image/src/imgStatusTracker.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "imgStatusTracker.h"
   8
   9 #include "imgIContainer.h"
  10 #include "imgRequestProxy.h"
  11 #include "imgDecoderObserver.h"
  12 #include "Image.h"
  13 #include "ImageLogging.h"
  14 #include "RasterImage.h"
  15 #include "nsIObserverService.h"
  16 #include "RasterImage.h"
  17
  18 #include "mozilla/Util.h"
  19 #include "mozilla/Assertions.h"
  20 #include "mozilla/Services.h"
  21
  22 using namespace mozilla::image;
  23
  24 class imgStatusTrackerNotifyingObserver : public imgDecoderObserver
  25 {
  26 public:
  27   imgStatusTrackerNotifyingObserver(imgStatusTracker* aTracker)
  28   : mTracker(aTracker) {}
  29
  30   virtual ~imgStatusTrackerNotifyingObserver() {}
  31
  32   void SetTracker(imgStatusTracker* aTracker) {
  33     mTracker = aTracker;
  34   }
  35
  36   /** imgDecoderObserver methods **/
  37
  38   virtual void OnStartDecode()
  39   {
  40     LOG_SCOPE(GetImgLog(), "imgStatusTrackerNotifyingObserver::OnStartDecode");
  41     NS_ABORT_IF_FALSE(mTracker->GetImage(),
  42                       "OnStartDecode callback before we've created our image");
  43
  44     mTracker->RecordStartDecode();
  45
  46     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
  47     while (iter.HasMore()) {
  48       mTracker->SendStartDecode(iter.GetNext());
  49     }
  50
  51     if (!mTracker->IsMultipart()) {
  52       mTracker->RecordBlockOnload();
  53
  54       nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
  55       while (iter.HasMore()) {
  56         mTracker->SendBlockOnload(iter.GetNext());
  57       }
  58     }
  59   }
  60
  61   virtual void OnStartRequest()
  62   {
  63     NS_NOTREACHED("imgStatusTrackerNotifyingObserver(imgDecoderObserver)::OnStartRequest");
  64   }
  65
  66   virtual void OnStartContainer()
  67   {
  68     LOG_SCOPE(GetImgLog(), "imgStatusTrackerNotifyingObserver::OnStartContainer");
  69
  70     NS_ABORT_IF_FALSE(mTracker->GetImage(),
  71                       "OnStartContainer callback before we've created our image");
  72     mTracker->RecordStartContainer(mTracker->GetImage());
  73
  74     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
  75     while (iter.HasMore()) {
  76       mTracker->SendStartContainer(iter.GetNext());
  77     }
  78   }
  79
  80   virtual void OnStartFrame()
  81   {
  82     LOG_SCOPE(GetImgLog(), "imgStatusTrackerNotifyingObserver::OnStartFrame");
  83     NS_ABORT_IF_FALSE(mTracker->GetImage(),
  84                       "OnStartFrame callback before we've created our image");
  85
  86     mTracker->RecordStartFrame();
  87
  88     // This is not observed below the imgStatusTracker level, so we don't need
  89     // to SendStartFrame.
  90   }
  91
  92   virtual void FrameChanged(const nsIntRect* dirtyRect)
  93   {
  94     LOG_SCOPE(GetImgLog(), "imgStatusTrackerNotifyingObserver::FrameChanged");
  95     NS_ABORT_IF_FALSE(mTracker->GetImage(),
  96                       "FrameChanged callback before we've created our image");
  97
  98     mTracker->RecordFrameChanged(dirtyRect);
  99
 100     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
 101     while (iter.HasMore()) {
 102       mTracker->SendFrameChanged(iter.GetNext(), dirtyRect);
 103     }
 104   }
 105
 106   virtual void OnStopFrame()
 107   {
 108     LOG_SCOPE(GetImgLog(), "imgStatusTrackerNotifyingObserver::OnStopFrame");
 109     NS_ABORT_IF_FALSE(mTracker->GetImage(),
 110                       "OnStopFrame callback before we've created our image");
 111
 112     mTracker->RecordStopFrame();
 113
 114     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
 115     while (iter.HasMore()) {
 116       mTracker->SendStopFrame(iter.GetNext());
 117     }
 118
 119     mTracker->MaybeUnblockOnload();
 120   }
 121
 122   virtual void OnStopDecode(nsresult aStatus)
 123   {
 124     LOG_SCOPE(GetImgLog(), "imgStatusTrackerNotifyingObserver::OnStopDecode");
 125     NS_ABORT_IF_FALSE(mTracker->GetImage(),
 126                       "OnStopDecode callback before we've created our image");
 127
 128     bool preexistingError = mTracker->GetImageStatus() == imgIRequest::STATUS_ERROR;
 129
 130     mTracker->RecordStopDecode(aStatus);
 131
 132     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
 133     while (iter.HasMore()) {
 134       mTracker->SendStopDecode(iter.GetNext(), aStatus);
 135     }
 136
 137     // This is really hacky. We need to handle the case where we start decoding,
 138     // block onload, but then hit an error before we get to our first frame.
 139     mTracker->MaybeUnblockOnload();
 140
 141     if (NS_FAILED(aStatus) && !preexistingError) {
 142       mTracker->FireFailureNotification();
 143     }
 144   }
 145
 146   virtual void OnStopRequest(bool aLastPart, nsresult aStatus)
 147   {
 148     NS_NOTREACHED("imgStatusTrackerNotifyingObserver(imgDecoderObserver)::OnStopRequest");
 149   }
 150
 151   virtual void OnDiscard()
 152   {
 153     NS_ABORT_IF_FALSE(mTracker->GetImage(),
 154                       "OnDiscard callback before we've created our image");
 155
 156     mTracker->RecordDiscard();
 157
 158     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
 159     while (iter.HasMore()) {
 160       mTracker->SendDiscard(iter.GetNext());
 161     }
 162   }
 163
 164   virtual void OnUnlockedDraw()
 165   {
 166     NS_ABORT_IF_FALSE(mTracker->GetImage(),
 167                       "OnUnlockedDraw callback before we've created our image");
 168     mTracker->RecordUnlockedDraw();
 169
 170     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
 171     while (iter.HasMore()) {
 172       mTracker->SendUnlockedDraw(iter.GetNext());
 173     }
 174   }
 175
 176   virtual void OnImageIsAnimated()
 177   {
 178     NS_ABORT_IF_FALSE(mTracker->GetImage(),
 179                       "OnImageIsAnimated callback before we've created our image");
 180     mTracker->RecordImageIsAnimated();
 181
 182     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mTracker->mConsumers);
 183     while (iter.HasMore()) {
 184       mTracker->SendImageIsAnimated(iter.GetNext());
 185     }
 186   }
 187
 188   virtual void OnError()
 189   {
 190     mTracker->RecordError();
 191   }
 192
 193 private:
 194   imgStatusTracker* mTracker;
 195 };
 196
 197 class imgStatusTrackerObserver : public imgDecoderObserver
 198 {
 199 public:
 200   imgStatusTrackerObserver(imgStatusTracker* aTracker)
 201   : mTracker(aTracker) {}
 202
 203   virtual ~imgStatusTrackerObserver() {}
 204
 205   void SetTracker(imgStatusTracker* aTracker) {
 206     mTracker = aTracker;
 207   }
 208
 209   /** imgDecoderObserver methods **/
 210
 211   virtual void OnStartDecode() MOZ_OVERRIDE
 212   {
 213     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStartDecode");
 214     mTracker->RecordStartDecode();
 215     if (!mTracker->IsMultipart()) {
 216       mTracker->RecordBlockOnload();
 217     }
 218   }
 219
 220   virtual void OnStartRequest() MOZ_OVERRIDE
 221   {
 222     NS_NOTREACHED("imgStatusTrackerObserver(imgDecoderObserver)::OnStartRequest");
 223   }
 224
 225   virtual void OnStartContainer() MOZ_OVERRIDE
 226   {
 227     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStartContainer");
 228     mTracker->RecordStartContainer(mTracker->GetImage());
 229   }
 230
 231   virtual void OnStartFrame() MOZ_OVERRIDE
 232   {
 233     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStartFrame");
 234     mTracker->RecordStartFrame();
 235   }
 236
 237   virtual void FrameChanged(const nsIntRect* dirtyRect) MOZ_OVERRIDE
 238   {
 239     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::FrameChanged");
 240     mTracker->RecordFrameChanged(dirtyRect);
 241   }
 242
 243   virtual void OnStopFrame() MOZ_OVERRIDE
 244   {
 245     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStopFrame");
 246     mTracker->RecordStopFrame();
 247     mTracker->RecordUnblockOnload();
 248   }
 249
 250   virtual void OnStopDecode(nsresult aStatus) MOZ_OVERRIDE
 251   {
 252     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStopDecode");
 253     mTracker->RecordStopDecode(aStatus);
 254
 255     // This is really hacky. We need to handle the case where we start decoding,
 256     // block onload, but then hit an error before we get to our first frame.
 257     mTracker->RecordUnblockOnload();
 258   }
 259
 260   virtual void OnStopRequest(bool aLastPart, nsresult aStatus) MOZ_OVERRIDE
 261   {
 262     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStopRequest");
 263     mTracker->RecordStopRequest(aLastPart, aStatus);
 264   }
 265
 266   virtual void OnDiscard() MOZ_OVERRIDE
 267   {
 268     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnDiscard");
 269     mTracker->RecordDiscard();
 270   }
 271
 272   virtual void OnUnlockedDraw() MOZ_OVERRIDE
 273   {
 274     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnUnlockedDraw");
 275     NS_ABORT_IF_FALSE(mTracker->GetImage(),
 276                       "OnUnlockedDraw callback before we've created our image");
 277     mTracker->RecordUnlockedDraw();
 278   }
 279
 280   virtual void OnImageIsAnimated() MOZ_OVERRIDE
 281   {
 282     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnImageIsAnimated");
 283     mTracker->RecordImageIsAnimated();
 284   }
 285
 286   virtual void OnError() MOZ_OVERRIDE
 287   {
 288     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnError");
 289     mTracker->RecordError();
 290   }
 291
 292 private:
 293   imgStatusTracker* mTracker;
 294 };
 295
 296 // imgStatusTracker methods
 297
 298 imgStatusTracker::imgStatusTracker(Image* aImage)
 299   : mImage(aImage),
 300     mState(0),
 301     mImageStatus(imgIRequest::STATUS_NONE),
 302     mIsMultipart(false),
 303     mHadLastPart(false),
 304     mHasBeenDecoded(false)
 305 {
 306   mTrackerObserver = new imgStatusTrackerObserver(this);
 307 }
 308
 309 // Private, used only by CloneForRecording.
 310 imgStatusTracker::imgStatusTracker(const imgStatusTracker& aOther)
 311   : mImage(aOther.mImage),
 312     mState(aOther.mState),
 313     mImageStatus(aOther.mImageStatus),
 314     mIsMultipart(aOther.mIsMultipart),
 315     mHadLastPart(aOther.mHadLastPart),
 316     mHasBeenDecoded(aOther.mHasBeenDecoded)
 317     // Note: we explicitly don't copy several fields:
 318     //  - mRequestRunnable, because it won't be nulled out when the
 319     //    mRequestRunnable's Run function eventually gets called.
 320     //  - mProperties, because we don't need it and it'd just point at the same
 321     //    object
 322     //  - mConsumers, because we don't need to talk to consumers
 323     //  - mInvalidRect, because the point of it is to be fired off and reset
 324 {
 325   mTrackerObserver = new imgStatusTrackerObserver(this);
 326 }
 327
 328 imgStatusTracker::~imgStatusTracker()
 329 {}
 330
 331 void
 332 imgStatusTracker::SetImage(Image* aImage)
 333 {
 334   NS_ABORT_IF_FALSE(aImage, "Setting null image");
 335   NS_ABORT_IF_FALSE(!mImage, "Setting image when we already have one");
 336   mImage = aImage;
 337 }
 338
 339 bool
 340 imgStatusTracker::IsLoading() const
 341 {
 342   // Checking for whether OnStopRequest has fired allows us to say we're
 343   // loading before OnStartRequest gets called, letting the request properly
 344   // get removed from the cache in certain cases.
 345   return !(mState & stateRequestStopped);
 346 }
 347
 348 uint32_t
 349 imgStatusTracker::GetImageStatus() const
 350 {
 351   return mImageStatus;
 352 }
 353
 354 // A helper class to allow us to call SyncNotify asynchronously.
 355 class imgRequestNotifyRunnable : public nsRunnable
 356 {
 357   public:
 358     imgRequestNotifyRunnable(imgStatusTracker* aTracker, imgRequestProxy* aRequestProxy)
 359       : mTracker(aTracker)
 360     {
 361       mProxies.AppendElement(aRequestProxy);
 362     }
 363
 364     NS_IMETHOD Run()
 365     {
 366       for (uint32_t i = 0; i < mProxies.Length(); ++i) {
 367         mProxies[i]->SetNotificationsDeferred(false);
 368         mTracker->SyncNotify(mProxies[i]);
 369       }
 370
 371       mTracker->mRequestRunnable = nullptr;
 372       return NS_OK;
 373     }
 374
 375     void AddProxy(imgRequestProxy* aRequestProxy)
 376     {
 377       mProxies.AppendElement(aRequestProxy);
 378     }
 379
 380     void RemoveProxy(imgRequestProxy* aRequestProxy)
 381     {
 382       mProxies.RemoveElement(aRequestProxy);
 383     }
 384
 385   private:
 386     friend class imgStatusTracker;
 387
 388     nsRefPtr<imgStatusTracker> mTracker;
 389     nsTArray< nsRefPtr<imgRequestProxy> > mProxies;
 390 };
 391
 392 void
 393 imgStatusTracker::Notify(imgRequestProxy* proxy)
 394 {
 395 #ifdef PR_LOGGING
 396   if (GetImage() && GetImage()->GetURI()) {
 397     nsCOMPtr<nsIURI> uri(GetImage()->GetURI());
 398     nsAutoCString spec;
 399     uri->GetSpec(spec);
 400     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgStatusTracker::Notify async", "uri", spec.get());
 401   } else {
 402     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgStatusTracker::Notify async", "uri", "<unknown>");
 403   }
 404 #endif
 405
 406   proxy->SetNotificationsDeferred(true);
 407
 408   // If we have an existing runnable that we can use, we just append this proxy
 409   // to its list of proxies to be notified. This ensures we don't unnecessarily
 410   // delay onload.
 411   imgRequestNotifyRunnable* runnable = static_cast<imgRequestNotifyRunnable*>(mRequestRunnable.get());
 412   if (runnable) {
 413     runnable->AddProxy(proxy);
 414   } else {
 415     mRequestRunnable = new imgRequestNotifyRunnable(this, proxy);
 416     NS_DispatchToCurrentThread(mRequestRunnable);
 417   }
 418 }
 419
 420 // A helper class to allow us to call SyncNotify asynchronously for a given,
 421 // fixed, state.
 422 class imgStatusNotifyRunnable : public nsRunnable
 423 {
 424   public:
 425     imgStatusNotifyRunnable(imgStatusTracker& status,
 426                             imgRequestProxy* requestproxy)
 427       : mStatus(status), mImage(status.mImage), mProxy(requestproxy)
 428     {}
 429
 430     NS_IMETHOD Run()
 431     {
 432       mProxy->SetNotificationsDeferred(false);
 433
 434       mStatus.SyncNotify(mProxy);
 435       return NS_OK;
 436     }
 437
 438   private:
 439     imgStatusTracker mStatus;
 440     // We have to hold on to a reference to the tracker's image, just in case
 441     // it goes away while we're in the event queue.
 442     nsRefPtr<Image> mImage;
 443     nsRefPtr<imgRequestProxy> mProxy;
 444 };
 445
 446 void
 447 imgStatusTracker::NotifyCurrentState(imgRequestProxy* proxy)
 448 {
 449 #ifdef PR_LOGGING
 450   nsCOMPtr<nsIURI> uri;
 451   proxy->GetURI(getter_AddRefs(uri));
 452   nsAutoCString spec;
 453   uri->GetSpec(spec);
 454   LOG_FUNC_WITH_PARAM(GetImgLog(), "imgStatusTracker::NotifyCurrentState", "uri", spec.get());
 455 #endif
 456
 457   proxy->SetNotificationsDeferred(true);
 458
 459   // We don't keep track of
 460   nsCOMPtr<nsIRunnable> ev = new imgStatusNotifyRunnable(*this, proxy);
 461   NS_DispatchToCurrentThread(ev);
 462 }
 463
 464 #define NOTIFY_IMAGE_OBSERVERS(func) \
 465   do { \
 466     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(proxies); \
 467     while (iter.HasMore()) { \
 468       nsRefPtr<imgRequestProxy> proxy = iter.GetNext(); \
 469       if (!proxy->NotificationsDeferred()) { \
 470         proxy->func; \
 471       } \
 472     } \
 473   } while (false);
 474
 475 /* static */ void
 476 imgStatusTracker::SyncNotifyState(nsTObserverArray<imgRequestProxy*>& proxies,
 477                                   bool hasImage, uint32_t state,
 478                                   nsIntRect& dirtyRect, bool hadLastPart)
 479 {
 480   // OnStartRequest
 481   if (state & stateRequestStarted)
 482     NOTIFY_IMAGE_OBSERVERS(OnStartRequest());
 483
 484   // OnStartContainer
 485   if (state & stateHasSize)
 486     NOTIFY_IMAGE_OBSERVERS(OnStartContainer());
 487
 488   // OnStartDecode
 489   if (state & stateDecodeStarted)
 490     NOTIFY_IMAGE_OBSERVERS(OnStartDecode());
 491
 492   // BlockOnload
 493   if (state & stateBlockingOnload)
 494     NOTIFY_IMAGE_OBSERVERS(BlockOnload());
 495
 496   if (hasImage) {
 497     // OnFrameUpdate
 498     // If there's any content in this frame at all (always true for
 499     // vector images, true for raster images that have decoded at
 500     // least one frame) then send OnFrameUpdate.
 501     if (!dirtyRect.IsEmpty())
 502       NOTIFY_IMAGE_OBSERVERS(OnFrameUpdate(&dirtyRect));
 503
 504     if (state & stateFrameStopped)
 505       NOTIFY_IMAGE_OBSERVERS(OnStopFrame());
 506
 507     // OnImageIsAnimated
 508     if (state & stateImageIsAnimated)
 509       NOTIFY_IMAGE_OBSERVERS(OnImageIsAnimated());
 510   }
 511
 512   if (state & stateDecodeStopped) {
 513     NS_ABORT_IF_FALSE(hasImage, "stopped decoding without ever having an image?");
 514     NOTIFY_IMAGE_OBSERVERS(OnStopDecode());
 515   }
 516
 517   if (state & stateRequestStopped) {
 518     NOTIFY_IMAGE_OBSERVERS(OnStopRequest(hadLastPart));
 519   }
 520 }
 521
 522 imgStatusTracker::StatusDiff
 523 imgStatusTracker::CalculateAndApplyDifference(imgStatusTracker* other)
 524 {
 525   LOG_SCOPE(GetImgLog(), "imgStatusTracker::SyncAndCalculateDifference");
 526
 527   // We must not modify or notify for the start-load state, which happens from Necko callbacks.
 528   uint32_t loadState = mState & stateRequestStarted;
 529
 530   StatusDiff diff;
 531   diff.mDiffState = ~mState & other->mState & ~stateRequestStarted;
 532   diff.mUnblockedOnload = mState & stateBlockingOnload && !(other->mState & stateBlockingOnload);
 533   diff.mFoundError = (mImageStatus != imgIRequest::STATUS_ERROR) && (other->mImageStatus == imgIRequest::STATUS_ERROR);
 534
 535   // Now that we've calculated the difference in state, synchronize our state
 536   // with the other tracker.
 537
 538   // First, actually synchronize our state.
 539   mState |= diff.mDiffState | loadState;
 540   if (diff.mUnblockedOnload) {
 541     mState &= ~stateBlockingOnload;
 542   }
 543
 544   mIsMultipart = other->mIsMultipart;
 545   mHadLastPart = other->mHadLastPart;
 546   mImageStatus |= other->mImageStatus;
 547   mHasBeenDecoded = mHasBeenDecoded || other->mHasBeenDecoded;
 548
 549   // The error state is sticky and overrides all other bits.
 550   if (mImageStatus & imgIRequest::STATUS_ERROR) {
 551     mImageStatus = imgIRequest::STATUS_ERROR;
 552   } else {
 553     // Unset the bits that can get unset as part of the decoding process.
 554     if (!(other->mImageStatus & imgIRequest::STATUS_DECODE_STARTED)) {
 555       mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
 556     }
 557   }
 558
 559   // Only record partial invalidations if we haven't been decoded before.
 560   // When images are re-decoded after discarding, we don't want to display
 561   // partially decoded versions to the user.
 562   bool doInvalidations  = !mHasBeenDecoded
 563                        || mImageStatus & imgIRequest::STATUS_ERROR
 564                        || mImageStatus & imgIRequest::STATUS_DECODE_COMPLETE;
 565
 566   // Record the invalid rectangles and reset them for another go.
 567   if (doInvalidations) {
 568     diff.mInvalidRect = mInvalidRect.Union(other->mInvalidRect);
 569     other->mInvalidRect.SetEmpty();
 570     mInvalidRect.SetEmpty();
 571   }
 572
 573   return diff;
 574 }
 575
 576 void
 577 imgStatusTracker::SyncNotifyDifference(imgStatusTracker::StatusDiff diff)
 578 {
 579   LOG_SCOPE(GetImgLog(), "imgStatusTracker::SyncNotifyDifference");
 580
 581   SyncNotifyState(mConsumers, !!mImage, diff.mDiffState, diff.mInvalidRect, mHadLastPart);
 582
 583   if (diff.mUnblockedOnload) {
 584     nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 585     while (iter.HasMore()) {
 586       // Hold on to a reference to this proxy, since notifying the state can
 587       // cause it to disappear.
 588       nsRefPtr<imgRequestProxy> proxy = iter.GetNext();
 589
 590       if (!proxy->NotificationsDeferred()) {
 591         SendUnblockOnload(proxy);
 592       }
 593     }
 594   }
 595
 596   if (diff.mFoundError) {
 597     FireFailureNotification();
 598   }
 599 }
 600
 601 imgStatusTracker*
 602 imgStatusTracker::CloneForRecording()
 603 {
 604   imgStatusTracker* clone = new imgStatusTracker(*this);
 605   return clone;
 606 }
 607
 608 void
 609 imgStatusTracker::SyncNotify(imgRequestProxy* proxy)
 610 {
 611 #ifdef PR_LOGGING
 612   nsCOMPtr<nsIURI> uri;
 613   proxy->GetURI(getter_AddRefs(uri));
 614   nsAutoCString spec;
 615   uri->GetSpec(spec);
 616   LOG_SCOPE_WITH_PARAM(GetImgLog(), "imgStatusTracker::SyncNotify", "uri", spec.get());
 617 #endif
 618
 619   nsIntRect r;
 620   if (mImage) {
 621     // XXX - Should only send partial rects here, but that needs to
 622     // wait until we fix up the observer interface
 623     r = mImage->FrameRect(imgIContainer::FRAME_CURRENT);
 624   }
 625
 626   nsTObserverArray<imgRequestProxy*> array;
 627   array.AppendElement(proxy);
 628   SyncNotifyState(array, !!mImage, mState, r, mHadLastPart);
 629 }
 630
 631 void
 632 imgStatusTracker::SyncNotifyDecodeState()
 633 {
 634   LOG_SCOPE(GetImgLog(), "imgStatusTracker::SyncNotifyDecodeState");
 635
 636   SyncNotifyState(mConsumers, !!mImage, mState & ~stateRequestStarted, mInvalidRect, mHadLastPart);
 637
 638   mInvalidRect.SetEmpty();
 639 }
 640
 641 void
 642 imgStatusTracker::EmulateRequestFinished(imgRequestProxy* aProxy,
 643                                          nsresult aStatus)
 644 {
 645   nsCOMPtr<imgIRequest> kungFuDeathGrip(aProxy);
 646
 647   // In certain cases the request might not have started yet.
 648   // We still need to fulfill the contract.
 649   if (!(mState & stateRequestStarted)) {
 650     aProxy->OnStartRequest();
 651   }
 652
 653   if (mState & stateBlockingOnload) {
 654     aProxy->UnblockOnload();
 655   }
 656
 657   if (!(mState & stateRequestStopped)) {
 658     aProxy->OnStopRequest(true);
 659   }
 660 }
 661
 662 void
 663 imgStatusTracker::AddConsumer(imgRequestProxy* aConsumer)
 664 {
 665   mConsumers.AppendElementUnlessExists(aConsumer);
 666 }
 667
 668 // XXX - The last argument should go away.
 669 bool
 670 imgStatusTracker::RemoveConsumer(imgRequestProxy* aConsumer, nsresult aStatus)
 671 {
 672   // Remove the proxy from the list.
 673   bool removed = mConsumers.RemoveElement(aConsumer);
 674
 675   // Consumers can get confused if they don't get all the proper teardown
 676   // notifications. Part ways on good terms.
 677   if (removed && !aConsumer->NotificationsDeferred()) {
 678     EmulateRequestFinished(aConsumer, aStatus);
 679   }
 680
 681   // Make sure we don't give callbacks to a consumer that isn't interested in
 682   // them any more.
 683   imgRequestNotifyRunnable* runnable = static_cast<imgRequestNotifyRunnable*>(mRequestRunnable.get());
 684   if (aConsumer->NotificationsDeferred() && runnable) {
 685     runnable->RemoveProxy(aConsumer);
 686     aConsumer->SetNotificationsDeferred(false);
 687   }
 688
 689   return removed;
 690 }
 691
 692 void
 693 imgStatusTracker::RecordCancel()
 694 {
 695   if (!(mImageStatus & imgIRequest::STATUS_LOAD_PARTIAL))
 696     mImageStatus = imgIRequest::STATUS_ERROR;
 697 }
 698
 699 void
 700 imgStatusTracker::RecordLoaded()
 701 {
 702   NS_ABORT_IF_FALSE(mImage, "RecordLoaded called before we have an Image");
 703   mState |= stateRequestStarted | stateHasSize | stateRequestStopped;
 704   mImageStatus |= imgIRequest::STATUS_SIZE_AVAILABLE | imgIRequest::STATUS_LOAD_COMPLETE;
 705   mHadLastPart = true;
 706 }
 707
 708 void
 709 imgStatusTracker::RecordDecoded()
 710 {
 711   NS_ABORT_IF_FALSE(mImage, "RecordDecoded called before we have an Image");
 712   mState |= stateDecodeStarted | stateDecodeStopped | stateFrameStopped;
 713   mImageStatus |= imgIRequest::STATUS_FRAME_COMPLETE | imgIRequest::STATUS_DECODE_COMPLETE;
 714   mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
 715 }
 716
 717 void
 718 imgStatusTracker::RecordStartDecode()
 719 {
 720   NS_ABORT_IF_FALSE(mImage, "RecordStartDecode without an Image");
 721   mState |= stateDecodeStarted;
 722   mImageStatus |= imgIRequest::STATUS_DECODE_STARTED;
 723 }
 724
 725 void
 726 imgStatusTracker::SendStartDecode(imgRequestProxy* aProxy)
 727 {
 728   if (!aProxy->NotificationsDeferred())
 729     aProxy->OnStartDecode();
 730 }
 731
 732 void
 733 imgStatusTracker::RecordStartContainer(imgIContainer* aContainer)
 734 {
 735   NS_ABORT_IF_FALSE(mImage,
 736                     "RecordStartContainer called before we have an Image");
 737   NS_ABORT_IF_FALSE(mImage == aContainer,
 738                     "RecordStartContainer called with wrong Image");
 739   mState |= stateHasSize;
 740   mImageStatus |= imgIRequest::STATUS_SIZE_AVAILABLE;
 741 }
 742
 743 void
 744 imgStatusTracker::SendStartContainer(imgRequestProxy* aProxy)
 745 {
 746   if (!aProxy->NotificationsDeferred())
 747     aProxy->OnStartContainer();
 748 }
 749
 750 void
 751 imgStatusTracker::RecordStartFrame()
 752 {
 753   mInvalidRect.SetEmpty();
 754 }
 755
 756 // No SendStartFrame since it's not observed below us.
 757
 758 void
 759 imgStatusTracker::RecordStopFrame()
 760 {
 761   NS_ABORT_IF_FALSE(mImage, "RecordStopFrame called before we have an Image");
 762   mState |= stateFrameStopped;
 763   mImageStatus |= imgIRequest::STATUS_FRAME_COMPLETE;
 764 }
 765
 766 void
 767 imgStatusTracker::SendStopFrame(imgRequestProxy* aProxy)
 768 {
 769   if (!aProxy->NotificationsDeferred())
 770     aProxy->OnStopFrame();
 771 }
 772
 773 void
 774 imgStatusTracker::RecordStopDecode(nsresult aStatus)
 775 {
 776   NS_ABORT_IF_FALSE(mImage,
 777                     "RecordStopDecode called before we have an Image");
 778   mState |= stateDecodeStopped;
 779
 780   if (NS_SUCCEEDED(aStatus) && mImageStatus != imgIRequest::STATUS_ERROR) {
 781     mImageStatus |= imgIRequest::STATUS_DECODE_COMPLETE;
 782     mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
 783     mHasBeenDecoded = true;
 784   // If we weren't successful, clear all success status bits and set error.
 785   } else {
 786     mImageStatus = imgIRequest::STATUS_ERROR;
 787   }
 788 }
 789
 790 void
 791 imgStatusTracker::SendStopDecode(imgRequestProxy* aProxy,
 792                                  nsresult aStatus)
 793 {
 794   if (!aProxy->NotificationsDeferred())
 795     aProxy->OnStopDecode();
 796 }
 797
 798 void
 799 imgStatusTracker::RecordDiscard()
 800 {
 801   NS_ABORT_IF_FALSE(mImage,
 802                     "RecordDiscard called before we have an Image");
 803   // Clear the state bits we no longer deserve.
 804   uint32_t stateBitsToClear = stateDecodeStopped;
 805   mState &= ~stateBitsToClear;
 806
 807   // Clear the status bits we no longer deserve.
 808   uint32_t statusBitsToClear = imgIRequest::STATUS_DECODE_STARTED |
 809                                imgIRequest::STATUS_FRAME_COMPLETE |
 810                                imgIRequest::STATUS_DECODE_COMPLETE;
 811   mImageStatus &= ~statusBitsToClear;
 812 }
 813
 814 void
 815 imgStatusTracker::SendDiscard(imgRequestProxy* aProxy)
 816 {
 817   if (!aProxy->NotificationsDeferred())
 818     aProxy->OnDiscard();
 819 }
 820
 821
 822 void
 823 imgStatusTracker::RecordUnlockedDraw()
 824 {
 825   NS_ABORT_IF_FALSE(mImage,
 826                     "RecordUnlockedDraw called before we have an Image");
 827 }
 828
 829 void
 830 imgStatusTracker::RecordImageIsAnimated()
 831 {
 832   NS_ABORT_IF_FALSE(mImage,
 833                     "RecordImageIsAnimated called before we have an Image");
 834   mState |= stateImageIsAnimated;
 835 }
 836
 837 void
 838 imgStatusTracker::SendImageIsAnimated(imgRequestProxy* aProxy)
 839 {
 840   if (!aProxy->NotificationsDeferred())
 841     aProxy->OnImageIsAnimated();
 842 }
 843
 844 void
 845 imgStatusTracker::SendUnlockedDraw(imgRequestProxy* aProxy)
 846 {
 847   if (!aProxy->NotificationsDeferred())
 848     aProxy->OnUnlockedDraw();
 849 }
 850
 851 void
 852 imgStatusTracker::OnUnlockedDraw()
 853 {
 854   RecordUnlockedDraw();
 855   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 856   while (iter.HasMore()) {
 857     SendUnlockedDraw(iter.GetNext());
 858   }
 859 }
 860
 861 void
 862 imgStatusTracker::RecordFrameChanged(const nsIntRect* aDirtyRect)
 863 {
 864   NS_ABORT_IF_FALSE(mImage,
 865                     "RecordFrameChanged called before we have an Image");
 866   mInvalidRect = mInvalidRect.Union(*aDirtyRect);
 867 }
 868
 869 void
 870 imgStatusTracker::SendFrameChanged(imgRequestProxy* aProxy,
 871                                    const nsIntRect* aDirtyRect)
 872 {
 873   if (!aProxy->NotificationsDeferred())
 874     aProxy->OnFrameUpdate(aDirtyRect);
 875 }
 876
 877 /* non-virtual sort-of-nsIRequestObserver methods */
 878 void
 879 imgStatusTracker::RecordStartRequest()
 880 {
 881   // We're starting a new load, so clear any status and state bits indicating
 882   // load/decode
 883   mImageStatus &= ~imgIRequest::STATUS_LOAD_PARTIAL;
 884   mImageStatus &= ~imgIRequest::STATUS_LOAD_COMPLETE;
 885   mImageStatus &= ~imgIRequest::STATUS_FRAME_COMPLETE;
 886   mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
 887   mImageStatus &= ~imgIRequest::STATUS_DECODE_COMPLETE;
 888   mState &= ~stateRequestStarted;
 889   mState &= ~stateDecodeStarted;
 890   mState &= ~stateDecodeStopped;
 891   mState &= ~stateRequestStopped;
 892   mState &= ~stateBlockingOnload;
 893   mState &= ~stateImageIsAnimated;
 894
 895   mState |= stateRequestStarted;
 896 }
 897
 898 void
 899 imgStatusTracker::SendStartRequest(imgRequestProxy* aProxy)
 900 {
 901   if (!aProxy->NotificationsDeferred())
 902     aProxy->OnStartRequest();
 903 }
 904
 905 void
 906 imgStatusTracker::OnStartRequest()
 907 {
 908   RecordStartRequest();
 909   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 910   while (iter.HasMore()) {
 911     SendStartRequest(iter.GetNext());
 912   }
 913 }
 914
 915 void
 916 imgStatusTracker::RecordStopRequest(bool aLastPart,
 917                                     nsresult aStatus)
 918 {
 919   mHadLastPart = aLastPart;
 920   mState |= stateRequestStopped;
 921
 922   // If we were successful in loading, note that the image is complete.
 923   if (NS_SUCCEEDED(aStatus) && mImageStatus != imgIRequest::STATUS_ERROR)
 924     mImageStatus |= imgIRequest::STATUS_LOAD_COMPLETE;
 925   else
 926     mImageStatus = imgIRequest::STATUS_ERROR;
 927 }
 928
 929 void
 930 imgStatusTracker::SendStopRequest(imgRequestProxy* aProxy,
 931                                   bool aLastPart,
 932                                   nsresult aStatus)
 933 {
 934   if (!aProxy->NotificationsDeferred()) {
 935     aProxy->OnStopRequest(aLastPart);
 936   }
 937 }
 938
 939 void
 940 imgStatusTracker::OnStopRequest(bool aLastPart,
 941                                 nsresult aStatus)
 942 {
 943   bool preexistingError = mImageStatus == imgIRequest::STATUS_ERROR;
 944
 945   RecordStopRequest(aLastPart, aStatus);
 946   /* notify the kids */
 947   nsTObserverArray<imgRequestProxy*>::ForwardIterator srIter(mConsumers);
 948   while (srIter.HasMore()) {
 949     SendStopRequest(srIter.GetNext(), aLastPart, aStatus);
 950   }
 951
 952   if (NS_FAILED(aStatus) && !preexistingError) {
 953     FireFailureNotification();
 954   }
 955 }
 956
 957 void
 958 imgStatusTracker::OnDiscard()
 959 {
 960   RecordDiscard();
 961
 962   /* notify the kids */
 963   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 964   while (iter.HasMore()) {
 965     SendDiscard(iter.GetNext());
 966   }
 967 }
 968
 969 void
 970 imgStatusTracker::FrameChanged(const nsIntRect* aDirtyRect)
 971 {
 972   RecordFrameChanged(aDirtyRect);
 973
 974   /* notify the kids */
 975   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 976   while (iter.HasMore()) {
 977     SendFrameChanged(iter.GetNext(), aDirtyRect);
 978   }
 979 }
 980
 981 void
 982 imgStatusTracker::OnStopFrame()
 983 {
 984   RecordStopFrame();
 985
 986   /* notify the kids */
 987   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 988   while (iter.HasMore()) {
 989     SendStopFrame(iter.GetNext());
 990   }
 991 }
 992
 993 void
 994 imgStatusTracker::OnDataAvailable()
 995 {
 996   // Notify any imgRequestProxys that are observing us that we have an Image.
 997   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
 998   while (iter.HasMore()) {
 999     iter.GetNext()->SetHasImage();
1000   }
1001 }
1002
1003 void
1004 imgStatusTracker::RecordBlockOnload()
1005 {
1006   MOZ_ASSERT(!(mState & stateBlockingOnload));
1007   mState |= stateBlockingOnload;
1008 }
1009
1010 void
1011 imgStatusTracker::SendBlockOnload(imgRequestProxy* aProxy)
1012 {
1013   if (!aProxy->NotificationsDeferred()) {
1014     aProxy->BlockOnload();
1015   }
1016 }
1017
1018 void
1019 imgStatusTracker::RecordUnblockOnload()
1020 {
1021   mState &= ~stateBlockingOnload;
1022 }
1023
1024 void
1025 imgStatusTracker::SendUnblockOnload(imgRequestProxy* aProxy)
1026 {
1027   if (!aProxy->NotificationsDeferred()) {
1028     aProxy->UnblockOnload();
1029   }
1030 }
1031
1032 void
1033 imgStatusTracker::MaybeUnblockOnload()
1034 {
1035   if (!(mState & stateBlockingOnload)) {
1036     return;
1037   }
1038
1039   RecordUnblockOnload();
1040
1041   nsTObserverArray<imgRequestProxy*>::ForwardIterator iter(mConsumers);
1042   while (iter.HasMore()) {
1043     SendUnblockOnload(iter.GetNext());
1044   }
1045 }
1046
1047 void
1048 imgStatusTracker::RecordError()
1049 {
1050   mImageStatus = imgIRequest::STATUS_ERROR;
1051 }
1052
1053 void
1054 imgStatusTracker::FireFailureNotification()
1055 {
1056   MOZ_ASSERT(NS_IsMainThread());
1057
1058   // Some kind of problem has happened with image decoding.
1059   // Report the URI to net:failed-to-process-uri-conent observers.
1060   if (GetImage()) {
1061     nsCOMPtr<nsIURI> uri = GetImage()->GetURI();
1062     if (uri) {
1063       nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
1064       if (os) {
1065         os->NotifyObservers(uri, "net:failed-to-process-uri-content", nullptr);
1066       }
1067     }
1068   }
1069 }