summaryrefslogtreecommitdiffstats
path: root/image/imgRequestProxy.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--image/imgRequestProxy.cpp1327
1 files changed, 1327 insertions, 0 deletions
diff --git a/image/imgRequestProxy.cpp b/image/imgRequestProxy.cpp
new file mode 100644
index 0000000000..797ae918a9
--- /dev/null
+++ b/image/imgRequestProxy.cpp
@@ -0,0 +1,1327 @@
+/* -*- 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 "imgRequestProxy.h"
+
+#include <utility>
+
+#include "Image.h"
+#include "ImageLogging.h"
+#include "ImageOps.h"
+#include "ImageTypes.h"
+#include "imgINotificationObserver.h"
+#include "imgLoader.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/Telemetry.h" // for Telemetry
+#include "mozilla/dom/DocGroup.h" // for DocGroup
+#include "nsCRTGlue.h"
+#include "nsError.h"
+
+using namespace mozilla;
+using namespace mozilla::image;
+
+// The split of imgRequestProxy and imgRequestProxyStatic means that
+// certain overridden functions need to be usable in the destructor.
+// Since virtual functions can't be used in that way, this class
+// provides a behavioural trait for each class to use instead.
+class ProxyBehaviour {
+ public:
+ virtual ~ProxyBehaviour() = default;
+
+ virtual already_AddRefed<mozilla::image::Image> GetImage() const = 0;
+ virtual bool HasImage() const = 0;
+ virtual already_AddRefed<ProgressTracker> GetProgressTracker() const = 0;
+ virtual imgRequest* GetOwner() const = 0;
+ virtual void SetOwner(imgRequest* aOwner) = 0;
+};
+
+class RequestBehaviour : public ProxyBehaviour {
+ public:
+ RequestBehaviour() : mOwner(nullptr), mOwnerHasImage(false) {}
+
+ already_AddRefed<mozilla::image::Image> GetImage() const override;
+ bool HasImage() const override;
+ already_AddRefed<ProgressTracker> GetProgressTracker() const override;
+
+ imgRequest* GetOwner() const override { return mOwner; }
+
+ void SetOwner(imgRequest* aOwner) override {
+ mOwner = aOwner;
+
+ if (mOwner) {
+ RefPtr<ProgressTracker> ownerProgressTracker = GetProgressTracker();
+ mOwnerHasImage = ownerProgressTracker && ownerProgressTracker->HasImage();
+ } else {
+ mOwnerHasImage = false;
+ }
+ }
+
+ private:
+ // We maintain the following invariant:
+ // The proxy is registered at most with a single imgRequest as an observer,
+ // and whenever it is, mOwner points to that object. This helps ensure that
+ // imgRequestProxy::~imgRequestProxy unregisters the proxy as an observer
+ // from whatever request it was registered with (if any). This, in turn,
+ // means that imgRequest::mObservers will not have any stale pointers in it.
+ RefPtr<imgRequest> mOwner;
+
+ bool mOwnerHasImage;
+};
+
+already_AddRefed<mozilla::image::Image> RequestBehaviour::GetImage() const {
+ if (!mOwnerHasImage) {
+ return nullptr;
+ }
+ RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+ return progressTracker->GetImage();
+}
+
+already_AddRefed<ProgressTracker> RequestBehaviour::GetProgressTracker() const {
+ // NOTE: It's possible that our mOwner has an Image that it didn't notify
+ // us about, if we were Canceled before its Image was constructed.
+ // (Canceling removes us as an observer, so mOwner has no way to notify us).
+ // That's why this method uses mOwner->GetProgressTracker() instead of just
+ // mOwner->mProgressTracker -- we might have a null mImage and yet have an
+ // mOwner with a non-null mImage (and a null mProgressTracker pointer).
+ return mOwner->GetProgressTracker();
+}
+
+NS_IMPL_ADDREF(imgRequestProxy)
+NS_IMPL_RELEASE(imgRequestProxy)
+
+NS_INTERFACE_MAP_BEGIN(imgRequestProxy)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, PreloaderBase)
+ NS_INTERFACE_MAP_ENTRY(imgIRequest)
+ NS_INTERFACE_MAP_ENTRY(nsIRequest)
+ NS_INTERFACE_MAP_ENTRY(nsISupportsPriority)
+ NS_INTERFACE_MAP_ENTRY_CONCRETE(imgRequestProxy)
+ NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsITimedChannel, TimedChannel() != nullptr)
+NS_INTERFACE_MAP_END
+
+imgRequestProxy::imgRequestProxy()
+ : mBehaviour(new RequestBehaviour),
+ mURI(nullptr),
+ mListener(nullptr),
+ mLoadFlags(nsIRequest::LOAD_NORMAL),
+ mLockCount(0),
+ mAnimationConsumers(0),
+ mCancelable(true),
+ mCanceled(false),
+ mIsInLoadGroup(false),
+ mForceDispatchLoadGroup(false),
+ mListenerIsStrongRef(false),
+ mDecodeRequested(false),
+ mPendingNotify(false),
+ mValidating(false),
+ mHadListener(false),
+ mHadDispatch(false) {
+ /* member initializers and constructor code */
+ LOG_FUNC(gImgLog, "imgRequestProxy::imgRequestProxy");
+}
+
+imgRequestProxy::~imgRequestProxy() {
+ /* destructor code */
+ MOZ_ASSERT(!mListener, "Someone forgot to properly cancel this request!");
+
+ // If we had a listener, that means we would have issued notifications. With
+ // bug 1359833, we added support for main thread scheduler groups. Each
+ // imgRequestProxy may have its own associated listener, document and/or
+ // scheduler group. Typically most imgRequestProxy belong to the same
+ // document, or have no listener, which means we will want to execute all main
+ // thread code in that shared scheduler group. Less frequently, there may be
+ // multiple imgRequests and they have separate documents, which means that
+ // when we issue state notifications, some or all need to be dispatched to the
+ // appropriate scheduler group for each request. This should be rare, so we
+ // want to monitor the frequency of dispatching in the wild.
+ if (mHadListener) {
+ mozilla::Telemetry::Accumulate(mozilla::Telemetry::IMAGE_REQUEST_DISPATCHED,
+ mHadDispatch);
+ }
+
+ MOZ_RELEASE_ASSERT(!mLockCount, "Someone forgot to unlock on time?");
+
+ ClearAnimationConsumers();
+
+ // Explicitly set mListener to null to ensure that the RemoveProxy
+ // call below can't send |this| to an arbitrary listener while |this|
+ // is being destroyed. This is all belt-and-suspenders in view of the
+ // above assert.
+ NullOutListener();
+
+ /* Call RemoveProxy with a successful status. This will keep the
+ channel, if still downloading data, from being canceled if 'this' is
+ the last observer. This allows the image to continue to download and
+ be cached even if no one is using it currently.
+ */
+ mCanceled = true;
+ RemoveFromOwner(NS_OK);
+
+ RemoveFromLoadGroup();
+ LOG_FUNC(gImgLog, "imgRequestProxy::~imgRequestProxy");
+}
+
+nsresult imgRequestProxy::Init(imgRequest* aOwner, nsILoadGroup* aLoadGroup,
+ Document* aLoadingDocument, nsIURI* aURI,
+ imgINotificationObserver* aObserver) {
+ MOZ_ASSERT(!GetOwner() && !mListener,
+ "imgRequestProxy is already initialized");
+
+ LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequestProxy::Init", "request", aOwner);
+
+ MOZ_ASSERT(mAnimationConsumers == 0, "Cannot have animation before Init");
+
+ mBehaviour->SetOwner(aOwner);
+ mListener = aObserver;
+ // Make sure to addref mListener before the AddToOwner call below, since
+ // that call might well want to release it if the imgRequest has
+ // already seen OnStopRequest.
+ if (mListener) {
+ mHadListener = true;
+ mListenerIsStrongRef = true;
+ NS_ADDREF(mListener);
+ }
+ mLoadGroup = aLoadGroup;
+ mURI = aURI;
+
+ // Note: AddToOwner won't send all the On* notifications immediately
+ AddToOwner(aLoadingDocument);
+
+ return NS_OK;
+}
+
+nsresult imgRequestProxy::ChangeOwner(imgRequest* aNewOwner) {
+ MOZ_ASSERT(GetOwner(), "Cannot ChangeOwner on a proxy without an owner!");
+
+ if (mCanceled) {
+ // Ensure that this proxy has received all notifications to date
+ // before we clean it up when removing it from the old owner below.
+ SyncNotifyListener();
+ }
+
+ // If we're holding locks, unlock the old image.
+ // Note that UnlockImage decrements mLockCount each time it's called.
+ uint32_t oldLockCount = mLockCount;
+ while (mLockCount) {
+ UnlockImage();
+ }
+
+ // If we're holding animation requests, undo them.
+ uint32_t oldAnimationConsumers = mAnimationConsumers;
+ ClearAnimationConsumers();
+
+ GetOwner()->RemoveProxy(this, NS_OK);
+
+ mBehaviour->SetOwner(aNewOwner);
+ MOZ_ASSERT(!GetValidator(), "New owner cannot be validating!");
+
+ // If we were locked, apply the locks here
+ for (uint32_t i = 0; i < oldLockCount; i++) {
+ LockImage();
+ }
+
+ // If we had animation requests, restore them here. Note that we
+ // do this *after* RemoveProxy, which clears out animation consumers
+ // (see bug 601723).
+ for (uint32_t i = 0; i < oldAnimationConsumers; i++) {
+ IncrementAnimationConsumers();
+ }
+
+ AddToOwner(nullptr);
+ return NS_OK;
+}
+
+NS_IMETHODIMP imgRequestProxy::GetTriggeringPrincipal(
+ nsIPrincipal** aTriggeringPrincipal) {
+ MOZ_ASSERT(GetOwner());
+ nsCOMPtr<nsIPrincipal> triggeringPrincipal =
+ GetOwner()->GetTriggeringPrincipal();
+ triggeringPrincipal.forget(aTriggeringPrincipal);
+ return NS_OK;
+}
+
+void imgRequestProxy::MarkValidating() {
+ MOZ_ASSERT(GetValidator());
+ mValidating = true;
+}
+
+void imgRequestProxy::ClearValidating() {
+ MOZ_ASSERT(mValidating);
+ MOZ_ASSERT(!GetValidator());
+ mValidating = false;
+
+ // If we'd previously requested a synchronous decode, request a decode on the
+ // new image.
+ if (mDecodeRequested) {
+ mDecodeRequested = false;
+ StartDecoding(imgIContainer::FLAG_NONE);
+ }
+}
+
+already_AddRefed<nsIEventTarget> imgRequestProxy::GetEventTarget() const {
+ nsCOMPtr<nsIEventTarget> target(mEventTarget);
+ return target.forget();
+}
+
+bool imgRequestProxy::HasDecodedPixels() {
+ if (IsValidating()) {
+ return false;
+ }
+
+ RefPtr<Image> image = GetImage();
+ if (image) {
+ return image->HasDecodedPixels();
+ }
+
+ return false;
+}
+
+nsresult imgRequestProxy::DispatchWithTargetIfAvailable(
+ already_AddRefed<nsIRunnable> aEvent) {
+ LOG_FUNC(gImgLog, "imgRequestProxy::DispatchWithTargetIfAvailable");
+
+ // This method should only be used when it is *expected* that we are
+ // dispatching an event (e.g. we want to handle an event asynchronously)
+ // rather we need to (e.g. we are in the wrong scheduler group context).
+ // As such, we do not set mHadDispatch for telemetry purposes.
+ if (mEventTarget) {
+ mEventTarget->Dispatch(CreateRenderBlockingRunnable(std::move(aEvent)),
+ NS_DISPATCH_NORMAL);
+ return NS_OK;
+ }
+
+ return NS_DispatchToMainThread(
+ CreateRenderBlockingRunnable(std::move(aEvent)));
+}
+
+void imgRequestProxy::AddToOwner(Document* aLoadingDocument) {
+ // An imgRequestProxy can be initialized with neither a listener nor a
+ // document. The caller could follow up later by cloning the canonical
+ // imgRequestProxy with the actual listener. This is possible because
+ // imgLoader::LoadImage does not require a valid listener to be provided.
+ //
+ // Without a listener, we don't need to set our scheduler group, because
+ // we have nothing to signal. However if we were told what document this
+ // is for, it is likely that future listeners will belong to the same
+ // scheduler group.
+ //
+ // With a listener, we always need to update our scheduler group. A null
+ // scheduler group is valid with or without a document, but that means
+ // we will use the most generic event target possible on dispatch.
+ if (aLoadingDocument) {
+ RefPtr<mozilla::dom::DocGroup> docGroup = aLoadingDocument->GetDocGroup();
+ if (docGroup) {
+ mEventTarget = docGroup->EventTargetFor(mozilla::TaskCategory::Other);
+ MOZ_ASSERT(mEventTarget);
+ }
+ }
+
+ if (mListener && !mEventTarget) {
+ mEventTarget = do_GetMainThread();
+ }
+
+ imgRequest* owner = GetOwner();
+ if (!owner) {
+ return;
+ }
+
+ owner->AddProxy(this);
+}
+
+void imgRequestProxy::RemoveFromOwner(nsresult aStatus) {
+ imgRequest* owner = GetOwner();
+ if (owner) {
+ if (mValidating) {
+ imgCacheValidator* validator = owner->GetValidator();
+ MOZ_ASSERT(validator);
+ validator->RemoveProxy(this);
+ mValidating = false;
+ }
+
+ owner->RemoveProxy(this, aStatus);
+ }
+}
+
+void imgRequestProxy::AddToLoadGroup() {
+ NS_ASSERTION(!mIsInLoadGroup, "Whaa, we're already in the loadgroup!");
+ MOZ_ASSERT(!mForceDispatchLoadGroup);
+
+ /* While in theory there could be a dispatch outstanding to remove this
+ request from the load group, in practice we only add to the load group
+ (when previously not in a load group) at initialization. */
+ if (!mIsInLoadGroup && mLoadGroup) {
+ LOG_FUNC(gImgLog, "imgRequestProxy::AddToLoadGroup");
+ mLoadGroup->AddRequest(this, nullptr);
+ mIsInLoadGroup = true;
+ }
+}
+
+void imgRequestProxy::RemoveFromLoadGroup() {
+ if (!mIsInLoadGroup || !mLoadGroup) {
+ return;
+ }
+
+ /* Sometimes we may not be able to remove ourselves from the load group in
+ the current context. This is because our listeners are not re-entrant (e.g.
+ we are in the middle of CancelAndForgetObserver or SyncClone). */
+ if (mForceDispatchLoadGroup) {
+ LOG_FUNC(gImgLog, "imgRequestProxy::RemoveFromLoadGroup -- dispatch");
+
+ /* We take away the load group from the request temporarily; this prevents
+ additional dispatches via RemoveFromLoadGroup occurring, as well as
+ MoveToBackgroundInLoadGroup from removing and readding. This is safe
+ because we know that once we get here, blocking the load group at all is
+ unnecessary. */
+ mIsInLoadGroup = false;
+ nsCOMPtr<nsILoadGroup> loadGroup = std::move(mLoadGroup);
+ RefPtr<imgRequestProxy> self(this);
+ DispatchWithTargetIfAvailable(NS_NewRunnableFunction(
+ "imgRequestProxy::RemoveFromLoadGroup", [self, loadGroup]() -> void {
+ loadGroup->RemoveRequest(self, nullptr, NS_OK);
+ }));
+ return;
+ }
+
+ LOG_FUNC(gImgLog, "imgRequestProxy::RemoveFromLoadGroup");
+
+ /* calling RemoveFromLoadGroup may cause the document to finish
+ loading, which could result in our death. We need to make sure
+ that we stay alive long enough to fight another battle... at
+ least until we exit this function. */
+ nsCOMPtr<imgIRequest> kungFuDeathGrip(this);
+ mLoadGroup->RemoveRequest(this, nullptr, NS_OK);
+ mLoadGroup = nullptr;
+ mIsInLoadGroup = false;
+}
+
+void imgRequestProxy::MoveToBackgroundInLoadGroup() {
+ /* Even if we are still in the load group, we may have taken away the load
+ group reference itself because we are in the process of leaving the group.
+ In that case, there is no need to background the request. */
+ if (!mLoadGroup) {
+ return;
+ }
+
+ /* There is no need to dispatch if we only need to add ourselves to the load
+ group without removal. It is the removal which causes the problematic
+ callbacks (see RemoveFromLoadGroup). */
+ if (mIsInLoadGroup && mForceDispatchLoadGroup) {
+ LOG_FUNC(gImgLog,
+ "imgRequestProxy::MoveToBackgroundInLoadGroup -- dispatch");
+
+ RefPtr<imgRequestProxy> self(this);
+ DispatchWithTargetIfAvailable(NS_NewRunnableFunction(
+ "imgRequestProxy::MoveToBackgroundInLoadGroup",
+ [self]() -> void { self->MoveToBackgroundInLoadGroup(); }));
+ return;
+ }
+
+ LOG_FUNC(gImgLog, "imgRequestProxy::MoveToBackgroundInLoadGroup");
+ nsCOMPtr<imgIRequest> kungFuDeathGrip(this);
+ if (mIsInLoadGroup) {
+ mLoadGroup->RemoveRequest(this, nullptr, NS_OK);
+ }
+
+ mLoadFlags |= nsIRequest::LOAD_BACKGROUND;
+ mLoadGroup->AddRequest(this, nullptr);
+}
+
+/** nsIRequest / imgIRequest methods **/
+
+NS_IMETHODIMP
+imgRequestProxy::GetName(nsACString& aName) {
+ aName.Truncate();
+
+ if (mURI) {
+ mURI->GetSpec(aName);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::IsPending(bool* _retval) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+imgRequestProxy::GetStatus(nsresult* aStatus) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP imgRequestProxy::SetCanceledReason(const nsACString& aReason) {
+ return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP imgRequestProxy::GetCanceledReason(nsACString& aReason) {
+ return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP imgRequestProxy::CancelWithReason(nsresult aStatus,
+ const nsACString& aReason) {
+ return CancelWithReasonImpl(aStatus, aReason);
+}
+
+void imgRequestProxy::SetCancelable(bool aCancelable) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mCancelable = aCancelable;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::Cancel(nsresult status) {
+ if (mCanceled) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_WARN_IF(!mCancelable)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ LOG_SCOPE(gImgLog, "imgRequestProxy::Cancel");
+
+ mCanceled = true;
+
+ nsCOMPtr<nsIRunnable> ev = new imgCancelRunnable(this, status);
+ return DispatchWithTargetIfAvailable(ev.forget());
+}
+
+void imgRequestProxy::DoCancel(nsresult status) {
+ RemoveFromOwner(status);
+ RemoveFromLoadGroup();
+ NullOutListener();
+}
+
+NS_IMETHODIMP
+imgRequestProxy::CancelAndForgetObserver(nsresult aStatus) {
+ // If mCanceled is true but mListener is non-null, that means
+ // someone called Cancel() on us but the imgCancelRunnable is still
+ // pending. We still need to null out mListener before returning
+ // from this function in this case. That means we want to do the
+ // RemoveProxy call right now, because we need to deliver the
+ // onStopRequest.
+ if (mCanceled && !mListener) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_WARN_IF(!mCancelable)) {
+ MOZ_ASSERT(mCancelable,
+ "Shouldn't try to cancel non-cancelable requests via "
+ "CancelAndForgetObserver");
+ return NS_ERROR_FAILURE;
+ }
+
+ LOG_SCOPE(gImgLog, "imgRequestProxy::CancelAndForgetObserver");
+
+ mCanceled = true;
+ mForceDispatchLoadGroup = true;
+ RemoveFromOwner(aStatus);
+ RemoveFromLoadGroup();
+ mForceDispatchLoadGroup = false;
+
+ NullOutListener();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::StartDecoding(uint32_t aFlags) {
+ // Flag this, so we know to request after validation if pending.
+ if (IsValidating()) {
+ mDecodeRequested = true;
+ return NS_OK;
+ }
+
+ RefPtr<Image> image = GetImage();
+ if (image) {
+ return image->StartDecoding(aFlags);
+ }
+
+ if (GetOwner()) {
+ GetOwner()->StartDecoding();
+ }
+
+ return NS_OK;
+}
+
+bool imgRequestProxy::StartDecodingWithResult(uint32_t aFlags) {
+ // Flag this, so we know to request after validation if pending.
+ if (IsValidating()) {
+ mDecodeRequested = true;
+ return false;
+ }
+
+ RefPtr<Image> image = GetImage();
+ if (image) {
+ return image->StartDecodingWithResult(aFlags);
+ }
+
+ if (GetOwner()) {
+ GetOwner()->StartDecoding();
+ }
+
+ return false;
+}
+
+imgIContainer::DecodeResult imgRequestProxy::RequestDecodeWithResult(
+ uint32_t aFlags) {
+ if (IsValidating()) {
+ mDecodeRequested = true;
+ return imgIContainer::DECODE_REQUESTED;
+ }
+
+ RefPtr<Image> image = GetImage();
+ if (image) {
+ return image->RequestDecodeWithResult(aFlags);
+ }
+
+ if (GetOwner()) {
+ GetOwner()->StartDecoding();
+ }
+
+ return imgIContainer::DECODE_REQUESTED;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::LockImage() {
+ mLockCount++;
+ RefPtr<Image> image =
+ GetOwner() && GetOwner()->ImageAvailable() ? GetImage() : nullptr;
+ if (image) {
+ return image->LockImage();
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::UnlockImage() {
+ MOZ_ASSERT(mLockCount > 0, "calling unlock but no locks!");
+
+ mLockCount--;
+ RefPtr<Image> image =
+ GetOwner() && GetOwner()->ImageAvailable() ? GetImage() : nullptr;
+ if (image) {
+ return image->UnlockImage();
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::RequestDiscard() {
+ RefPtr<Image> image = GetImage();
+ if (image) {
+ return image->RequestDiscard();
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::IncrementAnimationConsumers() {
+ mAnimationConsumers++;
+ RefPtr<Image> image =
+ GetOwner() && GetOwner()->ImageAvailable() ? GetImage() : nullptr;
+ if (image) {
+ image->IncrementAnimationConsumers();
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::DecrementAnimationConsumers() {
+ // We may get here if some responsible code called Increment,
+ // then called us, but we have meanwhile called ClearAnimationConsumers
+ // because we needed to get rid of them earlier (see
+ // imgRequest::RemoveProxy), and hence have nothing left to
+ // decrement. (In such a case we got rid of the animation consumers
+ // early, but not the observer.)
+ if (mAnimationConsumers > 0) {
+ mAnimationConsumers--;
+ RefPtr<Image> image =
+ GetOwner() && GetOwner()->ImageAvailable() ? GetImage() : nullptr;
+ if (image) {
+ image->DecrementAnimationConsumers();
+ }
+ }
+ return NS_OK;
+}
+
+void imgRequestProxy::ClearAnimationConsumers() {
+ while (mAnimationConsumers > 0) {
+ DecrementAnimationConsumers();
+ }
+}
+
+NS_IMETHODIMP
+imgRequestProxy::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+imgRequestProxy::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+imgRequestProxy::GetLoadGroup(nsILoadGroup** loadGroup) {
+ NS_IF_ADDREF(*loadGroup = mLoadGroup.get());
+ return NS_OK;
+}
+NS_IMETHODIMP
+imgRequestProxy::SetLoadGroup(nsILoadGroup* loadGroup) {
+ if (loadGroup != mLoadGroup) {
+ MOZ_ASSERT_UNREACHABLE("Switching load groups is unsupported!");
+ return NS_ERROR_NOT_IMPLEMENTED;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetLoadFlags(nsLoadFlags* flags) {
+ *flags = mLoadFlags;
+ return NS_OK;
+}
+NS_IMETHODIMP
+imgRequestProxy::SetLoadFlags(nsLoadFlags flags) {
+ mLoadFlags = flags;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
+ return GetTRRModeImpl(aTRRMode);
+}
+
+NS_IMETHODIMP
+imgRequestProxy::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
+ return SetTRRModeImpl(aTRRMode);
+}
+
+/** imgIRequest methods **/
+
+NS_IMETHODIMP
+imgRequestProxy::GetImage(imgIContainer** aImage) {
+ NS_ENSURE_TRUE(aImage, NS_ERROR_NULL_POINTER);
+ // It's possible that our owner has an image but hasn't notified us of it -
+ // that'll happen if we get Canceled before the owner instantiates its image
+ // (because Canceling unregisters us as a listener on mOwner). If we're
+ // in that situation, just grab the image off of mOwner.
+ RefPtr<Image> image = GetImage();
+ nsCOMPtr<imgIContainer> imageToReturn;
+ if (image) {
+ imageToReturn = image;
+ }
+ if (!imageToReturn && GetOwner()) {
+ imageToReturn = GetOwner()->GetImage();
+ }
+ if (!imageToReturn) {
+ return NS_ERROR_FAILURE;
+ }
+
+ imageToReturn.swap(*aImage);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetProviderId(uint32_t* aId) {
+ NS_ENSURE_TRUE(aId, NS_ERROR_NULL_POINTER);
+
+ nsCOMPtr<imgIContainer> image;
+ nsresult rv = GetImage(getter_AddRefs(image));
+ if (NS_SUCCEEDED(rv)) {
+ *aId = image->GetProviderId();
+ } else {
+ *aId = 0;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetImageStatus(uint32_t* aStatus) {
+ if (IsValidating()) {
+ // We are currently validating the image, and so our status could revert if
+ // we discard the cache. We should also be deferring notifications, such
+ // that the caller will be notified when validation completes. Rather than
+ // risk misleading the caller, return nothing.
+ *aStatus = imgIRequest::STATUS_NONE;
+ } else {
+ RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+ *aStatus = progressTracker->GetImageStatus();
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetImageErrorCode(nsresult* aStatus) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aStatus = GetOwner()->GetImageErrorCode();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetURI(nsIURI** aURI) {
+ MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread to convert URI");
+ nsCOMPtr<nsIURI> uri = mURI;
+ uri.forget(aURI);
+ return NS_OK;
+}
+
+nsresult imgRequestProxy::GetFinalURI(nsIURI** aURI) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return GetOwner()->GetFinalURI(aURI);
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetNotificationObserver(imgINotificationObserver** aObserver) {
+ *aObserver = mListener;
+ NS_IF_ADDREF(*aObserver);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetMimeType(char** aMimeType) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ const char* type = GetOwner()->GetMimeType();
+ if (!type) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aMimeType = NS_xstrdup(type);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetFileName(nsACString& aFileName) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ GetOwner()->GetFileName(aFileName);
+ return NS_OK;
+}
+
+imgRequestProxy* imgRequestProxy::NewClonedProxy() {
+ return new imgRequestProxy();
+}
+
+NS_IMETHODIMP
+imgRequestProxy::Clone(imgINotificationObserver* aObserver,
+ imgIRequest** aClone) {
+ nsresult result;
+ imgRequestProxy* proxy;
+ result = PerformClone(aObserver, nullptr, /* aSyncNotify */ true, &proxy);
+ *aClone = proxy;
+ return result;
+}
+
+nsresult imgRequestProxy::SyncClone(imgINotificationObserver* aObserver,
+ Document* aLoadingDocument,
+ imgRequestProxy** aClone) {
+ return PerformClone(aObserver, aLoadingDocument,
+ /* aSyncNotify */ true, aClone);
+}
+
+nsresult imgRequestProxy::Clone(imgINotificationObserver* aObserver,
+ Document* aLoadingDocument,
+ imgRequestProxy** aClone) {
+ return PerformClone(aObserver, aLoadingDocument,
+ /* aSyncNotify */ false, aClone);
+}
+
+nsresult imgRequestProxy::PerformClone(imgINotificationObserver* aObserver,
+ Document* aLoadingDocument,
+ bool aSyncNotify,
+ imgRequestProxy** aClone) {
+ MOZ_ASSERT(aClone, "Null out param");
+
+ LOG_SCOPE(gImgLog, "imgRequestProxy::Clone");
+
+ *aClone = nullptr;
+ RefPtr<imgRequestProxy> clone = NewClonedProxy();
+
+ nsCOMPtr<nsILoadGroup> loadGroup;
+ if (aLoadingDocument) {
+ loadGroup = aLoadingDocument->GetDocumentLoadGroup();
+ }
+
+ // It is important to call |SetLoadFlags()| before calling |Init()| because
+ // |Init()| adds the request to the loadgroup.
+ // When a request is added to a loadgroup, its load flags are merged
+ // with the load flags of the loadgroup.
+ // XXXldb That's not true anymore. Stuff from imgLoader adds the
+ // request to the loadgroup.
+ clone->SetLoadFlags(mLoadFlags);
+ nsresult rv = clone->Init(mBehaviour->GetOwner(), loadGroup, aLoadingDocument,
+ mURI, aObserver);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ // Assign to *aClone before calling Notify so that if the caller expects to
+ // only be notified for requests it's already holding pointers to it won't be
+ // surprised.
+ NS_ADDREF(*aClone = clone);
+
+ imgCacheValidator* validator = GetValidator();
+ if (validator) {
+ // Note that if we have a validator, we don't want to issue notifications at
+ // here because we want to defer until that completes. AddProxy will add us
+ // to the load group; we cannot avoid that in this case, because we don't
+ // know when the validation will complete, and if it will cause us to
+ // discard our cached state anyways. We are probably already blocked by the
+ // original LoadImage(WithChannel) request in any event.
+ clone->MarkValidating();
+ validator->AddProxy(clone);
+ } else {
+ // We only want to add the request to the load group of the owning document
+ // if it is still in progress. Some callers cannot handle a supurious load
+ // group removal (e.g. print preview) so we must be careful. On the other
+ // hand, if after cloning, the original request proxy is cancelled /
+ // destroyed, we need to ensure that any clones still block the load group
+ // if it is incomplete.
+ bool addToLoadGroup = mIsInLoadGroup;
+ if (!addToLoadGroup) {
+ RefPtr<ProgressTracker> tracker = clone->GetProgressTracker();
+ addToLoadGroup =
+ tracker && !(tracker->GetProgress() & FLAG_LOAD_COMPLETE);
+ }
+
+ if (addToLoadGroup) {
+ clone->AddToLoadGroup();
+ }
+
+ if (aSyncNotify) {
+ // This is wrong!!! We need to notify asynchronously, but there's code
+ // that assumes that we don't. This will be fixed in bug 580466. Note that
+ // if we have a validator, we won't issue notifications anyways because
+ // they are deferred, so there is no point in requesting.
+ clone->mForceDispatchLoadGroup = true;
+ clone->SyncNotifyListener();
+ clone->mForceDispatchLoadGroup = false;
+ } else {
+ // Without a validator, we can request asynchronous notifications
+ // immediately. If there was a validator, this would override the deferral
+ // and that would be incorrect.
+ clone->NotifyListener();
+ }
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetImagePrincipal(nsIPrincipal** aPrincipal) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIPrincipal> principal = GetOwner()->GetPrincipal();
+ principal.forget(aPrincipal);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetHadCrossOriginRedirects(bool* aHadCrossOriginRedirects) {
+ *aHadCrossOriginRedirects = false;
+
+ nsCOMPtr<nsITimedChannel> timedChannel = TimedChannel();
+ if (timedChannel) {
+ bool allRedirectsSameOrigin = false;
+ *aHadCrossOriginRedirects =
+ NS_SUCCEEDED(
+ timedChannel->GetAllRedirectsSameOrigin(&allRedirectsSameOrigin)) &&
+ !allRedirectsSameOrigin;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetMultipart(bool* aMultipart) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aMultipart = GetOwner()->GetMultipart();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetCORSMode(int32_t* aCorsMode) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aCorsMode = GetOwner()->GetCORSMode();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetReferrerInfo(nsIReferrerInfo** aReferrerInfo) {
+ if (!GetOwner()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIReferrerInfo> referrerInfo = GetOwner()->GetReferrerInfo();
+ referrerInfo.forget(aReferrerInfo);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::BoostPriority(uint32_t aCategory) {
+ NS_ENSURE_STATE(GetOwner() && !mCanceled);
+ GetOwner()->BoostPriority(aCategory);
+ return NS_OK;
+}
+
+/** nsISupportsPriority methods **/
+
+NS_IMETHODIMP
+imgRequestProxy::GetPriority(int32_t* priority) {
+ NS_ENSURE_STATE(GetOwner());
+ *priority = GetOwner()->Priority();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::SetPriority(int32_t priority) {
+ NS_ENSURE_STATE(GetOwner() && !mCanceled);
+ GetOwner()->AdjustPriority(this, priority - GetOwner()->Priority());
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxy::AdjustPriority(int32_t priority) {
+ // We don't require |!mCanceled| here. This may be called even if we're
+ // cancelled, because it's invoked as part of the process of removing an image
+ // from the load group.
+ NS_ENSURE_STATE(GetOwner());
+ GetOwner()->AdjustPriority(this, priority);
+ return NS_OK;
+}
+
+static const char* NotificationTypeToString(int32_t aType) {
+ switch (aType) {
+ case imgINotificationObserver::SIZE_AVAILABLE:
+ return "SIZE_AVAILABLE";
+ case imgINotificationObserver::FRAME_UPDATE:
+ return "FRAME_UPDATE";
+ case imgINotificationObserver::FRAME_COMPLETE:
+ return "FRAME_COMPLETE";
+ case imgINotificationObserver::LOAD_COMPLETE:
+ return "LOAD_COMPLETE";
+ case imgINotificationObserver::DECODE_COMPLETE:
+ return "DECODE_COMPLETE";
+ case imgINotificationObserver::DISCARD:
+ return "DISCARD";
+ case imgINotificationObserver::UNLOCKED_DRAW:
+ return "UNLOCKED_DRAW";
+ case imgINotificationObserver::IS_ANIMATED:
+ return "IS_ANIMATED";
+ case imgINotificationObserver::HAS_TRANSPARENCY:
+ return "HAS_TRANSPARENCY";
+ default:
+ MOZ_ASSERT_UNREACHABLE("Notification list should be exhaustive");
+ return "(unknown notification)";
+ }
+}
+
+void imgRequestProxy::Notify(int32_t aType,
+ const mozilla::gfx::IntRect* aRect) {
+ MOZ_ASSERT(aType != imgINotificationObserver::LOAD_COMPLETE,
+ "Should call OnLoadComplete");
+
+ LOG_FUNC_WITH_PARAM(gImgLog, "imgRequestProxy::Notify", "type",
+ NotificationTypeToString(aType));
+
+ if (!mListener || mCanceled) {
+ return;
+ }
+
+ // Make sure the listener stays alive while we notify.
+ nsCOMPtr<imgINotificationObserver> listener(mListener);
+
+ listener->Notify(this, aType, aRect);
+}
+
+void imgRequestProxy::OnLoadComplete(bool aLastPart) {
+ LOG_FUNC_WITH_PARAM(gImgLog, "imgRequestProxy::OnLoadComplete", "uri", mURI);
+
+ // There's all sorts of stuff here that could kill us (the OnStopRequest call
+ // on the listener, the removal from the loadgroup, the release of the
+ // listener, etc). Don't let them do it.
+ RefPtr<imgRequestProxy> self(this);
+
+ if (mListener && !mCanceled) {
+ // Hold a ref to the listener while we call it, just in case.
+ nsCOMPtr<imgINotificationObserver> listener(mListener);
+ listener->Notify(this, imgINotificationObserver::LOAD_COMPLETE, nullptr);
+ }
+
+ // If we're expecting more data from a multipart channel, re-add ourself
+ // to the loadgroup so that the document doesn't lose track of the load.
+ // If the request is already a background request and there's more data
+ // coming, we can just leave the request in the loadgroup as-is.
+ if (aLastPart || (mLoadFlags & nsIRequest::LOAD_BACKGROUND) == 0) {
+ if (aLastPart) {
+ RemoveFromLoadGroup();
+
+ nsresult errorCode = NS_OK;
+ // if the load is cross origin without CORS, or the CORS access is
+ // rejected, always fire load event to avoid leaking site information for
+ // <link rel=preload>.
+ // XXXedgar, currently we don't do the same thing for <img>.
+ imgRequest* request = GetOwner();
+ if (!request || !(request->IsDeniedCrossSiteCORSRequest() ||
+ request->IsCrossSiteNoCORSRequest())) {
+ uint32_t status = imgIRequest::STATUS_NONE;
+ GetImageStatus(&status);
+ if (status & imgIRequest::STATUS_ERROR) {
+ errorCode = NS_ERROR_FAILURE;
+ }
+ }
+ NotifyStop(errorCode);
+ } else {
+ // More data is coming, so change the request to be a background request
+ // and put it back in the loadgroup.
+ MoveToBackgroundInLoadGroup();
+ }
+ }
+
+ if (mListenerIsStrongRef && aLastPart) {
+ MOZ_ASSERT(mListener, "How did that happen?");
+ // Drop our strong ref to the listener now that we're done with
+ // everything. Note that this can cancel us and other fun things
+ // like that. Don't add anything in this method after this point.
+ imgINotificationObserver* obs = mListener;
+ mListenerIsStrongRef = false;
+ NS_RELEASE(obs);
+ }
+}
+
+void imgRequestProxy::NullOutListener() {
+ // If we have animation consumers, then they don't matter anymore
+ if (mListener) {
+ ClearAnimationConsumers();
+ }
+
+ if (mListenerIsStrongRef) {
+ // Releasing could do weird reentery stuff, so just play it super-safe
+ nsCOMPtr<imgINotificationObserver> obs;
+ obs.swap(mListener);
+ mListenerIsStrongRef = false;
+ } else {
+ mListener = nullptr;
+ }
+}
+
+NS_IMETHODIMP
+imgRequestProxy::GetStaticRequest(imgIRequest** aReturn) {
+ RefPtr<imgRequestProxy> proxy =
+ GetStaticRequest(static_cast<Document*>(nullptr));
+ if (proxy != this) {
+ RefPtr<Image> image = GetImage();
+ if (image && image->HasError()) {
+ // image/test/unit/test_async_notification_404.js needs this, but ideally
+ // this special case can be removed from the scripted codepath.
+ return NS_ERROR_FAILURE;
+ }
+ }
+ proxy.forget(aReturn);
+ return NS_OK;
+}
+
+already_AddRefed<imgRequestProxy> imgRequestProxy::GetStaticRequest(
+ Document* aLoadingDocument) {
+ MOZ_DIAGNOSTIC_ASSERT(!aLoadingDocument ||
+ aLoadingDocument->IsStaticDocument());
+ RefPtr<Image> image = GetImage();
+
+ bool animated;
+ if (!image || (NS_SUCCEEDED(image->GetAnimated(&animated)) && !animated)) {
+ // Early exit - we're not animated, so we don't have to do anything.
+ return do_AddRef(this);
+ }
+
+ // We are animated. We need to create a frozen version of this image.
+ RefPtr<Image> frozenImage = ImageOps::Freeze(image);
+
+ // Create a static imgRequestProxy with our new extracted frame.
+ nsCOMPtr<nsIPrincipal> currentPrincipal;
+ GetImagePrincipal(getter_AddRefs(currentPrincipal));
+ bool hadCrossOriginRedirects = true;
+ GetHadCrossOriginRedirects(&hadCrossOriginRedirects);
+ nsCOMPtr<nsIPrincipal> triggeringPrincipal = GetTriggeringPrincipal();
+ RefPtr<imgRequestProxy> req =
+ new imgRequestProxyStatic(frozenImage, currentPrincipal,
+ triggeringPrincipal, hadCrossOriginRedirects);
+ req->Init(nullptr, nullptr, aLoadingDocument, mURI, nullptr);
+
+ return req.forget();
+}
+
+void imgRequestProxy::NotifyListener() {
+ // It would be nice to notify the observer directly in the status tracker
+ // instead of through the proxy, but there are several places we do extra
+ // processing when we receive notifications (like OnStopRequest()), and we
+ // need to check mCanceled everywhere too.
+
+ RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+ if (GetOwner()) {
+ // Send the notifications to our listener asynchronously.
+ progressTracker->Notify(this);
+ } else {
+ // We don't have an imgRequest, so we can only notify the clone of our
+ // current state, but we still have to do that asynchronously.
+ MOZ_ASSERT(HasImage(), "if we have no imgRequest, we should have an Image");
+ progressTracker->NotifyCurrentState(this);
+ }
+}
+
+void imgRequestProxy::SyncNotifyListener() {
+ // It would be nice to notify the observer directly in the status tracker
+ // instead of through the proxy, but there are several places we do extra
+ // processing when we receive notifications (like OnStopRequest()), and we
+ // need to check mCanceled everywhere too.
+
+ RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+ progressTracker->SyncNotify(this);
+}
+
+void imgRequestProxy::SetHasImage() {
+ RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+ MOZ_ASSERT(progressTracker);
+ RefPtr<Image> image = progressTracker->GetImage();
+ MOZ_ASSERT(image);
+
+ // Force any private status related to the owner to reflect
+ // the presence of an image;
+ mBehaviour->SetOwner(mBehaviour->GetOwner());
+
+ // Apply any locks we have
+ for (uint32_t i = 0; i < mLockCount; ++i) {
+ image->LockImage();
+ }
+
+ // Apply any animation consumers we have
+ for (uint32_t i = 0; i < mAnimationConsumers; i++) {
+ image->IncrementAnimationConsumers();
+ }
+}
+
+already_AddRefed<ProgressTracker> imgRequestProxy::GetProgressTracker() const {
+ return mBehaviour->GetProgressTracker();
+}
+
+already_AddRefed<mozilla::image::Image> imgRequestProxy::GetImage() const {
+ return mBehaviour->GetImage();
+}
+
+bool RequestBehaviour::HasImage() const {
+ if (!mOwnerHasImage) {
+ return false;
+ }
+ RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+ return progressTracker ? progressTracker->HasImage() : false;
+}
+
+bool imgRequestProxy::HasImage() const { return mBehaviour->HasImage(); }
+
+imgRequest* imgRequestProxy::GetOwner() const { return mBehaviour->GetOwner(); }
+
+imgCacheValidator* imgRequestProxy::GetValidator() const {
+ imgRequest* owner = GetOwner();
+ if (!owner) {
+ return nullptr;
+ }
+ return owner->GetValidator();
+}
+
+nsITimedChannel* imgRequestProxy::TimedChannel() {
+ if (!GetOwner()) {
+ return nullptr;
+ }
+ return GetOwner()->GetTimedChannel();
+}
+
+////////////////// imgRequestProxyStatic methods
+
+class StaticBehaviour : public ProxyBehaviour {
+ public:
+ explicit StaticBehaviour(mozilla::image::Image* aImage) : mImage(aImage) {}
+
+ already_AddRefed<mozilla::image::Image> GetImage() const override {
+ RefPtr<mozilla::image::Image> image = mImage;
+ return image.forget();
+ }
+
+ bool HasImage() const override { return mImage; }
+
+ already_AddRefed<ProgressTracker> GetProgressTracker() const override {
+ return mImage->GetProgressTracker();
+ }
+
+ imgRequest* GetOwner() const override { return nullptr; }
+
+ void SetOwner(imgRequest* aOwner) override {
+ MOZ_ASSERT(!aOwner,
+ "We shouldn't be giving static requests a non-null owner.");
+ }
+
+ private:
+ // Our image. We have to hold a strong reference here, because that's normally
+ // the job of the underlying request.
+ RefPtr<mozilla::image::Image> mImage;
+};
+
+imgRequestProxyStatic::imgRequestProxyStatic(mozilla::image::Image* aImage,
+ nsIPrincipal* aImagePrincipal,
+ nsIPrincipal* aTriggeringPrincipal,
+ bool aHadCrossOriginRedirects)
+ : mImagePrincipal(aImagePrincipal),
+ mTriggeringPrincipal(aTriggeringPrincipal),
+ mHadCrossOriginRedirects(aHadCrossOriginRedirects) {
+ mBehaviour = mozilla::MakeUnique<StaticBehaviour>(aImage);
+}
+
+NS_IMETHODIMP
+imgRequestProxyStatic::GetImagePrincipal(nsIPrincipal** aPrincipal) {
+ if (!mImagePrincipal) {
+ return NS_ERROR_FAILURE;
+ }
+ NS_ADDREF(*aPrincipal = mImagePrincipal);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxyStatic::GetTriggeringPrincipal(nsIPrincipal** aPrincipal) {
+ NS_IF_ADDREF(*aPrincipal = mTriggeringPrincipal);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequestProxyStatic::GetHadCrossOriginRedirects(
+ bool* aHadCrossOriginRedirects) {
+ *aHadCrossOriginRedirects = mHadCrossOriginRedirects;
+ return NS_OK;
+}
+
+imgRequestProxy* imgRequestProxyStatic::NewClonedProxy() {
+ nsCOMPtr<nsIPrincipal> currentPrincipal;
+ GetImagePrincipal(getter_AddRefs(currentPrincipal));
+ nsCOMPtr<nsIPrincipal> triggeringPrincipal;
+ GetTriggeringPrincipal(getter_AddRefs(triggeringPrincipal));
+ bool hadCrossOriginRedirects = true;
+ GetHadCrossOriginRedirects(&hadCrossOriginRedirects);
+ RefPtr<mozilla::image::Image> image = GetImage();
+ return new imgRequestProxyStatic(image, currentPrincipal, triggeringPrincipal,
+ hadCrossOriginRedirects);
+}