The Tor Browser: image/src/imgStatusTracker.cpp@b8a032363ba2 (annotated)

image/src/imgStatusTracker.cpp@b8a032363ba2 (annotated)

image/src/imgStatusTracker.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "imgStatusTracker.h"
 #include "imgIContainer.h"
 #include "imgRequestProxy.h"
 #include "imgDecoderObserver.h"
 #include "Image.h"
 #include "ImageLogging.h"
 #include "nsNetUtil.h"
 #include "nsIObserverService.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/Services.h"
 using namespace mozilla::image;
 using mozilla::WeakPtr;
 class imgStatusTrackerObserver : public imgDecoderObserver
 {
 public:
   imgStatusTrackerObserver(imgStatusTracker* aTracker)
   : mTracker(aTracker->asWeakPtr())
   {
     MOZ_ASSERT(aTracker);
   }
   void SetTracker(imgStatusTracker* aTracker)
   {
     MOZ_ASSERT(aTracker);
     mTracker = aTracker->asWeakPtr();
   }
   /** imgDecoderObserver methods **/
   virtual void OnStartDecode() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStartDecode");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordStartDecode();
     if (!tracker->IsMultipart()) {
       tracker->RecordBlockOnload();
     }
   }
   virtual void OnStartRequest() MOZ_OVERRIDE
   {
     NS_NOTREACHED("imgStatusTrackerObserver(imgDecoderObserver)::OnStartRequest");
   }
   virtual void OnStartContainer() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStartContainer");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     nsRefPtr<Image> image = tracker->GetImage();;
     tracker->RecordStartContainer(image);
   }
   virtual void OnStartFrame() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStartFrame");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordStartFrame();
   }
   virtual void FrameChanged(const nsIntRect* dirtyRect) MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::FrameChanged");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordFrameChanged(dirtyRect);
   }
   virtual void OnStopFrame() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStopFrame");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordStopFrame();
     tracker->RecordUnblockOnload();
   }
   virtual void OnStopDecode(nsresult aStatus) MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStopDecode");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordStopDecode(aStatus);
     // This is really hacky. We need to handle the case where we start decoding,
     // block onload, but then hit an error before we get to our first frame.
     tracker->RecordUnblockOnload();
   }
   virtual void OnStopRequest(bool aLastPart, nsresult aStatus) MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnStopRequest");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordStopRequest(aLastPart, aStatus);
   }
   virtual void OnDiscard() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnDiscard");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordDiscard();
   }
   virtual void OnUnlockedDraw() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnUnlockedDraw");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     NS_ABORT_IF_FALSE(tracker->HasImage(),
                       "OnUnlockedDraw callback before we've created our image");
     tracker->RecordUnlockedDraw();
   }
   virtual void OnImageIsAnimated() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnImageIsAnimated");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordImageIsAnimated();
   }
   virtual void OnError() MOZ_OVERRIDE
   {
     LOG_SCOPE(GetImgLog(), "imgStatusTrackerObserver::OnError");
     nsRefPtr<imgStatusTracker> tracker = mTracker.get();
     if (!tracker) { return; }
     tracker->RecordError();
   }
 protected:
   virtual ~imgStatusTrackerObserver() {}
 private:
   WeakPtr<imgStatusTracker> mTracker;
 };
 // imgStatusTracker methods
 imgStatusTracker::imgStatusTracker(Image* aImage)
   : mImage(aImage),
     mState(0),
     mImageStatus(imgIRequest::STATUS_NONE),
     mIsMultipart(false),
     mHadLastPart(false),
     mHasBeenDecoded(false)
 {
   mTrackerObserver = new imgStatusTrackerObserver(this);
 }
 // Private, used only by CloneForRecording.
 imgStatusTracker::imgStatusTracker(const imgStatusTracker& aOther)
   : mImage(aOther.mImage),
     mState(aOther.mState),
     mImageStatus(aOther.mImageStatus),
     mIsMultipart(aOther.mIsMultipart),
     mHadLastPart(aOther.mHadLastPart),
     mHasBeenDecoded(aOther.mHasBeenDecoded)
     // Note: we explicitly don't copy several fields:
     //  - mRequestRunnable, because it won't be nulled out when the
     //    mRequestRunnable's Run function eventually gets called.
     //  - mProperties, because we don't need it and it'd just point at the same
     //    object
     //  - mConsumers, because we don't need to talk to consumers
     //  - mInvalidRect, because the point of it is to be fired off and reset
 {
   mTrackerObserver = new imgStatusTrackerObserver(this);
 }
 imgStatusTracker::~imgStatusTracker()
 {}
 imgStatusTrackerInit::imgStatusTrackerInit(mozilla::image::Image* aImage,
                                            imgStatusTracker* aTracker)
 {
   MOZ_ASSERT(aImage);
   if (aTracker) {
     mTracker = aTracker;
     mTracker->SetImage(aImage);
   } else {
     mTracker = new imgStatusTracker(aImage);
   }
   aImage->SetStatusTracker(mTracker);
   MOZ_ASSERT(mTracker);
 }
 imgStatusTrackerInit::~imgStatusTrackerInit()
 {
   mTracker->ResetImage();
 }
 void
 imgStatusTracker::SetImage(Image* aImage)
 {
   NS_ABORT_IF_FALSE(aImage, "Setting null image");
   NS_ABORT_IF_FALSE(!mImage, "Setting image when we already have one");
   mImage = aImage;
 }
 void
 imgStatusTracker::ResetImage()
 {
   NS_ABORT_IF_FALSE(mImage, "Resetting image when it's already null!");
   mImage = nullptr;
 }
 bool
 imgStatusTracker::IsLoading() const
 {
   // Checking for whether OnStopRequest has fired allows us to say we're
   // loading before OnStartRequest gets called, letting the request properly
   // get removed from the cache in certain cases.
   return !(mState & stateRequestStopped);
 }
 uint32_t
 imgStatusTracker::GetImageStatus() const
 {
   return mImageStatus;
 }
 // A helper class to allow us to call SyncNotify asynchronously.
 class imgRequestNotifyRunnable : public nsRunnable
 {
   public:
     imgRequestNotifyRunnable(imgStatusTracker* aTracker,
                              imgRequestProxy* aRequestProxy)
       : mTracker(aTracker)
     {
       MOZ_ASSERT(NS_IsMainThread(), "Should be created on the main thread");
       MOZ_ASSERT(aRequestProxy, "aRequestProxy should not be null");
       MOZ_ASSERT(aTracker, "aTracker should not be null");
       mProxies.AppendElement(aRequestProxy);
     }
     NS_IMETHOD Run()
     {
       MOZ_ASSERT(NS_IsMainThread(), "Should be running on the main thread");
       MOZ_ASSERT(mTracker, "mTracker should not be null");
       for (uint32_t i = 0; i < mProxies.Length(); ++i) {
         mProxies[i]->SetNotificationsDeferred(false);
         mTracker->SyncNotify(mProxies[i]);
       }
       mTracker->mRequestRunnable = nullptr;
       return NS_OK;
     }
     void AddProxy(imgRequestProxy* aRequestProxy)
     {
       mProxies.AppendElement(aRequestProxy);
     }
     void RemoveProxy(imgRequestProxy* aRequestProxy)
     {
       mProxies.RemoveElement(aRequestProxy);
     }
   private:
     friend class imgStatusTracker;
     nsRefPtr<imgStatusTracker> mTracker;
     nsTArray< nsRefPtr<imgRequestProxy> > mProxies;
 };
 void
 imgStatusTracker::Notify(imgRequestProxy* proxy)
 {
   MOZ_ASSERT(NS_IsMainThread(), "imgRequestProxy is not threadsafe");
 #ifdef PR_LOGGING
   if (mImage && mImage->GetURI()) {
     nsRefPtr<ImageURL> uri(mImage->GetURI());
     nsAutoCString spec;
     uri->GetSpec(spec);
     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgStatusTracker::Notify async", "uri", spec.get());
   } else {
     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgStatusTracker::Notify async", "uri", "<unknown>");
   }
 #endif
   proxy->SetNotificationsDeferred(true);
   // If we have an existing runnable that we can use, we just append this proxy
   // to its list of proxies to be notified. This ensures we don't unnecessarily
   // delay onload.
   imgRequestNotifyRunnable* runnable = static_cast<imgRequestNotifyRunnable*>(mRequestRunnable.get());
   if (runnable) {
     runnable->AddProxy(proxy);
   } else {
     mRequestRunnable = new imgRequestNotifyRunnable(this, proxy);
     NS_DispatchToCurrentThread(mRequestRunnable);
   }
 }
 // A helper class to allow us to call SyncNotify asynchronously for a given,
 // fixed, state.
 class imgStatusNotifyRunnable : public nsRunnable
 {
   public:
     imgStatusNotifyRunnable(imgStatusTracker* statusTracker,
                             imgRequestProxy* requestproxy)
       : mStatusTracker(statusTracker), mProxy(requestproxy)
     {
       MOZ_ASSERT(NS_IsMainThread(), "Should be created on the main thread");
       MOZ_ASSERT(requestproxy, "requestproxy cannot be null");
       MOZ_ASSERT(statusTracker, "status should not be null");
       mImage = statusTracker->GetImage();
     }
     NS_IMETHOD Run()
     {
       MOZ_ASSERT(NS_IsMainThread(), "Should be running on the main thread");
       mProxy->SetNotificationsDeferred(false);
       mStatusTracker->SyncNotify(mProxy);
       return NS_OK;
     }
   private:
     nsRefPtr<imgStatusTracker> mStatusTracker;
     // We have to hold on to a reference to the tracker's image, just in case
     // it goes away while we're in the event queue.
     nsRefPtr<Image> mImage;
     nsRefPtr<imgRequestProxy> mProxy;
 };
 void
 imgStatusTracker::NotifyCurrentState(imgRequestProxy* proxy)
 {
   MOZ_ASSERT(NS_IsMainThread(), "imgRequestProxy is not threadsafe");
 #ifdef PR_LOGGING
   nsRefPtr<ImageURL> uri;
   proxy->GetURI(getter_AddRefs(uri));
   nsAutoCString spec;
   uri->GetSpec(spec);
   LOG_FUNC_WITH_PARAM(GetImgLog(), "imgStatusTracker::NotifyCurrentState", "uri", spec.get());
 #endif
   proxy->SetNotificationsDeferred(true);
   // We don't keep track of
   nsCOMPtr<nsIRunnable> ev = new imgStatusNotifyRunnable(this, proxy);
   NS_DispatchToCurrentThread(ev);
 }
 #define NOTIFY_IMAGE_OBSERVERS(func) \
   do { \
     ProxyArray::ForwardIterator iter(proxies); \
     while (iter.HasMore()) { \
       nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get(); \
       if (proxy && !proxy->NotificationsDeferred()) { \
         proxy->func; \
       } \
     } \
   } while (false);
 /* static */ void
 imgStatusTracker::SyncNotifyState(ProxyArray& proxies,
                                   bool hasImage, uint32_t state,
                                   nsIntRect& dirtyRect, bool hadLastPart)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // OnStartRequest
   if (state & stateRequestStarted)
     NOTIFY_IMAGE_OBSERVERS(OnStartRequest());
   // OnStartContainer
   if (state & stateHasSize)
     NOTIFY_IMAGE_OBSERVERS(OnStartContainer());
   // OnStartDecode
   if (state & stateDecodeStarted)
     NOTIFY_IMAGE_OBSERVERS(OnStartDecode());
   // BlockOnload
   if (state & stateBlockingOnload)
     NOTIFY_IMAGE_OBSERVERS(BlockOnload());
   if (hasImage) {
     // OnFrameUpdate
     // If there's any content in this frame at all (always true for
     // vector images, true for raster images that have decoded at
     // least one frame) then send OnFrameUpdate.
     if (!dirtyRect.IsEmpty())
       NOTIFY_IMAGE_OBSERVERS(OnFrameUpdate(&dirtyRect));
     if (state & stateFrameStopped)
       NOTIFY_IMAGE_OBSERVERS(OnStopFrame());
     // OnImageIsAnimated
     if (state & stateImageIsAnimated)
       NOTIFY_IMAGE_OBSERVERS(OnImageIsAnimated());
   }
   if (state & stateDecodeStopped) {
     NS_ABORT_IF_FALSE(hasImage, "stopped decoding without ever having an image?");
     NOTIFY_IMAGE_OBSERVERS(OnStopDecode());
   }
   if (state & stateRequestStopped) {
     NOTIFY_IMAGE_OBSERVERS(OnStopRequest(hadLastPart));
   }
 }
 ImageStatusDiff
 imgStatusTracker::Difference(imgStatusTracker* aOther) const
 {
   MOZ_ASSERT(aOther, "aOther cannot be null");
   ImageStatusDiff diff;
   diff.diffState = ~mState & aOther->mState & ~stateRequestStarted;
   diff.diffImageStatus = ~mImageStatus & aOther->mImageStatus;
   diff.unblockedOnload = mState & stateBlockingOnload && !(aOther->mState & stateBlockingOnload);
   diff.unsetDecodeStarted = mImageStatus & imgIRequest::STATUS_DECODE_STARTED
                          && !(aOther->mImageStatus & imgIRequest::STATUS_DECODE_STARTED);
   diff.foundError = (mImageStatus != imgIRequest::STATUS_ERROR)
                  && (aOther->mImageStatus == imgIRequest::STATUS_ERROR);
   MOZ_ASSERT(!mIsMultipart || aOther->mIsMultipart, "mIsMultipart should be monotonic");
   diff.foundIsMultipart = !mIsMultipart && aOther->mIsMultipart;
   diff.foundLastPart = !mHadLastPart && aOther->mHadLastPart;
   diff.gotDecoded = !mHasBeenDecoded && aOther->mHasBeenDecoded;
   // Only record partial invalidations if we haven't been decoded before.
   // When images are re-decoded after discarding, we don't want to display
   // partially decoded versions to the user.
   const uint32_t combinedStatus = mImageStatus | aOther->mImageStatus;
   const bool doInvalidations  = !(mHasBeenDecoded || aOther->mHasBeenDecoded)
                              || combinedStatus & imgIRequest::STATUS_ERROR
                              || combinedStatus & imgIRequest::STATUS_DECODE_COMPLETE;
   // Record and reset the invalid rectangle.
   // XXX(seth): We shouldn't be resetting anything here; see bug 910441.
   if (doInvalidations) {
     diff.invalidRect = aOther->mInvalidRect;
     aOther->mInvalidRect.SetEmpty();
   }
   return diff;
 }
 ImageStatusDiff
 imgStatusTracker::DecodeStateAsDifference() const
 {
   ImageStatusDiff diff;
   diff.diffState = mState & ~stateRequestStarted;
   // All other ImageStatusDiff fields are intentionally left at their default
   // values; we only want to notify decode state changes.
   return diff;
 }
 void
 imgStatusTracker::ApplyDifference(const ImageStatusDiff& aDiff)
 {
   LOG_SCOPE(GetImgLog(), "imgStatusTracker::ApplyDifference");
   // We must not modify or notify for the start-load state, which happens from Necko callbacks.
   uint32_t loadState = mState & stateRequestStarted;
   // Synchronize our state.
   mState |= aDiff.diffState | loadState;
   if (aDiff.unblockedOnload)
     mState &= ~stateBlockingOnload;
   mIsMultipart = mIsMultipart || aDiff.foundIsMultipart;
   mHadLastPart = mHadLastPart || aDiff.foundLastPart;
   mHasBeenDecoded = mHasBeenDecoded || aDiff.gotDecoded;
   // Update the image status. There are some subtle points which are handled below.
   mImageStatus |= aDiff.diffImageStatus;
   // Unset bits which can get unset as part of the decoding process.
   if (aDiff.unsetDecodeStarted)
     mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
   // The error state is sticky and overrides all other bits.
   if (mImageStatus & imgIRequest::STATUS_ERROR)
     mImageStatus = imgIRequest::STATUS_ERROR;
 }
 void
 imgStatusTracker::SyncNotifyDifference(const ImageStatusDiff& diff)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Use mConsumers on main thread only");
   LOG_SCOPE(GetImgLog(), "imgStatusTracker::SyncNotifyDifference");
   nsIntRect invalidRect = mInvalidRect.Union(diff.invalidRect);
   SyncNotifyState(mConsumers, !!mImage, diff.diffState, invalidRect, mHadLastPart);
   mInvalidRect.SetEmpty();
   if (diff.unblockedOnload) {
     ProxyArray::ForwardIterator iter(mConsumers);
     while (iter.HasMore()) {
       // Hold on to a reference to this proxy, since notifying the state can
       // cause it to disappear.
       nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
       if (proxy && !proxy->NotificationsDeferred()) {
         SendUnblockOnload(proxy);
       }
     }
   }
   if (diff.foundError) {
     FireFailureNotification();
   }
 }
 already_AddRefed<imgStatusTracker>
 imgStatusTracker::CloneForRecording()
 {
   // Grab a ref to this to ensure it isn't deleted.
   nsRefPtr<imgStatusTracker> thisStatusTracker = this;
   nsRefPtr<imgStatusTracker> clone = new imgStatusTracker(*thisStatusTracker);
   return clone.forget();
 }
 void
 imgStatusTracker::SyncNotify(imgRequestProxy* proxy)
 {
   MOZ_ASSERT(NS_IsMainThread(), "imgRequestProxy is not threadsafe");
 #ifdef PR_LOGGING
   nsRefPtr<ImageURL> uri;
   proxy->GetURI(getter_AddRefs(uri));
   nsAutoCString spec;
   uri->GetSpec(spec);
   LOG_SCOPE_WITH_PARAM(GetImgLog(), "imgStatusTracker::SyncNotify", "uri", spec.get());
 #endif
   nsIntRect r;
   if (mImage) {
     // XXX - Should only send partial rects here, but that needs to
     // wait until we fix up the observer interface
     r = mImage->FrameRect(imgIContainer::FRAME_CURRENT);
   }
   ProxyArray array;
   array.AppendElement(proxy->asWeakPtr());
   SyncNotifyState(array, !!mImage, mState, r, mHadLastPart);
 }
 void
 imgStatusTracker::EmulateRequestFinished(imgRequestProxy* aProxy,
                                          nsresult aStatus)
 {
   MOZ_ASSERT(NS_IsMainThread(),
              "SyncNotifyState and mConsumers are not threadsafe");
   nsCOMPtr<imgIRequest> kungFuDeathGrip(aProxy);
   // In certain cases the request might not have started yet.
   // We still need to fulfill the contract.
   if (!(mState & stateRequestStarted)) {
     aProxy->OnStartRequest();
   }
   if (mState & stateBlockingOnload) {
     aProxy->UnblockOnload();
   }
   if (!(mState & stateRequestStopped)) {
     aProxy->OnStopRequest(true);
   }
 }
 void
 imgStatusTracker::AddConsumer(imgRequestProxy* aConsumer)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mConsumers.AppendElementUnlessExists(aConsumer->asWeakPtr());
 }
 // XXX - The last argument should go away.
 bool
 imgStatusTracker::RemoveConsumer(imgRequestProxy* aConsumer, nsresult aStatus)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Remove the proxy from the list.
   bool removed = mConsumers.RemoveElement(aConsumer);
   // Consumers can get confused if they don't get all the proper teardown
   // notifications. Part ways on good terms.
   if (removed && !aConsumer->NotificationsDeferred()) {
     EmulateRequestFinished(aConsumer, aStatus);
   }
   // Make sure we don't give callbacks to a consumer that isn't interested in
   // them any more.
   imgRequestNotifyRunnable* runnable = static_cast<imgRequestNotifyRunnable*>(mRequestRunnable.get());
   if (aConsumer->NotificationsDeferred() && runnable) {
     runnable->RemoveProxy(aConsumer);
     aConsumer->SetNotificationsDeferred(false);
   }
   return removed;
 }
 bool
 imgStatusTracker::FirstConsumerIs(imgRequestProxy* aConsumer)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Use mConsumers on main thread only");
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       return proxy.get() == aConsumer;
     }
   }
   return false;
 }
 void
 imgStatusTracker::RecordCancel()
 {
   if (!(mImageStatus & imgIRequest::STATUS_LOAD_PARTIAL))
     mImageStatus = imgIRequest::STATUS_ERROR;
 }
 void
 imgStatusTracker::RecordLoaded()
 {
   NS_ABORT_IF_FALSE(mImage, "RecordLoaded called before we have an Image");
   mState |= stateRequestStarted | stateHasSize | stateRequestStopped;
   mImageStatus |= imgIRequest::STATUS_SIZE_AVAILABLE | imgIRequest::STATUS_LOAD_COMPLETE;
   mHadLastPart = true;
 }
 void
 imgStatusTracker::RecordDecoded()
 {
   NS_ABORT_IF_FALSE(mImage, "RecordDecoded called before we have an Image");
   mState |= stateDecodeStarted | stateDecodeStopped | stateFrameStopped;
   mImageStatus |= imgIRequest::STATUS_FRAME_COMPLETE | imgIRequest::STATUS_DECODE_COMPLETE;
   mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
 }
 void
 imgStatusTracker::RecordStartDecode()
 {
   NS_ABORT_IF_FALSE(mImage, "RecordStartDecode without an Image");
   mState |= stateDecodeStarted;
   mImageStatus |= imgIRequest::STATUS_DECODE_STARTED;
 }
 void
 imgStatusTracker::SendStartDecode(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnStartDecode();
 }
 void
 imgStatusTracker::RecordStartContainer(imgIContainer* aContainer)
 {
   NS_ABORT_IF_FALSE(mImage,
                     "RecordStartContainer called before we have an Image");
   NS_ABORT_IF_FALSE(mImage == aContainer,
                     "RecordStartContainer called with wrong Image");
   mState |= stateHasSize;
   mImageStatus |= imgIRequest::STATUS_SIZE_AVAILABLE;
 }
 void
 imgStatusTracker::SendStartContainer(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnStartContainer();
 }
 void
 imgStatusTracker::RecordStartFrame()
 {
   mInvalidRect.SetEmpty();
 }
 // No SendStartFrame since it's not observed below us.
 void
 imgStatusTracker::RecordStopFrame()
 {
   NS_ABORT_IF_FALSE(mImage, "RecordStopFrame called before we have an Image");
   mState |= stateFrameStopped;
   mImageStatus |= imgIRequest::STATUS_FRAME_COMPLETE;
 }
 void
 imgStatusTracker::SendStopFrame(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnStopFrame();
 }
 void
 imgStatusTracker::RecordStopDecode(nsresult aStatus)
 {
   NS_ABORT_IF_FALSE(mImage,
                     "RecordStopDecode called before we have an Image");
   mState |= stateDecodeStopped;
   if (NS_SUCCEEDED(aStatus) && mImageStatus != imgIRequest::STATUS_ERROR) {
     mImageStatus |= imgIRequest::STATUS_DECODE_COMPLETE;
     mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
     mHasBeenDecoded = true;
   // If we weren't successful, clear all success status bits and set error.
   } else {
     mImageStatus = imgIRequest::STATUS_ERROR;
   }
 }
 void
 imgStatusTracker::SendStopDecode(imgRequestProxy* aProxy,
                                  nsresult aStatus)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnStopDecode();
 }
 void
 imgStatusTracker::RecordDiscard()
 {
   NS_ABORT_IF_FALSE(mImage,
                     "RecordDiscard called before we have an Image");
   // Clear the state bits we no longer deserve.
   uint32_t stateBitsToClear = stateDecodeStopped;
   mState &= ~stateBitsToClear;
   // Clear the status bits we no longer deserve.
   uint32_t statusBitsToClear = imgIRequest::STATUS_DECODE_STARTED |
                                imgIRequest::STATUS_FRAME_COMPLETE |
                                imgIRequest::STATUS_DECODE_COMPLETE;
   mImageStatus &= ~statusBitsToClear;
 }
 void
 imgStatusTracker::SendDiscard(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnDiscard();
 }
 void
 imgStatusTracker::RecordUnlockedDraw()
 {
   NS_ABORT_IF_FALSE(mImage,
                     "RecordUnlockedDraw called before we have an Image");
 }
 void
 imgStatusTracker::RecordImageIsAnimated()
 {
   NS_ABORT_IF_FALSE(mImage,
                     "RecordImageIsAnimated called before we have an Image");
   mState |= stateImageIsAnimated;
 }
 void
 imgStatusTracker::SendImageIsAnimated(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnImageIsAnimated();
 }
 void
 imgStatusTracker::SendUnlockedDraw(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnUnlockedDraw();
 }
 void
 imgStatusTracker::OnUnlockedDraw()
 {
   MOZ_ASSERT(NS_IsMainThread());
   RecordUnlockedDraw();
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       SendUnlockedDraw(proxy);
     }
   }
 }
 void
 imgStatusTracker::RecordFrameChanged(const nsIntRect* aDirtyRect)
 {
   NS_ABORT_IF_FALSE(mImage,
                     "RecordFrameChanged called before we have an Image");
   mInvalidRect = mInvalidRect.Union(*aDirtyRect);
 }
 void
 imgStatusTracker::SendFrameChanged(imgRequestProxy* aProxy,
                                    const nsIntRect* aDirtyRect)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnFrameUpdate(aDirtyRect);
 }
 /* non-virtual sort-of-nsIRequestObserver methods */
 void
 imgStatusTracker::RecordStartRequest()
 {
   // We're starting a new load, so clear any status and state bits indicating
   // load/decode
   mImageStatus &= ~imgIRequest::STATUS_LOAD_PARTIAL;
   mImageStatus &= ~imgIRequest::STATUS_LOAD_COMPLETE;
   mImageStatus &= ~imgIRequest::STATUS_FRAME_COMPLETE;
   mImageStatus &= ~imgIRequest::STATUS_DECODE_STARTED;
   mImageStatus &= ~imgIRequest::STATUS_DECODE_COMPLETE;
   mState &= ~stateRequestStarted;
   mState &= ~stateDecodeStarted;
   mState &= ~stateDecodeStopped;
   mState &= ~stateRequestStopped;
   mState &= ~stateBlockingOnload;
   mState &= ~stateImageIsAnimated;
   mState |= stateRequestStarted;
 }
 void
 imgStatusTracker::SendStartRequest(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred())
     aProxy->OnStartRequest();
 }
 void
 imgStatusTracker::OnStartRequest()
 {
   MOZ_ASSERT(NS_IsMainThread());
   RecordStartRequest();
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       SendStartRequest(proxy);
     }
   }
 }
 void
 imgStatusTracker::RecordStopRequest(bool aLastPart,
                                     nsresult aStatus)
 {
   mHadLastPart = aLastPart;
   mState |= stateRequestStopped;
   // If we were successful in loading, note that the image is complete.
   if (NS_SUCCEEDED(aStatus) && mImageStatus != imgIRequest::STATUS_ERROR)
     mImageStatus |= imgIRequest::STATUS_LOAD_COMPLETE;
   else
     mImageStatus = imgIRequest::STATUS_ERROR;
 }
 void
 imgStatusTracker::SendStopRequest(imgRequestProxy* aProxy,
                                   bool aLastPart,
                                   nsresult aStatus)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred()) {
     aProxy->OnStopRequest(aLastPart);
   }
 }
 class OnStopRequestEvent : public nsRunnable
 {
 public:
   OnStopRequestEvent(imgStatusTracker* aTracker,
                      bool aLastPart,
                      nsresult aStatus)
     : mTracker(aTracker)
     , mLastPart(aLastPart)
     , mStatus(aStatus)
   {
     MOZ_ASSERT(!NS_IsMainThread(), "Should be created off the main thread");
     MOZ_ASSERT(aTracker, "aTracker should not be null");
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread(), "Should be running on the main thread");
     MOZ_ASSERT(mTracker, "mTracker should not be null");
     mTracker->OnStopRequest(mLastPart, mStatus);
     return NS_OK;
   }
 private:
   nsRefPtr<imgStatusTracker> mTracker;
   bool mLastPart;
   nsresult mStatus;
 };
 void
 imgStatusTracker::OnStopRequest(bool aLastPart,
                                 nsresult aStatus)
 {
   if (!NS_IsMainThread()) {
     NS_DispatchToMainThread(
       new OnStopRequestEvent(this, aLastPart, aStatus));
     return;
   }
   bool preexistingError = mImageStatus == imgIRequest::STATUS_ERROR;
   RecordStopRequest(aLastPart, aStatus);
   /* notify the kids */
   ProxyArray::ForwardIterator srIter(mConsumers);
   while (srIter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = srIter.GetNext().get();
     if (proxy) {
       SendStopRequest(proxy, aLastPart, aStatus);
     }
   }
   if (NS_FAILED(aStatus) && !preexistingError) {
     FireFailureNotification();
   }
 }
 void
 imgStatusTracker::OnDiscard()
 {
   MOZ_ASSERT(NS_IsMainThread());
   RecordDiscard();
   /* notify the kids */
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       SendDiscard(proxy);
     }
   }
 }
 void
 imgStatusTracker::FrameChanged(const nsIntRect* aDirtyRect)
 {
   MOZ_ASSERT(NS_IsMainThread());
   RecordFrameChanged(aDirtyRect);
   /* notify the kids */
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       SendFrameChanged(proxy, aDirtyRect);
     }
   }
 }
 void
 imgStatusTracker::OnStopFrame()
 {
   MOZ_ASSERT(NS_IsMainThread());
   RecordStopFrame();
   /* notify the kids */
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       SendStopFrame(proxy);
     }
   }
 }
 void
 imgStatusTracker::OnDataAvailable()
 {
   if (!NS_IsMainThread()) {
     // Note: SetHasImage calls Image::Lock and Image::IncrementAnimationCounter
     // so subsequent calls or dispatches which Unlock or Decrement~ should
     // be issued after this to avoid race conditions.
     NS_DispatchToMainThread(
       NS_NewRunnableMethod(this, &imgStatusTracker::OnDataAvailable));
     return;
   }
   // Notify any imgRequestProxys that are observing us that we have an Image.
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       proxy->SetHasImage();
     }
   }
 }
 void
 imgStatusTracker::RecordBlockOnload()
 {
   MOZ_ASSERT(!(mState & stateBlockingOnload));
   mState |= stateBlockingOnload;
 }
 void
 imgStatusTracker::SendBlockOnload(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred()) {
     aProxy->BlockOnload();
   }
 }
 void
 imgStatusTracker::RecordUnblockOnload()
 {
   mState &= ~stateBlockingOnload;
 }
 void
 imgStatusTracker::SendUnblockOnload(imgRequestProxy* aProxy)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!aProxy->NotificationsDeferred()) {
     aProxy->UnblockOnload();
   }
 }
 void
 imgStatusTracker::MaybeUnblockOnload()
 {
   if (!NS_IsMainThread()) {
     NS_DispatchToMainThread(
       NS_NewRunnableMethod(this, &imgStatusTracker::MaybeUnblockOnload));
     return;
   }
   if (!(mState & stateBlockingOnload)) {
     return;
   }
   RecordUnblockOnload();
   ProxyArray::ForwardIterator iter(mConsumers);
   while (iter.HasMore()) {
     nsRefPtr<imgRequestProxy> proxy = iter.GetNext().get();
     if (proxy) {
       SendUnblockOnload(proxy);
     }
   }
 }
 void
 imgStatusTracker::RecordError()
 {
   mImageStatus = imgIRequest::STATUS_ERROR;
 }
 void
 imgStatusTracker::FireFailureNotification()
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Some kind of problem has happened with image decoding.
   // Report the URI to net:failed-to-process-uri-conent observers.
   if (mImage) {
     // Should be on main thread, so ok to create a new nsIURI.
     nsCOMPtr<nsIURI> uri;
     {
       nsRefPtr<ImageURL> threadsafeUriData = mImage->GetURI();
       uri = threadsafeUriData ? threadsafeUriData->ToIURI() : nullptr;
     }
     if (uri) {
       nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
       if (os) {
         os->NotifyObservers(uri, "net:failed-to-process-uri-content", nullptr);
       }
     }
   }
 }

The Tor Browser / annotate

image/src/imgStatusTracker.cpp@b8a032363ba2 (annotated)

image/src/imgStatusTracker.cpp