summaryrefslogtreecommitdiffstats
path: root/image/ProgressTracker.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /image/ProgressTracker.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'image/ProgressTracker.cpp')
-rw-r--r--image/ProgressTracker.cpp570
1 files changed, 570 insertions, 0 deletions
diff --git a/image/ProgressTracker.cpp b/image/ProgressTracker.cpp
new file mode 100644
index 000000000..912b1d17c
--- /dev/null
+++ b/image/ProgressTracker.cpp
@@ -0,0 +1,570 @@
+/* -*- 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 "ImageLogging.h"
+#include "ProgressTracker.h"
+
+#include "imgIContainer.h"
+#include "imgINotificationObserver.h"
+#include "imgIRequest.h"
+#include "Image.h"
+#include "nsNetUtil.h"
+#include "nsIObserverService.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Services.h"
+
+using mozilla::WeakPtr;
+
+namespace mozilla {
+namespace image {
+
+static void
+CheckProgressConsistency(Progress aOldProgress, Progress aNewProgress)
+{
+ // Check preconditions for every progress bit.
+
+ if (aNewProgress & FLAG_SIZE_AVAILABLE) {
+ // No preconditions.
+ }
+ if (aNewProgress & FLAG_DECODE_COMPLETE) {
+ MOZ_ASSERT(aNewProgress & FLAG_SIZE_AVAILABLE);
+ MOZ_ASSERT(aNewProgress & (FLAG_FRAME_COMPLETE | FLAG_HAS_ERROR));
+ }
+ if (aNewProgress & FLAG_FRAME_COMPLETE) {
+ MOZ_ASSERT(aNewProgress & FLAG_SIZE_AVAILABLE);
+ }
+ if (aNewProgress & FLAG_LOAD_COMPLETE) {
+ MOZ_ASSERT(aNewProgress & (FLAG_SIZE_AVAILABLE | FLAG_HAS_ERROR));
+ }
+ if (aNewProgress & FLAG_ONLOAD_BLOCKED) {
+ // No preconditions.
+ }
+ if (aNewProgress & FLAG_ONLOAD_UNBLOCKED) {
+ MOZ_ASSERT(aNewProgress & FLAG_ONLOAD_BLOCKED);
+ MOZ_ASSERT(aNewProgress & (FLAG_SIZE_AVAILABLE | FLAG_HAS_ERROR));
+ }
+ if (aNewProgress & FLAG_IS_ANIMATED) {
+ // No preconditions; like FLAG_HAS_TRANSPARENCY, we should normally never
+ // discover this *after* FLAG_SIZE_AVAILABLE, but unfortunately some corrupt
+ // GIFs may fool us.
+ }
+ if (aNewProgress & FLAG_HAS_TRANSPARENCY) {
+ // XXX We'd like to assert that transparency is only set during metadata
+ // decode but we don't have any way to assert that until bug 1254892 is fixed.
+ }
+ if (aNewProgress & FLAG_LAST_PART_COMPLETE) {
+ MOZ_ASSERT(aNewProgress & FLAG_LOAD_COMPLETE);
+ }
+ if (aNewProgress & FLAG_HAS_ERROR) {
+ // No preconditions.
+ }
+}
+
+void
+ProgressTracker::SetImage(Image* aImage)
+{
+ MutexAutoLock lock(mImageMutex);
+ MOZ_ASSERT(aImage, "Setting null image");
+ MOZ_ASSERT(!mImage, "Setting image when we already have one");
+ mImage = aImage;
+}
+
+void
+ProgressTracker::ResetImage()
+{
+ MutexAutoLock lock(mImageMutex);
+ MOZ_ASSERT(mImage, "Resetting image when it's already null!");
+ mImage = nullptr;
+}
+
+uint32_t
+ProgressTracker::GetImageStatus() const
+{
+ uint32_t status = imgIRequest::STATUS_NONE;
+
+ // Translate our current state to a set of imgIRequest::STATE_* flags.
+ if (mProgress & FLAG_SIZE_AVAILABLE) {
+ status |= imgIRequest::STATUS_SIZE_AVAILABLE;
+ }
+ if (mProgress & FLAG_DECODE_COMPLETE) {
+ status |= imgIRequest::STATUS_DECODE_COMPLETE;
+ }
+ if (mProgress & FLAG_FRAME_COMPLETE) {
+ status |= imgIRequest::STATUS_FRAME_COMPLETE;
+ }
+ if (mProgress & FLAG_LOAD_COMPLETE) {
+ status |= imgIRequest::STATUS_LOAD_COMPLETE;
+ }
+ if (mProgress & FLAG_IS_ANIMATED) {
+ status |= imgIRequest::STATUS_IS_ANIMATED;
+ }
+ if (mProgress & FLAG_HAS_TRANSPARENCY) {
+ status |= imgIRequest::STATUS_HAS_TRANSPARENCY;
+ }
+ if (mProgress & FLAG_HAS_ERROR) {
+ status |= imgIRequest::STATUS_ERROR;
+ }
+
+ return status;
+}
+
+// A helper class to allow us to call SyncNotify asynchronously.
+class AsyncNotifyRunnable : public Runnable
+{
+ public:
+ AsyncNotifyRunnable(ProgressTracker* aTracker,
+ IProgressObserver* aObserver)
+ : mTracker(aTracker)
+ {
+ MOZ_ASSERT(NS_IsMainThread(), "Should be created on the main thread");
+ MOZ_ASSERT(aTracker, "aTracker should not be null");
+ MOZ_ASSERT(aObserver, "aObserver should not be null");
+ mObservers.AppendElement(aObserver);
+ }
+
+ NS_IMETHOD Run() override
+ {
+ 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 < mObservers.Length(); ++i) {
+ mObservers[i]->SetNotificationsDeferred(false);
+ mTracker->SyncNotify(mObservers[i]);
+ }
+
+ mTracker->mRunnable = nullptr;
+ return NS_OK;
+ }
+
+ void AddObserver(IProgressObserver* aObserver)
+ {
+ mObservers.AppendElement(aObserver);
+ }
+
+ void RemoveObserver(IProgressObserver* aObserver)
+ {
+ mObservers.RemoveElement(aObserver);
+ }
+
+ private:
+ friend class ProgressTracker;
+
+ RefPtr<ProgressTracker> mTracker;
+ nsTArray<RefPtr<IProgressObserver>> mObservers;
+};
+
+void
+ProgressTracker::Notify(IProgressObserver* aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) {
+ RefPtr<Image> image = GetImage();
+ if (image && image->GetURI()) {
+ RefPtr<ImageURL> uri(image->GetURI());
+ nsAutoCString spec;
+ uri->GetSpec(spec);
+ LOG_FUNC_WITH_PARAM(gImgLog,
+ "ProgressTracker::Notify async", "uri", spec.get());
+ } else {
+ LOG_FUNC_WITH_PARAM(gImgLog,
+ "ProgressTracker::Notify async", "uri", "<unknown>");
+ }
+ }
+
+ aObserver->SetNotificationsDeferred(true);
+
+ // If we have an existing runnable that we can use, we just append this
+ // observer to its list of observers to be notified. This ensures we don't
+ // unnecessarily delay onload.
+ AsyncNotifyRunnable* runnable =
+ static_cast<AsyncNotifyRunnable*>(mRunnable.get());
+
+ if (runnable) {
+ runnable->AddObserver(aObserver);
+ } else {
+ mRunnable = new AsyncNotifyRunnable(this, aObserver);
+ NS_DispatchToCurrentThread(mRunnable);
+ }
+}
+
+// A helper class to allow us to call SyncNotify asynchronously for a given,
+// fixed, state.
+class AsyncNotifyCurrentStateRunnable : public Runnable
+{
+ public:
+ AsyncNotifyCurrentStateRunnable(ProgressTracker* aProgressTracker,
+ IProgressObserver* aObserver)
+ : mProgressTracker(aProgressTracker)
+ , mObserver(aObserver)
+ {
+ MOZ_ASSERT(NS_IsMainThread(), "Should be created on the main thread");
+ MOZ_ASSERT(mProgressTracker, "mProgressTracker should not be null");
+ MOZ_ASSERT(mObserver, "mObserver should not be null");
+ mImage = mProgressTracker->GetImage();
+ }
+
+ NS_IMETHOD Run() override
+ {
+ MOZ_ASSERT(NS_IsMainThread(), "Should be running on the main thread");
+ mObserver->SetNotificationsDeferred(false);
+
+ mProgressTracker->SyncNotify(mObserver);
+ return NS_OK;
+ }
+
+ private:
+ RefPtr<ProgressTracker> mProgressTracker;
+ RefPtr<IProgressObserver> mObserver;
+
+ // 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.
+ RefPtr<Image> mImage;
+};
+
+void
+ProgressTracker::NotifyCurrentState(IProgressObserver* aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (MOZ_LOG_TEST(gImgLog, LogLevel::Debug)) {
+ RefPtr<Image> image = GetImage();
+ nsAutoCString spec;
+ if (image && image->GetURI()) {
+ image->GetURI()->GetSpec(spec);
+ }
+ LOG_FUNC_WITH_PARAM(gImgLog,
+ "ProgressTracker::NotifyCurrentState", "uri", spec.get());
+ }
+
+ aObserver->SetNotificationsDeferred(true);
+
+ nsCOMPtr<nsIRunnable> ev = new AsyncNotifyCurrentStateRunnable(this,
+ aObserver);
+ NS_DispatchToCurrentThread(ev);
+}
+
+/**
+ * ImageObserverNotifier is a helper type that abstracts over the difference
+ * between sending notifications to all of the observers in an ObserverTable,
+ * and sending them to a single observer. This allows the same notification code
+ * to be used for both cases.
+ */
+template <typename T> struct ImageObserverNotifier;
+
+template <>
+struct MOZ_STACK_CLASS ImageObserverNotifier<const ObserverTable*>
+{
+ explicit ImageObserverNotifier(const ObserverTable* aObservers,
+ bool aIgnoreDeferral = false)
+ : mObservers(aObservers)
+ , mIgnoreDeferral(aIgnoreDeferral)
+ { }
+
+ template <typename Lambda>
+ void operator()(Lambda aFunc)
+ {
+ for (auto iter = mObservers->ConstIter(); !iter.Done(); iter.Next()) {
+ RefPtr<IProgressObserver> observer = iter.Data().get();
+ if (observer &&
+ (mIgnoreDeferral || !observer->NotificationsDeferred())) {
+ aFunc(observer);
+ }
+ }
+ }
+
+private:
+ const ObserverTable* mObservers;
+ const bool mIgnoreDeferral;
+};
+
+template <>
+struct MOZ_STACK_CLASS ImageObserverNotifier<IProgressObserver*>
+{
+ explicit ImageObserverNotifier(IProgressObserver* aObserver)
+ : mObserver(aObserver)
+ { }
+
+ template <typename Lambda>
+ void operator()(Lambda aFunc)
+ {
+ if (mObserver && !mObserver->NotificationsDeferred()) {
+ aFunc(mObserver);
+ }
+ }
+
+private:
+ IProgressObserver* mObserver;
+};
+
+template <typename T> void
+SyncNotifyInternal(const T& aObservers,
+ bool aHasImage,
+ Progress aProgress,
+ const nsIntRect& aDirtyRect)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ typedef imgINotificationObserver I;
+ ImageObserverNotifier<T> notify(aObservers);
+
+ if (aProgress & FLAG_SIZE_AVAILABLE) {
+ notify([](IProgressObserver* aObs) { aObs->Notify(I::SIZE_AVAILABLE); });
+ }
+
+ if (aProgress & FLAG_ONLOAD_BLOCKED) {
+ notify([](IProgressObserver* aObs) { aObs->BlockOnload(); });
+ }
+
+ if (aHasImage) {
+ // 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 (!aDirtyRect.IsEmpty()) {
+ notify([&](IProgressObserver* aObs) {
+ aObs->Notify(I::FRAME_UPDATE, &aDirtyRect);
+ });
+ }
+
+ if (aProgress & FLAG_FRAME_COMPLETE) {
+ notify([](IProgressObserver* aObs) { aObs->Notify(I::FRAME_COMPLETE); });
+ }
+
+ if (aProgress & FLAG_HAS_TRANSPARENCY) {
+ notify([](IProgressObserver* aObs) { aObs->Notify(I::HAS_TRANSPARENCY); });
+ }
+
+ if (aProgress & FLAG_IS_ANIMATED) {
+ notify([](IProgressObserver* aObs) { aObs->Notify(I::IS_ANIMATED); });
+ }
+ }
+
+ // Send UnblockOnload before OnStopDecode and OnStopRequest. This allows
+ // observers that can fire events when they receive those notifications to do
+ // so then, instead of being forced to wait for UnblockOnload.
+ if (aProgress & FLAG_ONLOAD_UNBLOCKED) {
+ notify([](IProgressObserver* aObs) { aObs->UnblockOnload(); });
+ }
+
+ if (aProgress & FLAG_DECODE_COMPLETE) {
+ MOZ_ASSERT(aHasImage, "Stopped decoding without ever having an image?");
+ notify([](IProgressObserver* aObs) { aObs->Notify(I::DECODE_COMPLETE); });
+ }
+
+ if (aProgress & FLAG_LOAD_COMPLETE) {
+ notify([=](IProgressObserver* aObs) {
+ aObs->OnLoadComplete(aProgress & FLAG_LAST_PART_COMPLETE);
+ });
+ }
+}
+
+void
+ProgressTracker::SyncNotifyProgress(Progress aProgress,
+ const nsIntRect& aInvalidRect
+ /* = nsIntRect() */)
+{
+ MOZ_ASSERT(NS_IsMainThread(), "Use mObservers on main thread only");
+
+ // Don't unblock onload if we're not blocked.
+ Progress progress = Difference(aProgress);
+ if (!((mProgress | progress) & FLAG_ONLOAD_BLOCKED)) {
+ progress &= ~FLAG_ONLOAD_UNBLOCKED;
+ }
+
+ CheckProgressConsistency(mProgress, mProgress | progress);
+
+ // XXX(seth): Hack to work around the fact that some observers have bugs and
+ // need to get onload blocking notifications multiple times. We should fix
+ // those observers and remove this.
+ if ((aProgress & FLAG_DECODE_COMPLETE) &&
+ (mProgress & FLAG_ONLOAD_BLOCKED) &&
+ (mProgress & FLAG_ONLOAD_UNBLOCKED)) {
+ progress |= FLAG_ONLOAD_BLOCKED | FLAG_ONLOAD_UNBLOCKED;
+ }
+
+ // Apply the changes.
+ mProgress |= progress;
+
+ // Send notifications.
+ mObservers.Read([&](const ObserverTable* aTable) {
+ SyncNotifyInternal(aTable, HasImage(), progress, aInvalidRect);
+ });
+
+ if (progress & FLAG_HAS_ERROR) {
+ FireFailureNotification();
+ }
+}
+
+void
+ProgressTracker::SyncNotify(IProgressObserver* aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ RefPtr<Image> image = GetImage();
+
+ nsAutoCString spec;
+ if (image && image->GetURI()) {
+ image->GetURI()->GetSpec(spec);
+ }
+ LOG_SCOPE_WITH_PARAM(gImgLog,
+ "ProgressTracker::SyncNotify", "uri", spec.get());
+
+ nsIntRect rect;
+ if (image) {
+ if (NS_FAILED(image->GetWidth(&rect.width)) ||
+ NS_FAILED(image->GetHeight(&rect.height))) {
+ // Either the image has no intrinsic size, or it has an error.
+ rect = GetMaxSizedIntRect();
+ }
+ }
+
+ SyncNotifyInternal(aObserver, !!image, mProgress, rect);
+}
+
+void
+ProgressTracker::EmulateRequestFinished(IProgressObserver* aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread(),
+ "SyncNotifyState and mObservers are not threadsafe");
+ RefPtr<IProgressObserver> kungFuDeathGrip(aObserver);
+
+ if (mProgress & FLAG_ONLOAD_BLOCKED && !(mProgress & FLAG_ONLOAD_UNBLOCKED)) {
+ aObserver->UnblockOnload();
+ }
+
+ if (!(mProgress & FLAG_LOAD_COMPLETE)) {
+ aObserver->OnLoadComplete(true);
+ }
+}
+
+void
+ProgressTracker::AddObserver(IProgressObserver* aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ RefPtr<IProgressObserver> observer = aObserver;
+
+ mObservers.Write([=](ObserverTable* aTable) {
+ MOZ_ASSERT(!aTable->Get(observer, nullptr),
+ "Adding duplicate entry for image observer");
+
+ WeakPtr<IProgressObserver> weakPtr = observer.get();
+ aTable->Put(observer, weakPtr);
+ });
+}
+
+bool
+ProgressTracker::RemoveObserver(IProgressObserver* aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ RefPtr<IProgressObserver> observer = aObserver;
+
+ // Remove the observer from the list.
+ bool removed = mObservers.Write([=](ObserverTable* aTable) {
+ bool removed = aTable->Get(observer, nullptr);
+ aTable->Remove(observer);
+ return removed;
+ });
+
+ // Observers can get confused if they don't get all the proper teardown
+ // notifications. Part ways on good terms.
+ if (removed && !aObserver->NotificationsDeferred()) {
+ EmulateRequestFinished(aObserver);
+ }
+
+ // Make sure we don't give callbacks to an observer that isn't interested in
+ // them any more.
+ AsyncNotifyRunnable* runnable =
+ static_cast<AsyncNotifyRunnable*>(mRunnable.get());
+
+ if (aObserver->NotificationsDeferred() && runnable) {
+ runnable->RemoveObserver(aObserver);
+ aObserver->SetNotificationsDeferred(false);
+ }
+
+ return removed;
+}
+
+uint32_t
+ProgressTracker::ObserverCount() const
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ return mObservers.Read([](const ObserverTable* aTable) {
+ return aTable->Count();
+ });
+}
+
+void
+ProgressTracker::OnUnlockedDraw()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ mObservers.Read([](const ObserverTable* aTable) {
+ ImageObserverNotifier<const ObserverTable*> notify(aTable);
+ notify([](IProgressObserver* aObs) {
+ aObs->Notify(imgINotificationObserver::UNLOCKED_DRAW);
+ });
+ });
+}
+
+void
+ProgressTracker::ResetForNewRequest()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ mProgress = NoProgress;
+}
+
+void
+ProgressTracker::OnDiscard()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ mObservers.Read([](const ObserverTable* aTable) {
+ ImageObserverNotifier<const ObserverTable*> notify(aTable);
+ notify([](IProgressObserver* aObs) {
+ aObs->Notify(imgINotificationObserver::DISCARD);
+ });
+ });
+}
+
+void
+ProgressTracker::OnImageAvailable()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ // Notify any imgRequestProxys that are observing us that we have an Image.
+ mObservers.Read([](const ObserverTable* aTable) {
+ ImageObserverNotifier<const ObserverTable*>
+ notify(aTable, /* aIgnoreDeferral = */ true);
+ notify([](IProgressObserver* aObs) {
+ aObs->SetHasImage();
+ });
+ });
+}
+
+void
+ProgressTracker::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.
+ RefPtr<Image> image = GetImage();
+ if (image) {
+ // Should be on main thread, so ok to create a new nsIURI.
+ nsCOMPtr<nsIURI> uri;
+ {
+ RefPtr<ImageURL> threadsafeUriData = image->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);
+ }
+ }
+ }
+}
+
+} // namespace image
+} // namespace mozilla