Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1244 insertions, 0 deletions

diff --git a/image/imgRequest.cpp b/image/imgRequest.cpp
new file mode 100644
index 0000000000..f544169caa
--- /dev/null
+++ b/image/imgRequest.cpp
@@ -0,0 +1,1244 @@
+/* -*- 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 "imgRequest.h"
+#include "ImageLogging.h"
+
+#include "imgLoader.h"
+#include "imgRequestProxy.h"
+#include "DecodePool.h"
+#include "ProgressTracker.h"
+#include "ImageFactory.h"
+#include "Image.h"
+#include "MultipartImage.h"
+#include "RasterImage.h"
+
+#include "nsIChannel.h"
+#include "nsICacheInfoChannel.h"
+#include "nsIClassOfService.h"
+#include "mozilla/dom/Document.h"
+#include "nsIThreadRetargetableRequest.h"
+#include "nsIInputStream.h"
+#include "nsIMultiPartChannel.h"
+#include "nsIHttpChannel.h"
+#include "nsIApplicationCache.h"
+#include "nsIApplicationCacheChannel.h"
+#include "nsMimeTypes.h"
+
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsComponentManagerUtils.h"
+#include "nsContentUtils.h"
+
+#include "plstr.h"   // PL_strcasestr(...)
+#include "prtime.h"  // for PR_Now
+#include "nsNetUtil.h"
+#include "nsIProtocolHandler.h"
+#include "imgIRequest.h"
+#include "nsProperties.h"
+
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/SizeOfState.h"
+
+using namespace mozilla;
+using namespace mozilla::image;
+
+#define LOG_TEST(level) (MOZ_LOG_TEST(gImgLog, (level)))
+
+NS_IMPL_ISUPPORTS(imgRequest, nsIStreamListener, nsIRequestObserver,
+                  nsIThreadRetargetableStreamListener, nsIChannelEventSink,
+                  nsIInterfaceRequestor, nsIAsyncVerifyRedirectCallback)
+
+imgRequest::imgRequest(imgLoader* aLoader, const ImageCacheKey& aCacheKey)
+    : mLoader(aLoader),
+      mCacheKey(aCacheKey),
+      mLoadId(nullptr),
+      mFirstProxy(nullptr),
+      mValidator(nullptr),
+      mInnerWindowId(0),
+      mCORSMode(imgIRequest::CORS_NONE),
+      mImageErrorCode(NS_OK),
+      mImageAvailable(false),
+      mIsDeniedCrossSiteCORSRequest(false),
+      mIsCrossSiteNoCORSRequest(false),
+      mMutex("imgRequest"),
+      mProgressTracker(new ProgressTracker()),
+      mIsMultiPartChannel(false),
+      mIsInCache(false),
+      mDecodeRequested(false),
+      mNewPartPending(false),
+      mHadInsecureRedirect(false) {
+  LOG_FUNC(gImgLog, "imgRequest::imgRequest()");
+}
+
+imgRequest::~imgRequest() {
+  if (mLoader) {
+    mLoader->RemoveFromUncachedImages(this);
+  }
+  if (mURI) {
+    LOG_FUNC_WITH_PARAM(gImgLog, "imgRequest::~imgRequest()", "keyuri", mURI);
+  } else
+    LOG_FUNC(gImgLog, "imgRequest::~imgRequest()");
+}
+
+nsresult imgRequest::Init(nsIURI* aURI, nsIURI* aFinalURI,
+                          bool aHadInsecureRedirect, nsIRequest* aRequest,
+                          nsIChannel* aChannel, imgCacheEntry* aCacheEntry,
+                          mozilla::dom::Document* aLoadingDocument,
+                          nsIPrincipal* aTriggeringPrincipal, int32_t aCORSMode,
+                          nsIReferrerInfo* aReferrerInfo) {
+  MOZ_ASSERT(NS_IsMainThread(), "Cannot use nsIURI off main thread!");
+
+  LOG_FUNC(gImgLog, "imgRequest::Init");
+
+  MOZ_ASSERT(!mImage, "Multiple calls to init");
+  MOZ_ASSERT(aURI, "No uri");
+  MOZ_ASSERT(aFinalURI, "No final uri");
+  MOZ_ASSERT(aRequest, "No request");
+  MOZ_ASSERT(aChannel, "No channel");
+
+  mProperties = new nsProperties();
+  mURI = aURI;
+  mFinalURI = aFinalURI;
+  mRequest = aRequest;
+  mChannel = aChannel;
+  mTimedChannel = do_QueryInterface(mChannel);
+  mTriggeringPrincipal = aTriggeringPrincipal;
+  mCORSMode = aCORSMode;
+  mReferrerInfo = aReferrerInfo;
+
+  // If the original URI and the final URI are different, check whether the
+  // original URI is secure. We deliberately don't take the final URI into
+  // account, as it needs to be handled using more complicated rules than
+  // earlier elements of the redirect chain.
+  if (aURI != aFinalURI) {
+    bool schemeLocal = false;
+    if (NS_FAILED(NS_URIChainHasFlags(
+            aURI, nsIProtocolHandler::URI_IS_LOCAL_RESOURCE, &schemeLocal)) ||
+        (!aURI->SchemeIs("https") && !aURI->SchemeIs("chrome") &&
+         !schemeLocal)) {
+      mHadInsecureRedirect = true;
+    }
+  }
+
+  // imgCacheValidator may have handled redirects before we were created, so we
+  // allow the caller to let us know if any redirects were insecure.
+  mHadInsecureRedirect = mHadInsecureRedirect || aHadInsecureRedirect;
+
+  mChannel->GetNotificationCallbacks(getter_AddRefs(mPrevChannelSink));
+
+  NS_ASSERTION(mPrevChannelSink != this,
+               "Initializing with a channel that already calls back to us!");
+
+  mChannel->SetNotificationCallbacks(this);
+
+  mCacheEntry = aCacheEntry;
+  mCacheEntry->UpdateLoadTime();
+
+  SetLoadId(aLoadingDocument);
+
+  // Grab the inner window ID of the loading document, if possible.
+  if (aLoadingDocument) {
+    mInnerWindowId = aLoadingDocument->InnerWindowID();
+  }
+
+  return NS_OK;
+}
+
+bool imgRequest::CanReuseWithoutValidation(dom::Document* aDoc) const {
+  // If the request's loadId is the same as the aLoadingDocument, then it is ok
+  // to use this one because it has already been validated for this context.
+  // XXX: nullptr seems to be a 'special' key value that indicates that NO
+  //      validation is required.
+  // XXX: we also check the window ID because the loadID() can return a reused
+  //      pointer of a document. This can still happen for non-document image
+  //      cache entries.
+  void* key = (void*)aDoc;
+  uint64_t innerWindowID = aDoc ? aDoc->InnerWindowID() : 0;
+  if (LoadId() == key && InnerWindowID() == innerWindowID) {
+    return true;
+  }
+
+  // As a special-case, if this is a print preview document, also validate on
+  // the original document. This allows to print uncacheable images.
+  if (dom::Document* original = aDoc ? aDoc->GetOriginalDocument() : nullptr) {
+    return CanReuseWithoutValidation(original);
+  }
+
+  return false;
+}
+
+void imgRequest::ClearLoader() { mLoader = nullptr; }
+
+already_AddRefed<ProgressTracker> imgRequest::GetProgressTracker() const {
+  MutexAutoLock lock(mMutex);
+
+  if (mImage) {
+    MOZ_ASSERT(!mProgressTracker,
+               "Should have given mProgressTracker to mImage");
+    return mImage->GetProgressTracker();
+  }
+  MOZ_ASSERT(mProgressTracker,
+             "Should have mProgressTracker until we create mImage");
+  RefPtr<ProgressTracker> progressTracker = mProgressTracker;
+  MOZ_ASSERT(progressTracker);
+  return progressTracker.forget();
+}
+
+void imgRequest::SetCacheEntry(imgCacheEntry* entry) { mCacheEntry = entry; }
+
+bool imgRequest::HasCacheEntry() const { return mCacheEntry != nullptr; }
+
+void imgRequest::ResetCacheEntry() {
+  if (HasCacheEntry()) {
+    mCacheEntry->SetDataSize(0);
+  }
+}
+
+void imgRequest::AddProxy(imgRequestProxy* proxy) {
+  MOZ_ASSERT(proxy, "null imgRequestProxy passed in");
+  LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::AddProxy", "proxy", proxy);
+
+  if (!mFirstProxy) {
+    // Save a raw pointer to the first proxy we see, for use in the network
+    // priority logic.
+    mFirstProxy = proxy;
+  }
+
+  // If we're empty before adding, we have to tell the loader we now have
+  // proxies.
+  RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+  if (progressTracker->ObserverCount() == 0) {
+    MOZ_ASSERT(mURI, "Trying to SetHasProxies without key uri.");
+    if (mLoader) {
+      mLoader->SetHasProxies(this);
+    }
+  }
+
+  progressTracker->AddObserver(proxy);
+}
+
+nsresult imgRequest::RemoveProxy(imgRequestProxy* proxy, nsresult aStatus) {
+  LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::RemoveProxy", "proxy", proxy);
+
+  // This will remove our animation consumers, so after removing
+  // this proxy, we don't end up without proxies with observers, but still
+  // have animation consumers.
+  proxy->ClearAnimationConsumers();
+
+  // Let the status tracker do its thing before we potentially call Cancel()
+  // below, because Cancel() may result in OnStopRequest being called back
+  // before Cancel() returns, leaving the image in a different state then the
+  // one it was in at this point.
+  RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+  if (!progressTracker->RemoveObserver(proxy)) {
+    return NS_OK;
+  }
+
+  if (progressTracker->ObserverCount() == 0) {
+    // If we have no observers, there's nothing holding us alive. If we haven't
+    // been cancelled and thus removed from the cache, tell the image loader so
+    // we can be evicted from the cache.
+    if (mCacheEntry) {
+      MOZ_ASSERT(mURI, "Removing last observer without key uri.");
+
+      if (mLoader) {
+        mLoader->SetHasNoProxies(this, mCacheEntry);
+      }
+    } else {
+      LOG_MSG_WITH_PARAM(gImgLog, "imgRequest::RemoveProxy no cache entry",
+                         "uri", mURI);
+    }
+
+    /* If |aStatus| is a failure code, then cancel the load if it is still in
+       progress.  Otherwise, let the load continue, keeping 'this' in the cache
+       with no observers.  This way, if a proxy is destroyed without calling
+       cancel on it, it won't leak and won't leave a bad pointer in the observer
+       list.
+     */
+    if (!(progressTracker->GetProgress() & FLAG_LAST_PART_COMPLETE) &&
+        NS_FAILED(aStatus)) {
+      LOG_MSG(gImgLog, "imgRequest::RemoveProxy",
+              "load in progress.  canceling");
+
+      this->Cancel(NS_BINDING_ABORTED);
+    }
+
+    /* break the cycle from the cache entry. */
+    mCacheEntry = nullptr;
+  }
+
+  return NS_OK;
+}
+
+void imgRequest::CancelAndAbort(nsresult aStatus) {
+  LOG_SCOPE(gImgLog, "imgRequest::CancelAndAbort");
+
+  Cancel(aStatus);
+
+  // It's possible for the channel to fail to open after we've set our
+  // notification callbacks. In that case, make sure to break the cycle between
+  // the channel and us, because it won't.
+  if (mChannel) {
+    mChannel->SetNotificationCallbacks(mPrevChannelSink);
+    mPrevChannelSink = nullptr;
+  }
+}
+
+class imgRequestMainThreadCancel : public Runnable {
+ public:
+  imgRequestMainThreadCancel(imgRequest* aImgRequest, nsresult aStatus)
+      : Runnable("imgRequestMainThreadCancel"),
+        mImgRequest(aImgRequest),
+        mStatus(aStatus) {
+    MOZ_ASSERT(!NS_IsMainThread(), "Create me off main thread only!");
+    MOZ_ASSERT(aImgRequest);
+  }
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread(), "I should be running on the main thread!");
+    mImgRequest->ContinueCancel(mStatus);
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<imgRequest> mImgRequest;
+  nsresult mStatus;
+};
+
+void imgRequest::Cancel(nsresult aStatus) {
+  /* The Cancel() method here should only be called by this class. */
+  LOG_SCOPE(gImgLog, "imgRequest::Cancel");
+
+  if (NS_IsMainThread()) {
+    ContinueCancel(aStatus);
+  } else {
+    RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+    nsCOMPtr<nsIEventTarget> eventTarget = progressTracker->GetEventTarget();
+    nsCOMPtr<nsIRunnable> ev = new imgRequestMainThreadCancel(this, aStatus);
+    eventTarget->Dispatch(ev.forget(), NS_DISPATCH_NORMAL);
+  }
+}
+
+void imgRequest::ContinueCancel(nsresult aStatus) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+  progressTracker->SyncNotifyProgress(FLAG_HAS_ERROR);
+
+  RemoveFromCache();
+
+  if (mRequest && !(progressTracker->GetProgress() & FLAG_LAST_PART_COMPLETE)) {
+    mRequest->Cancel(aStatus);
+  }
+}
+
+class imgRequestMainThreadEvict : public Runnable {
+ public:
+  explicit imgRequestMainThreadEvict(imgRequest* aImgRequest)
+      : Runnable("imgRequestMainThreadEvict"), mImgRequest(aImgRequest) {
+    MOZ_ASSERT(!NS_IsMainThread(), "Create me off main thread only!");
+    MOZ_ASSERT(aImgRequest);
+  }
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread(), "I should be running on the main thread!");
+    mImgRequest->ContinueEvict();
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<imgRequest> mImgRequest;
+};
+
+// EvictFromCache() is written to allowed to get called from any thread
+void imgRequest::EvictFromCache() {
+  /* The EvictFromCache() method here should only be called by this class. */
+  LOG_SCOPE(gImgLog, "imgRequest::EvictFromCache");
+
+  if (NS_IsMainThread()) {
+    ContinueEvict();
+  } else {
+    NS_DispatchToMainThread(new imgRequestMainThreadEvict(this));
+  }
+}
+
+// Helper-method used by EvictFromCache()
+void imgRequest::ContinueEvict() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RemoveFromCache();
+}
+
+void imgRequest::StartDecoding() {
+  MutexAutoLock lock(mMutex);
+  mDecodeRequested = true;
+}
+
+bool imgRequest::IsDecodeRequested() const {
+  MutexAutoLock lock(mMutex);
+  return mDecodeRequested;
+}
+
+nsresult imgRequest::GetURI(nsIURI** aURI) {
+  MOZ_ASSERT(aURI);
+
+  LOG_FUNC(gImgLog, "imgRequest::GetURI");
+
+  if (mURI) {
+    *aURI = mURI;
+    NS_ADDREF(*aURI);
+    return NS_OK;
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+nsresult imgRequest::GetFinalURI(nsIURI** aURI) {
+  MOZ_ASSERT(aURI);
+
+  LOG_FUNC(gImgLog, "imgRequest::GetFinalURI");
+
+  if (mFinalURI) {
+    *aURI = mFinalURI;
+    NS_ADDREF(*aURI);
+    return NS_OK;
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+bool imgRequest::IsChrome() const { return mURI->SchemeIs("chrome"); }
+
+bool imgRequest::IsData() const { return mURI->SchemeIs("data"); }
+
+nsresult imgRequest::GetImageErrorCode() { return mImageErrorCode; }
+
+void imgRequest::RemoveFromCache() {
+  LOG_SCOPE(gImgLog, "imgRequest::RemoveFromCache");
+
+  bool isInCache = false;
+
+  {
+    MutexAutoLock lock(mMutex);
+    isInCache = mIsInCache;
+  }
+
+  if (isInCache && mLoader) {
+    // mCacheEntry is nulled out when we have no more observers.
+    if (mCacheEntry) {
+      mLoader->RemoveFromCache(mCacheEntry);
+    } else {
+      mLoader->RemoveFromCache(mCacheKey);
+    }
+  }
+
+  mCacheEntry = nullptr;
+}
+
+bool imgRequest::HasConsumers() const {
+  RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+  return progressTracker && progressTracker->ObserverCount() > 0;
+}
+
+already_AddRefed<image::Image> imgRequest::GetImage() const {
+  MutexAutoLock lock(mMutex);
+  RefPtr<image::Image> image = mImage;
+  return image.forget();
+}
+
+int32_t imgRequest::Priority() const {
+  int32_t priority = nsISupportsPriority::PRIORITY_NORMAL;
+  nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mRequest);
+  if (p) {
+    p->GetPriority(&priority);
+  }
+  return priority;
+}
+
+void imgRequest::AdjustPriority(imgRequestProxy* proxy, int32_t delta) {
+  // only the first proxy is allowed to modify the priority of this image load.
+  //
+  // XXX(darin): this is probably not the most optimal algorithm as we may want
+  // to increase the priority of requests that have a lot of proxies.  the key
+  // concern though is that image loads remain lower priority than other pieces
+  // of content such as link clicks, CSS, and JS.
+  //
+  if (!mFirstProxy || proxy != mFirstProxy) {
+    return;
+  }
+
+  AdjustPriorityInternal(delta);
+}
+
+void imgRequest::AdjustPriorityInternal(int32_t aDelta) {
+  nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mChannel);
+  if (p) {
+    p->AdjustPriority(aDelta);
+  }
+}
+
+void imgRequest::BoostPriority(uint32_t aCategory) {
+  if (!StaticPrefs::image_layout_network_priority()) {
+    return;
+  }
+
+  uint32_t newRequestedCategory =
+      (mBoostCategoriesRequested & aCategory) ^ aCategory;
+  if (!newRequestedCategory) {
+    // priority boost for each category can only apply once.
+    return;
+  }
+
+  MOZ_LOG(gImgLog, LogLevel::Debug,
+          ("[this=%p] imgRequest::BoostPriority for category %x", this,
+           newRequestedCategory));
+
+  int32_t delta = 0;
+
+  if (newRequestedCategory & imgIRequest::CATEGORY_FRAME_INIT) {
+    --delta;
+  }
+
+  if (newRequestedCategory & imgIRequest::CATEGORY_FRAME_STYLE) {
+    --delta;
+  }
+
+  if (newRequestedCategory & imgIRequest::CATEGORY_SIZE_QUERY) {
+    --delta;
+  }
+
+  if (newRequestedCategory & imgIRequest::CATEGORY_DISPLAY) {
+    delta += nsISupportsPriority::PRIORITY_HIGH;
+  }
+
+  AdjustPriorityInternal(delta);
+  mBoostCategoriesRequested |= newRequestedCategory;
+}
+
+void imgRequest::SetIsInCache(bool aInCache) {
+  LOG_FUNC_WITH_PARAM(gImgLog, "imgRequest::SetIsCacheable", "aInCache",
+                      aInCache);
+  MutexAutoLock lock(mMutex);
+  mIsInCache = aInCache;
+}
+
+void imgRequest::UpdateCacheEntrySize() {
+  if (!mCacheEntry) {
+    return;
+  }
+
+  RefPtr<Image> image = GetImage();
+  SizeOfState state(moz_malloc_size_of);
+  size_t size = image->SizeOfSourceWithComputedFallback(state);
+  mCacheEntry->SetDataSize(size);
+}
+
+void imgRequest::SetCacheValidation(imgCacheEntry* aCacheEntry,
+                                    nsIRequest* aRequest) {
+  /* get the expires info */
+  if (!aCacheEntry || aCacheEntry->GetExpiryTime() != 0) {
+    return;
+  }
+
+  auto info = nsContentUtils::GetSubresourceCacheValidationInfo(aRequest);
+
+  // Expiration time defaults to 0. We set the expiration time on our entry if
+  // it hasn't been set yet.
+  if (!info.mExpirationTime) {
+    // If the channel doesn't support caching, then ensure this expires the
+    // next time it is used.
+    info.mExpirationTime.emplace(nsContentUtils::SecondsFromPRTime(PR_Now()) -
+                                 1);
+  }
+  aCacheEntry->SetExpiryTime(*info.mExpirationTime);
+  // Cache entries default to not needing to validate. We ensure that
+  // multiple calls to this function don't override an earlier decision to
+  // validate by making validation a one-way decision.
+  if (info.mMustRevalidate) {
+    aCacheEntry->SetMustValidate(info.mMustRevalidate);
+  }
+}
+
+namespace {
+
+already_AddRefed<nsIApplicationCache> GetApplicationCache(
+    nsIRequest* aRequest) {
+  nsresult rv;
+
+  nsCOMPtr<nsIApplicationCacheChannel> appCacheChan =
+      do_QueryInterface(aRequest);
+  if (!appCacheChan) {
+    return nullptr;
+  }
+
+  bool fromAppCache;
+  rv = appCacheChan->GetLoadedFromApplicationCache(&fromAppCache);
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  if (!fromAppCache) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIApplicationCache> appCache;
+  rv = appCacheChan->GetApplicationCache(getter_AddRefs(appCache));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  return appCache.forget();
+}
+
+}  // namespace
+
+bool imgRequest::CacheChanged(nsIRequest* aNewRequest) {
+  nsCOMPtr<nsIApplicationCache> newAppCache = GetApplicationCache(aNewRequest);
+
+  // Application cache not involved at all or the same app cache involved
+  // in both of the loads (original and new).
+  if (newAppCache == mApplicationCache) {
+    return false;
+  }
+
+  // In a rare case it may happen that two objects still refer
+  // the same application cache version.
+  if (newAppCache && mApplicationCache) {
+    nsresult rv;
+
+    nsAutoCString oldAppCacheClientId, newAppCacheClientId;
+    rv = mApplicationCache->GetClientID(oldAppCacheClientId);
+    NS_ENSURE_SUCCESS(rv, true);
+    rv = newAppCache->GetClientID(newAppCacheClientId);
+    NS_ENSURE_SUCCESS(rv, true);
+
+    if (oldAppCacheClientId == newAppCacheClientId) {
+      return false;
+    }
+  }
+
+  // When we get here, app caches differ or app cache is involved
+  // just in one of the loads what we also consider as a change
+  // in a loading cache.
+  return true;
+}
+
+bool imgRequest::GetMultipart() const {
+  MutexAutoLock lock(mMutex);
+  return mIsMultiPartChannel;
+}
+
+bool imgRequest::HadInsecureRedirect() const {
+  MutexAutoLock lock(mMutex);
+  return mHadInsecureRedirect;
+}
+
+/** nsIRequestObserver methods **/
+
+NS_IMETHODIMP
+imgRequest::OnStartRequest(nsIRequest* aRequest) {
+  LOG_SCOPE(gImgLog, "imgRequest::OnStartRequest");
+
+  RefPtr<Image> image;
+
+  if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest)) {
+    nsresult rv;
+    nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->LoadInfo();
+    mIsDeniedCrossSiteCORSRequest =
+        loadInfo->GetTainting() == LoadTainting::CORS &&
+        (NS_FAILED(httpChannel->GetStatus(&rv)) || NS_FAILED(rv));
+    mIsCrossSiteNoCORSRequest = loadInfo->GetTainting() == LoadTainting::Opaque;
+  }
+
+  // Figure out if we're multipart.
+  nsCOMPtr<nsIMultiPartChannel> multiPartChannel = do_QueryInterface(aRequest);
+  {
+    MutexAutoLock lock(mMutex);
+
+    MOZ_ASSERT(multiPartChannel || !mIsMultiPartChannel,
+               "Stopped being multipart?");
+
+    mNewPartPending = true;
+    image = mImage;
+    mIsMultiPartChannel = bool(multiPartChannel);
+  }
+
+  // If we're not multipart, we shouldn't have an image yet.
+  if (image && !multiPartChannel) {
+    MOZ_ASSERT_UNREACHABLE("Already have an image for a non-multipart request");
+    Cancel(NS_IMAGELIB_ERROR_FAILURE);
+    return NS_ERROR_FAILURE;
+  }
+
+  /*
+   * If mRequest is null here, then we need to set it so that we'll be able to
+   * cancel it if our Cancel() method is called.  Note that this can only
+   * happen for multipart channels.  We could simply not null out mRequest for
+   * non-last parts, if GetIsLastPart() were reliable, but it's not.  See
+   * https://bugzilla.mozilla.org/show_bug.cgi?id=339610
+   */
+  if (!mRequest) {
+    MOZ_ASSERT(multiPartChannel, "Should have mRequest unless we're multipart");
+    nsCOMPtr<nsIChannel> baseChannel;
+    multiPartChannel->GetBaseChannel(getter_AddRefs(baseChannel));
+    mRequest = baseChannel;
+  }
+
+  nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
+  if (channel) {
+    /* Get our principal */
+    nsCOMPtr<nsIScriptSecurityManager> secMan =
+        nsContentUtils::GetSecurityManager();
+    if (secMan) {
+      nsresult rv = secMan->GetChannelResultPrincipal(
+          channel, getter_AddRefs(mPrincipal));
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+    }
+  }
+
+  SetCacheValidation(mCacheEntry, aRequest);
+
+  mApplicationCache = GetApplicationCache(aRequest);
+
+  // Shouldn't we be dead already if this gets hit?
+  // Probably multipart/x-mixed-replace...
+  RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+  if (progressTracker->ObserverCount() == 0) {
+    this->Cancel(NS_IMAGELIB_ERROR_FAILURE);
+  }
+
+  // Try to retarget OnDataAvailable to a decode thread. We must process data
+  // URIs synchronously as per the spec however.
+  if (!channel || IsData()) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIThreadRetargetableRequest> retargetable =
+      do_QueryInterface(aRequest);
+  if (retargetable) {
+    nsAutoCString mimeType;
+    nsresult rv = channel->GetContentType(mimeType);
+    if (NS_SUCCEEDED(rv) && !mimeType.EqualsLiteral(IMAGE_SVG_XML)) {
+      // Retarget OnDataAvailable to the DecodePool's IO thread.
+      nsCOMPtr<nsIEventTarget> target =
+          DecodePool::Singleton()->GetIOEventTarget();
+      rv = retargetable->RetargetDeliveryTo(target);
+    }
+    MOZ_LOG(gImgLog, LogLevel::Warning,
+            ("[this=%p] imgRequest::OnStartRequest -- "
+             "RetargetDeliveryTo rv %" PRIu32 "=%s\n",
+             this, static_cast<uint32_t>(rv),
+             NS_SUCCEEDED(rv) ? "succeeded" : "failed"));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequest::OnStopRequest(nsIRequest* aRequest, nsresult status) {
+  LOG_FUNC(gImgLog, "imgRequest::OnStopRequest");
+  MOZ_ASSERT(NS_IsMainThread(), "Can't send notifications off-main-thread");
+
+  RefPtr<Image> image = GetImage();
+
+  RefPtr<imgRequest> strongThis = this;
+
+  if (mIsMultiPartChannel && mNewPartPending) {
+    OnDataAvailable(aRequest, nullptr, 0, 0);
+  }
+
+  // XXXldb What if this is a non-last part of a multipart request?
+  // xxx before we release our reference to mRequest, lets
+  // save the last status that we saw so that the
+  // imgRequestProxy will have access to it.
+  if (mRequest) {
+    mRequest = nullptr;  // we no longer need the request
+  }
+
+  // stop holding a ref to the channel, since we don't need it anymore
+  if (mChannel) {
+    mChannel->SetNotificationCallbacks(mPrevChannelSink);
+    mPrevChannelSink = nullptr;
+    mChannel = nullptr;
+  }
+
+  bool lastPart = true;
+  nsCOMPtr<nsIMultiPartChannel> mpchan(do_QueryInterface(aRequest));
+  if (mpchan) {
+    mpchan->GetIsLastPart(&lastPart);
+  }
+
+  bool isPartial = false;
+  if (image && (status == NS_ERROR_NET_PARTIAL_TRANSFER)) {
+    isPartial = true;
+    status = NS_OK;  // fake happy face
+  }
+
+  // Tell the image that it has all of the source data. Note that this can
+  // trigger a failure, since the image might be waiting for more non-optional
+  // data and this is the point where we break the news that it's not coming.
+  if (image) {
+    nsresult rv =
+        image->OnImageDataComplete(aRequest, nullptr, status, lastPart);
+
+    // If we got an error in the OnImageDataComplete() call, we don't want to
+    // proceed as if nothing bad happened. However, we also want to give
+    // precedence to failure status codes from necko, since presumably they're
+    // more meaningful.
+    if (NS_FAILED(rv) && NS_SUCCEEDED(status)) {
+      status = rv;
+    }
+  }
+
+  // If the request went through, update the cache entry size. Otherwise,
+  // cancel the request, which removes us from the cache.
+  if (image && NS_SUCCEEDED(status) && !isPartial) {
+    // We update the cache entry size here because this is where we finish
+    // loading compressed source data, which is part of our size calculus.
+    UpdateCacheEntrySize();
+
+  } else if (isPartial) {
+    // Remove the partial image from the cache.
+    this->EvictFromCache();
+
+  } else {
+    mImageErrorCode = status;
+
+    // if the error isn't "just" a partial transfer
+    // stops animations, removes from cache
+    this->Cancel(status);
+  }
+
+  if (!image) {
+    // We have to fire the OnStopRequest notifications ourselves because there's
+    // no image capable of doing so.
+    Progress progress =
+        LoadCompleteProgress(lastPart, /* aError = */ false, status);
+
+    RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+    progressTracker->SyncNotifyProgress(progress);
+  }
+
+  mTimedChannel = nullptr;
+  return NS_OK;
+}
+
+struct mimetype_closure {
+  nsACString* newType;
+};
+
+/* prototype for these defined below */
+static nsresult sniff_mimetype_callback(nsIInputStream* in, void* closure,
+                                        const char* fromRawSegment,
+                                        uint32_t toOffset, uint32_t count,
+                                        uint32_t* writeCount);
+
+/** nsThreadRetargetableStreamListener methods **/
+NS_IMETHODIMP
+imgRequest::CheckListenerChain() {
+  // TODO Might need more checking here.
+  NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!");
+  return NS_OK;
+}
+
+/** nsIStreamListener methods **/
+
+struct NewPartResult final {
+  explicit NewPartResult(image::Image* aExistingImage)
+      : mImage(aExistingImage),
+        mIsFirstPart(!aExistingImage),
+        mSucceeded(false),
+        mShouldResetCacheEntry(false) {}
+
+  nsAutoCString mContentType;
+  nsAutoCString mContentDisposition;
+  RefPtr<image::Image> mImage;
+  const bool mIsFirstPart;
+  bool mSucceeded;
+  bool mShouldResetCacheEntry;
+};
+
+static NewPartResult PrepareForNewPart(nsIRequest* aRequest,
+                                       nsIInputStream* aInStr, uint32_t aCount,
+                                       nsIURI* aURI, bool aIsMultipart,
+                                       image::Image* aExistingImage,
+                                       ProgressTracker* aProgressTracker,
+                                       uint32_t aInnerWindowId) {
+  NewPartResult result(aExistingImage);
+
+  if (aInStr) {
+    mimetype_closure closure;
+    closure.newType = &result.mContentType;
+
+    // Look at the first few bytes and see if we can tell what the data is from
+    // that since servers tend to lie. :(
+    uint32_t out;
+    aInStr->ReadSegments(sniff_mimetype_callback, &closure, aCount, &out);
+  }
+
+  nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest));
+  if (result.mContentType.IsEmpty()) {
+    nsresult rv =
+        chan ? chan->GetContentType(result.mContentType) : NS_ERROR_FAILURE;
+    if (NS_FAILED(rv)) {
+      MOZ_LOG(gImgLog, LogLevel::Error,
+              ("imgRequest::PrepareForNewPart -- "
+               "Content type unavailable from the channel\n"));
+      if (!aIsMultipart) {
+        return result;
+      }
+    }
+  }
+
+  if (chan) {
+    chan->GetContentDispositionHeader(result.mContentDisposition);
+  }
+
+  MOZ_LOG(gImgLog, LogLevel::Debug,
+          ("imgRequest::PrepareForNewPart -- Got content type %s\n",
+           result.mContentType.get()));
+
+  // XXX If server lied about mimetype and it's SVG, we may need to copy
+  // the data and dispatch back to the main thread, AND tell the channel to
+  // dispatch there in the future.
+
+  // Create the new image and give it ownership of our ProgressTracker.
+  if (aIsMultipart) {
+    // Create the ProgressTracker and image for this part.
+    RefPtr<ProgressTracker> progressTracker = new ProgressTracker();
+    RefPtr<image::Image> partImage = image::ImageFactory::CreateImage(
+        aRequest, progressTracker, result.mContentType, aURI,
+        /* aIsMultipart = */ true, aInnerWindowId);
+
+    if (result.mIsFirstPart) {
+      // First part for a multipart channel. Create the MultipartImage wrapper.
+      MOZ_ASSERT(aProgressTracker, "Shouldn't have given away tracker yet");
+      aProgressTracker->SetIsMultipart();
+      result.mImage = image::ImageFactory::CreateMultipartImage(
+          partImage, aProgressTracker);
+    } else {
+      // Transition to the new part.
+      auto multipartImage = static_cast<MultipartImage*>(aExistingImage);
+      multipartImage->BeginTransitionToPart(partImage);
+
+      // Reset our cache entry size so it doesn't keep growing without bound.
+      result.mShouldResetCacheEntry = true;
+    }
+  } else {
+    MOZ_ASSERT(!aExistingImage, "New part for non-multipart channel?");
+    MOZ_ASSERT(aProgressTracker, "Shouldn't have given away tracker yet");
+
+    // Create an image using our progress tracker.
+    result.mImage = image::ImageFactory::CreateImage(
+        aRequest, aProgressTracker, result.mContentType, aURI,
+        /* aIsMultipart = */ false, aInnerWindowId);
+  }
+
+  MOZ_ASSERT(result.mImage);
+  if (!result.mImage->HasError() || aIsMultipart) {
+    // We allow multipart images to fail to initialize (which generally
+    // indicates a bad content type) without cancelling the load, because
+    // subsequent parts might be fine.
+    result.mSucceeded = true;
+  }
+
+  return result;
+}
+
+class FinishPreparingForNewPartRunnable final : public Runnable {
+ public:
+  FinishPreparingForNewPartRunnable(imgRequest* aImgRequest,
+                                    NewPartResult&& aResult)
+      : Runnable("FinishPreparingForNewPartRunnable"),
+        mImgRequest(aImgRequest),
+        mResult(aResult) {
+    MOZ_ASSERT(aImgRequest);
+  }
+
+  NS_IMETHOD Run() override {
+    mImgRequest->FinishPreparingForNewPart(mResult);
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<imgRequest> mImgRequest;
+  NewPartResult mResult;
+};
+
+void imgRequest::FinishPreparingForNewPart(const NewPartResult& aResult) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mContentType = aResult.mContentType;
+
+  SetProperties(aResult.mContentType, aResult.mContentDisposition);
+
+  if (aResult.mIsFirstPart) {
+    // Notify listeners that we have an image.
+    mImageAvailable = true;
+    RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
+    progressTracker->OnImageAvailable();
+    MOZ_ASSERT(progressTracker->HasImage());
+  }
+
+  if (aResult.mShouldResetCacheEntry) {
+    ResetCacheEntry();
+  }
+
+  if (IsDecodeRequested()) {
+    aResult.mImage->StartDecoding(imgIContainer::FLAG_NONE);
+  }
+}
+
+bool imgRequest::ImageAvailable() const { return mImageAvailable; }
+
+NS_IMETHODIMP
+imgRequest::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr,
+                            uint64_t aOffset, uint32_t aCount) {
+  LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::OnDataAvailable", "count", aCount);
+
+  NS_ASSERTION(aRequest, "imgRequest::OnDataAvailable -- no request!");
+
+  RefPtr<Image> image;
+  RefPtr<ProgressTracker> progressTracker;
+  bool isMultipart = false;
+  bool newPartPending = false;
+
+  // Retrieve and update our state.
+  {
+    MutexAutoLock lock(mMutex);
+    image = mImage;
+    progressTracker = mProgressTracker;
+    isMultipart = mIsMultiPartChannel;
+    newPartPending = mNewPartPending;
+    mNewPartPending = false;
+  }
+
+  // If this is a new part, we need to sniff its content type and create an
+  // appropriate image.
+  if (newPartPending) {
+    NewPartResult result =
+        PrepareForNewPart(aRequest, aInStr, aCount, mURI, isMultipart, image,
+                          progressTracker, mInnerWindowId);
+    bool succeeded = result.mSucceeded;
+
+    if (result.mImage) {
+      image = result.mImage;
+      nsCOMPtr<nsIEventTarget> eventTarget;
+
+      // Update our state to reflect this new part.
+      {
+        MutexAutoLock lock(mMutex);
+        mImage = image;
+
+        // We only get an event target if we are not on the main thread, because
+        // we have to dispatch in that case. If we are on the main thread, but
+        // on a different scheduler group than ProgressTracker would give us,
+        // that is okay because nothing in imagelib requires that, just our
+        // listeners (which have their own checks).
+        if (!NS_IsMainThread()) {
+          eventTarget = mProgressTracker->GetEventTarget();
+          MOZ_ASSERT(eventTarget);
+        }
+
+        mProgressTracker = nullptr;
+      }
+
+      // Some property objects are not threadsafe, and we need to send
+      // OnImageAvailable on the main thread, so finish on the main thread.
+      if (!eventTarget) {
+        MOZ_ASSERT(NS_IsMainThread());
+        FinishPreparingForNewPart(result);
+      } else {
+        nsCOMPtr<nsIRunnable> runnable =
+            new FinishPreparingForNewPartRunnable(this, std::move(result));
+        eventTarget->Dispatch(CreateMediumHighRunnable(runnable.forget()),
+                              NS_DISPATCH_NORMAL);
+      }
+    }
+
+    if (!succeeded) {
+      // Something went wrong; probably a content type issue.
+      Cancel(NS_IMAGELIB_ERROR_FAILURE);
+      return NS_BINDING_ABORTED;
+    }
+  }
+
+  // Notify the image that it has new data.
+  if (aInStr) {
+    nsresult rv =
+        image->OnImageDataAvailable(aRequest, nullptr, aInStr, aOffset, aCount);
+
+    if (NS_FAILED(rv)) {
+      MOZ_LOG(gImgLog, LogLevel::Warning,
+              ("[this=%p] imgRequest::OnDataAvailable -- "
+               "copy to RasterImage failed\n",
+               this));
+      Cancel(NS_IMAGELIB_ERROR_FAILURE);
+      return NS_BINDING_ABORTED;
+    }
+  }
+
+  return NS_OK;
+}
+
+void imgRequest::SetProperties(const nsACString& aContentType,
+                               const nsACString& aContentDisposition) {
+  /* set our mimetype as a property */
+  nsCOMPtr<nsISupportsCString> contentType =
+      do_CreateInstance("@mozilla.org/supports-cstring;1");
+  if (contentType) {
+    contentType->SetData(aContentType);
+    mProperties->Set("type", contentType);
+  }
+
+  /* set our content disposition as a property */
+  if (!aContentDisposition.IsEmpty()) {
+    nsCOMPtr<nsISupportsCString> contentDisposition =
+        do_CreateInstance("@mozilla.org/supports-cstring;1");
+    if (contentDisposition) {
+      contentDisposition->SetData(aContentDisposition);
+      mProperties->Set("content-disposition", contentDisposition);
+    }
+  }
+}
+
+static nsresult sniff_mimetype_callback(nsIInputStream* in, void* data,
+                                        const char* fromRawSegment,
+                                        uint32_t toOffset, uint32_t count,
+                                        uint32_t* writeCount) {
+  mimetype_closure* closure = static_cast<mimetype_closure*>(data);
+
+  NS_ASSERTION(closure, "closure is null!");
+
+  if (count > 0) {
+    imgLoader::GetMimeTypeFromContent(fromRawSegment, count, *closure->newType);
+  }
+
+  *writeCount = 0;
+  return NS_ERROR_FAILURE;
+}
+
+/** nsIInterfaceRequestor methods **/
+
+NS_IMETHODIMP
+imgRequest::GetInterface(const nsIID& aIID, void** aResult) {
+  if (!mPrevChannelSink || aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
+    return QueryInterface(aIID, aResult);
+  }
+
+  NS_ASSERTION(
+      mPrevChannelSink != this,
+      "Infinite recursion - don't keep track of channel sinks that are us!");
+  return mPrevChannelSink->GetInterface(aIID, aResult);
+}
+
+/** nsIChannelEventSink methods **/
+NS_IMETHODIMP
+imgRequest::AsyncOnChannelRedirect(nsIChannel* oldChannel,
+                                   nsIChannel* newChannel, uint32_t flags,
+                                   nsIAsyncVerifyRedirectCallback* callback) {
+  NS_ASSERTION(mRequest && mChannel,
+               "Got a channel redirect after we nulled out mRequest!");
+  NS_ASSERTION(mChannel == oldChannel,
+               "Got a channel redirect for an unknown channel!");
+  NS_ASSERTION(newChannel, "Got a redirect to a NULL channel!");
+
+  SetCacheValidation(mCacheEntry, oldChannel);
+
+  // Prepare for callback
+  mRedirectCallback = callback;
+  mNewRedirectChannel = newChannel;
+
+  nsCOMPtr<nsIChannelEventSink> sink(do_GetInterface(mPrevChannelSink));
+  if (sink) {
+    nsresult rv =
+        sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this);
+    if (NS_FAILED(rv)) {
+      mRedirectCallback = nullptr;
+      mNewRedirectChannel = nullptr;
+    }
+    return rv;
+  }
+
+  (void)OnRedirectVerifyCallback(NS_OK);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+imgRequest::OnRedirectVerifyCallback(nsresult result) {
+  NS_ASSERTION(mRedirectCallback, "mRedirectCallback not set in callback");
+  NS_ASSERTION(mNewRedirectChannel, "mNewRedirectChannel not set in callback");
+
+  if (NS_FAILED(result)) {
+    mRedirectCallback->OnRedirectVerifyCallback(result);
+    mRedirectCallback = nullptr;
+    mNewRedirectChannel = nullptr;
+    return NS_OK;
+  }
+
+  mChannel = mNewRedirectChannel;
+  mTimedChannel = do_QueryInterface(mChannel);
+  mNewRedirectChannel = nullptr;
+
+  if (LOG_TEST(LogLevel::Debug)) {
+    LOG_MSG_WITH_PARAM(gImgLog, "imgRequest::OnChannelRedirect", "old",
+                       mFinalURI ? mFinalURI->GetSpecOrDefault().get() : "");
+  }
+
+  // If the previous URI is a non-HTTPS URI, record that fact for later use by
+  // security code, which needs to know whether there is an insecure load at any
+  // point in the redirect chain.
+  bool schemeLocal = false;
+  if (NS_FAILED(NS_URIChainHasFlags(mFinalURI,
+                                    nsIProtocolHandler::URI_IS_LOCAL_RESOURCE,
+                                    &schemeLocal)) ||
+      (!mFinalURI->SchemeIs("https") && !mFinalURI->SchemeIs("chrome") &&
+       !schemeLocal)) {
+    MutexAutoLock lock(mMutex);
+
+    // The csp directive upgrade-insecure-requests performs an internal redirect
+    // to upgrade all requests from http to https before any data is fetched
+    // from the network. Do not pollute mHadInsecureRedirect in case of such an
+    // internal redirect.
+    nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
+    bool upgradeInsecureRequests =
+        loadInfo ? loadInfo->GetUpgradeInsecureRequests() ||
+                       loadInfo->GetBrowserUpgradeInsecureRequests()
+                 : false;
+    if (!upgradeInsecureRequests) {
+      mHadInsecureRedirect = true;
+    }
+  }
+
+  // Update the final URI.
+  mChannel->GetURI(getter_AddRefs(mFinalURI));
+
+  if (LOG_TEST(LogLevel::Debug)) {
+    LOG_MSG_WITH_PARAM(gImgLog, "imgRequest::OnChannelRedirect", "new",
+                       mFinalURI ? mFinalURI->GetSpecOrDefault().get() : "");
+  }
+
+  // Make sure we have a protocol that returns data rather than opens an
+  // external application, e.g. 'mailto:'.
+  bool doesNotReturnData = false;
+  nsresult rv = NS_URIChainHasFlags(
+      mFinalURI, nsIProtocolHandler::URI_DOES_NOT_RETURN_DATA,
+      &doesNotReturnData);
+
+  if (NS_SUCCEEDED(rv) && doesNotReturnData) {
+    rv = NS_ERROR_ABORT;
+  }
+
+  if (NS_FAILED(rv)) {
+    mRedirectCallback->OnRedirectVerifyCallback(rv);
+    mRedirectCallback = nullptr;
+    return NS_OK;
+  }
+
+  mRedirectCallback->OnRedirectVerifyCallback(NS_OK);
+  mRedirectCallback = nullptr;
+  return NS_OK;
+}