image/imgRequest.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "imgRequest.h"
   8 #include "ImageLogging.h"
   9
  10 #include "imgLoader.h"
  11 #include "imgRequestProxy.h"
  12 #include "DecodePool.h"
  13 #include "ProgressTracker.h"
  14 #include "ImageFactory.h"
  15 #include "Image.h"
  16 #include "MultipartImage.h"
  17 #include "RasterImage.h"
  18
  19 #include "nsIChannel.h"
  20 #include "nsICacheInfoChannel.h"
  21 #include "mozilla/dom/Document.h"
  22 #include "nsIThreadRetargetableRequest.h"
  23 #include "nsIInputStream.h"
  24 #include "nsIMultiPartChannel.h"
  25 #include "nsIHttpChannel.h"
  26 #include "nsIApplicationCache.h"
  27 #include "nsIApplicationCacheChannel.h"
  28 #include "nsMimeTypes.h"
  29
  30 #include "nsIInterfaceRequestorUtils.h"
  31 #include "nsISupportsPrimitives.h"
  32 #include "nsIScriptSecurityManager.h"
  33 #include "nsContentUtils.h"
  34
  35 #include "plstr.h"   // PL_strcasestr(...)
  36 #include "prtime.h"  // for PR_Now
  37 #include "nsNetUtil.h"
  38 #include "nsIProtocolHandler.h"
  39 #include "imgIRequest.h"
  40 #include "nsProperties.h"
  41
  42 #include "mozilla/IntegerPrintfMacros.h"
  43 #include "mozilla/SizeOfState.h"
  44
  45 using namespace mozilla;
  46 using namespace mozilla::image;
  47
  48 #define LOG_TEST(level) (MOZ_LOG_TEST(gImgLog, (level)))
  49
  50 NS_IMPL_ISUPPORTS(imgRequest, nsIStreamListener, nsIRequestObserver,
  51                   nsIThreadRetargetableStreamListener, nsIChannelEventSink,
  52                   nsIInterfaceRequestor, nsIAsyncVerifyRedirectCallback)
  53
  54 imgRequest::imgRequest(imgLoader* aLoader, const ImageCacheKey& aCacheKey)
  55     : mLoader(aLoader),
  56       mCacheKey(aCacheKey),
  57       mLoadId(nullptr),
  58       mFirstProxy(nullptr),
  59       mValidator(nullptr),
  60       mInnerWindowId(0),
  61       mCORSMode(imgIRequest::CORS_NONE),
  62       mImageErrorCode(NS_OK),
  63       mImageAvailable(false),
  64       mMutex("imgRequest"),
  65       mProgressTracker(new ProgressTracker()),
  66       mIsMultiPartChannel(false),
  67       mIsInCache(false),
  68       mDecodeRequested(false),
  69       mNewPartPending(false),
  70       mHadInsecureRedirect(false) {
  71   LOG_FUNC(gImgLog, "imgRequest::imgRequest()");
  72 }
  73
  74 imgRequest::~imgRequest() {
  75   if (mLoader) {
  76     mLoader->RemoveFromUncachedImages(this);
  77   }
  78   if (mURI) {
  79     LOG_FUNC_WITH_PARAM(gImgLog, "imgRequest::~imgRequest()", "keyuri", mURI);
  80   } else
  81     LOG_FUNC(gImgLog, "imgRequest::~imgRequest()");
  82 }
  83
  84 nsresult imgRequest::Init(nsIURI* aURI, nsIURI* aFinalURI,
  85                           bool aHadInsecureRedirect, nsIRequest* aRequest,
  86                           nsIChannel* aChannel, imgCacheEntry* aCacheEntry,
  87                           nsISupports* aCX, nsIPrincipal* aTriggeringPrincipal,
  88                           int32_t aCORSMode, nsIReferrerInfo* aReferrerInfo) {
  89   MOZ_ASSERT(NS_IsMainThread(), "Cannot use nsIURI off main thread!");
  90
  91   LOG_FUNC(gImgLog, "imgRequest::Init");
  92
  93   MOZ_ASSERT(!mImage, "Multiple calls to init");
  94   MOZ_ASSERT(aURI, "No uri");
  95   MOZ_ASSERT(aFinalURI, "No final uri");
  96   MOZ_ASSERT(aRequest, "No request");
  97   MOZ_ASSERT(aChannel, "No channel");
  98
  99   mProperties = new nsProperties();
 100   mURI = aURI;
 101   mFinalURI = aFinalURI;
 102   mRequest = aRequest;
 103   mChannel = aChannel;
 104   mTimedChannel = do_QueryInterface(mChannel);
 105   mTriggeringPrincipal = aTriggeringPrincipal;
 106   mCORSMode = aCORSMode;
 107   mReferrerInfo = aReferrerInfo;
 108
 109   // If the original URI and the final URI are different, check whether the
 110   // original URI is secure. We deliberately don't take the final URI into
 111   // account, as it needs to be handled using more complicated rules than
 112   // earlier elements of the redirect chain.
 113   if (aURI != aFinalURI) {
 114     bool schemeLocal = false;
 115     if (NS_FAILED(NS_URIChainHasFlags(
 116             aURI, nsIProtocolHandler::URI_IS_LOCAL_RESOURCE, &schemeLocal)) ||
 117         (!aURI->SchemeIs("https") && !aURI->SchemeIs("chrome") &&
 118          !schemeLocal)) {
 119       mHadInsecureRedirect = true;
 120     }
 121   }
 122
 123   // imgCacheValidator may have handled redirects before we were created, so we
 124   // allow the caller to let us know if any redirects were insecure.
 125   mHadInsecureRedirect = mHadInsecureRedirect || aHadInsecureRedirect;
 126
 127   mChannel->GetNotificationCallbacks(getter_AddRefs(mPrevChannelSink));
 128
 129   NS_ASSERTION(mPrevChannelSink != this,
 130                "Initializing with a channel that already calls back to us!");
 131
 132   mChannel->SetNotificationCallbacks(this);
 133
 134   mCacheEntry = aCacheEntry;
 135   mCacheEntry->UpdateLoadTime();
 136
 137   SetLoadId(aCX);
 138
 139   // Grab the inner window ID of the loading document, if possible.
 140   nsCOMPtr<dom::Document> doc = do_QueryInterface(aCX);
 141   if (doc) {
 142     mInnerWindowId = doc->InnerWindowID();
 143   }
 144
 145   return NS_OK;
 146 }
 147
 148 void imgRequest::ClearLoader() { mLoader = nullptr; }
 149
 150 already_AddRefed<ProgressTracker> imgRequest::GetProgressTracker() const {
 151   MutexAutoLock lock(mMutex);
 152
 153   if (mImage) {
 154     MOZ_ASSERT(!mProgressTracker,
 155                "Should have given mProgressTracker to mImage");
 156     return mImage->GetProgressTracker();
 157   }
 158   MOZ_ASSERT(mProgressTracker,
 159              "Should have mProgressTracker until we create mImage");
 160   RefPtr<ProgressTracker> progressTracker = mProgressTracker;
 161   MOZ_ASSERT(progressTracker);
 162   return progressTracker.forget();
 163 }
 164
 165 void imgRequest::SetCacheEntry(imgCacheEntry* entry) { mCacheEntry = entry; }
 166
 167 bool imgRequest::HasCacheEntry() const { return mCacheEntry != nullptr; }
 168
 169 void imgRequest::ResetCacheEntry() {
 170   if (HasCacheEntry()) {
 171     mCacheEntry->SetDataSize(0);
 172   }
 173 }
 174
 175 void imgRequest::AddProxy(imgRequestProxy* proxy) {
 176   MOZ_ASSERT(proxy, "null imgRequestProxy passed in");
 177   LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::AddProxy", "proxy", proxy);
 178
 179   if (!mFirstProxy) {
 180     // Save a raw pointer to the first proxy we see, for use in the network
 181     // priority logic.
 182     mFirstProxy = proxy;
 183   }
 184
 185   // If we're empty before adding, we have to tell the loader we now have
 186   // proxies.
 187   RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 188   if (progressTracker->ObserverCount() == 0) {
 189     MOZ_ASSERT(mURI, "Trying to SetHasProxies without key uri.");
 190     if (mLoader) {
 191       mLoader->SetHasProxies(this);
 192     }
 193   }
 194
 195   progressTracker->AddObserver(proxy);
 196 }
 197
 198 nsresult imgRequest::RemoveProxy(imgRequestProxy* proxy, nsresult aStatus) {
 199   LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::RemoveProxy", "proxy", proxy);
 200
 201   // This will remove our animation consumers, so after removing
 202   // this proxy, we don't end up without proxies with observers, but still
 203   // have animation consumers.
 204   proxy->ClearAnimationConsumers();
 205
 206   // Let the status tracker do its thing before we potentially call Cancel()
 207   // below, because Cancel() may result in OnStopRequest being called back
 208   // before Cancel() returns, leaving the image in a different state then the
 209   // one it was in at this point.
 210   RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 211   if (!progressTracker->RemoveObserver(proxy)) {
 212     return NS_OK;
 213   }
 214
 215   if (progressTracker->ObserverCount() == 0) {
 216     // If we have no observers, there's nothing holding us alive. If we haven't
 217     // been cancelled and thus removed from the cache, tell the image loader so
 218     // we can be evicted from the cache.
 219     if (mCacheEntry) {
 220       MOZ_ASSERT(mURI, "Removing last observer without key uri.");
 221
 222       if (mLoader) {
 223         mLoader->SetHasNoProxies(this, mCacheEntry);
 224       }
 225     } else {
 226       LOG_MSG_WITH_PARAM(gImgLog, "imgRequest::RemoveProxy no cache entry",
 227                          "uri", mURI);
 228     }
 229
 230     /* If |aStatus| is a failure code, then cancel the load if it is still in
 231        progress.  Otherwise, let the load continue, keeping 'this' in the cache
 232        with no observers.  This way, if a proxy is destroyed without calling
 233        cancel on it, it won't leak and won't leave a bad pointer in the observer
 234        list.
 235      */
 236     if (!(progressTracker->GetProgress() & FLAG_LAST_PART_COMPLETE) &&
 237         NS_FAILED(aStatus)) {
 238       LOG_MSG(gImgLog, "imgRequest::RemoveProxy",
 239               "load in progress.  canceling");
 240
 241       this->Cancel(NS_BINDING_ABORTED);
 242     }
 243
 244     /* break the cycle from the cache entry. */
 245     mCacheEntry = nullptr;
 246   }
 247
 248   return NS_OK;
 249 }
 250
 251 void imgRequest::CancelAndAbort(nsresult aStatus) {
 252   LOG_SCOPE(gImgLog, "imgRequest::CancelAndAbort");
 253
 254   Cancel(aStatus);
 255
 256   // It's possible for the channel to fail to open after we've set our
 257   // notification callbacks. In that case, make sure to break the cycle between
 258   // the channel and us, because it won't.
 259   if (mChannel) {
 260     mChannel->SetNotificationCallbacks(mPrevChannelSink);
 261     mPrevChannelSink = nullptr;
 262   }
 263 }
 264
 265 class imgRequestMainThreadCancel : public Runnable {
 266  public:
 267   imgRequestMainThreadCancel(imgRequest* aImgRequest, nsresult aStatus)
 268       : Runnable("imgRequestMainThreadCancel"),
 269         mImgRequest(aImgRequest),
 270         mStatus(aStatus) {
 271     MOZ_ASSERT(!NS_IsMainThread(), "Create me off main thread only!");
 272     MOZ_ASSERT(aImgRequest);
 273   }
 274
 275   NS_IMETHOD Run() override {
 276     MOZ_ASSERT(NS_IsMainThread(), "I should be running on the main thread!");
 277     mImgRequest->ContinueCancel(mStatus);
 278     return NS_OK;
 279   }
 280
 281  private:
 282   RefPtr<imgRequest> mImgRequest;
 283   nsresult mStatus;
 284 };
 285
 286 void imgRequest::Cancel(nsresult aStatus) {
 287   /* The Cancel() method here should only be called by this class. */
 288   LOG_SCOPE(gImgLog, "imgRequest::Cancel");
 289
 290   if (NS_IsMainThread()) {
 291     ContinueCancel(aStatus);
 292   } else {
 293     RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 294     nsCOMPtr<nsIEventTarget> eventTarget = progressTracker->GetEventTarget();
 295     nsCOMPtr<nsIRunnable> ev = new imgRequestMainThreadCancel(this, aStatus);
 296     eventTarget->Dispatch(ev.forget(), NS_DISPATCH_NORMAL);
 297   }
 298 }
 299
 300 void imgRequest::ContinueCancel(nsresult aStatus) {
 301   MOZ_ASSERT(NS_IsMainThread());
 302
 303   RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 304   progressTracker->SyncNotifyProgress(FLAG_HAS_ERROR);
 305
 306   RemoveFromCache();
 307
 308   if (mRequest && !(progressTracker->GetProgress() & FLAG_LAST_PART_COMPLETE)) {
 309     mRequest->Cancel(aStatus);
 310   }
 311 }
 312
 313 class imgRequestMainThreadEvict : public Runnable {
 314  public:
 315   explicit imgRequestMainThreadEvict(imgRequest* aImgRequest)
 316       : Runnable("imgRequestMainThreadEvict"), mImgRequest(aImgRequest) {
 317     MOZ_ASSERT(!NS_IsMainThread(), "Create me off main thread only!");
 318     MOZ_ASSERT(aImgRequest);
 319   }
 320
 321   NS_IMETHOD Run() override {
 322     MOZ_ASSERT(NS_IsMainThread(), "I should be running on the main thread!");
 323     mImgRequest->ContinueEvict();
 324     return NS_OK;
 325   }
 326
 327  private:
 328   RefPtr<imgRequest> mImgRequest;
 329 };
 330
 331 // EvictFromCache() is written to allowed to get called from any thread
 332 void imgRequest::EvictFromCache() {
 333   /* The EvictFromCache() method here should only be called by this class. */
 334   LOG_SCOPE(gImgLog, "imgRequest::EvictFromCache");
 335
 336   if (NS_IsMainThread()) {
 337     ContinueEvict();
 338   } else {
 339     NS_DispatchToMainThread(new imgRequestMainThreadEvict(this));
 340   }
 341 }
 342
 343 // Helper-method used by EvictFromCache()
 344 void imgRequest::ContinueEvict() {
 345   MOZ_ASSERT(NS_IsMainThread());
 346
 347   RemoveFromCache();
 348 }
 349
 350 void imgRequest::StartDecoding() {
 351   MutexAutoLock lock(mMutex);
 352   mDecodeRequested = true;
 353 }
 354
 355 bool imgRequest::IsDecodeRequested() const {
 356   MutexAutoLock lock(mMutex);
 357   return mDecodeRequested;
 358 }
 359
 360 nsresult imgRequest::GetURI(nsIURI** aURI) {
 361   MOZ_ASSERT(aURI);
 362
 363   LOG_FUNC(gImgLog, "imgRequest::GetURI");
 364
 365   if (mURI) {
 366     *aURI = mURI;
 367     NS_ADDREF(*aURI);
 368     return NS_OK;
 369   }
 370
 371   return NS_ERROR_FAILURE;
 372 }
 373
 374 nsresult imgRequest::GetFinalURI(nsIURI** aURI) {
 375   MOZ_ASSERT(aURI);
 376
 377   LOG_FUNC(gImgLog, "imgRequest::GetFinalURI");
 378
 379   if (mFinalURI) {
 380     *aURI = mFinalURI;
 381     NS_ADDREF(*aURI);
 382     return NS_OK;
 383   }
 384
 385   return NS_ERROR_FAILURE;
 386 }
 387
 388 bool imgRequest::IsChrome() const { return mURI->SchemeIs("chrome"); }
 389
 390 bool imgRequest::IsData() const { return mURI->SchemeIs("data"); }
 391
 392 nsresult imgRequest::GetImageErrorCode() { return mImageErrorCode; }
 393
 394 void imgRequest::RemoveFromCache() {
 395   LOG_SCOPE(gImgLog, "imgRequest::RemoveFromCache");
 396
 397   bool isInCache = false;
 398
 399   {
 400     MutexAutoLock lock(mMutex);
 401     isInCache = mIsInCache;
 402   }
 403
 404   if (isInCache && mLoader) {
 405     // mCacheEntry is nulled out when we have no more observers.
 406     if (mCacheEntry) {
 407       mLoader->RemoveFromCache(mCacheEntry);
 408     } else {
 409       mLoader->RemoveFromCache(mCacheKey);
 410     }
 411   }
 412
 413   mCacheEntry = nullptr;
 414 }
 415
 416 bool imgRequest::HasConsumers() const {
 417   RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 418   return progressTracker && progressTracker->ObserverCount() > 0;
 419 }
 420
 421 already_AddRefed<image::Image> imgRequest::GetImage() const {
 422   MutexAutoLock lock(mMutex);
 423   RefPtr<image::Image> image = mImage;
 424   return image.forget();
 425 }
 426
 427 int32_t imgRequest::Priority() const {
 428   int32_t priority = nsISupportsPriority::PRIORITY_NORMAL;
 429   nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mRequest);
 430   if (p) {
 431     p->GetPriority(&priority);
 432   }
 433   return priority;
 434 }
 435
 436 void imgRequest::AdjustPriority(imgRequestProxy* proxy, int32_t delta) {
 437   // only the first proxy is allowed to modify the priority of this image load.
 438   //
 439   // XXX(darin): this is probably not the most optimal algorithm as we may want
 440   // to increase the priority of requests that have a lot of proxies.  the key
 441   // concern though is that image loads remain lower priority than other pieces
 442   // of content such as link clicks, CSS, and JS.
 443   //
 444   if (!mFirstProxy || proxy != mFirstProxy) {
 445     return;
 446   }
 447
 448   AdjustPriorityInternal(delta);
 449 }
 450
 451 void imgRequest::AdjustPriorityInternal(int32_t aDelta) {
 452   nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mChannel);
 453   if (p) {
 454     p->AdjustPriority(aDelta);
 455   }
 456 }
 457
 458 void imgRequest::BoostPriority(uint32_t aCategory) {
 459   if (!StaticPrefs::image_layout_network_priority()) {
 460     return;
 461   }
 462
 463   uint32_t newRequestedCategory =
 464       (mBoostCategoriesRequested & aCategory) ^ aCategory;
 465   if (!newRequestedCategory) {
 466     // priority boost for each category can only apply once.
 467     return;
 468   }
 469
 470   MOZ_LOG(gImgLog, LogLevel::Debug,
 471           ("[this=%p] imgRequest::BoostPriority for category %x", this,
 472            newRequestedCategory));
 473
 474   int32_t delta = 0;
 475
 476   if (newRequestedCategory & imgIRequest::CATEGORY_FRAME_INIT) {
 477     --delta;
 478   }
 479
 480   if (newRequestedCategory & imgIRequest::CATEGORY_FRAME_STYLE) {
 481     --delta;
 482   }
 483
 484   if (newRequestedCategory & imgIRequest::CATEGORY_SIZE_QUERY) {
 485     --delta;
 486   }
 487
 488   if (newRequestedCategory & imgIRequest::CATEGORY_DISPLAY) {
 489     delta += nsISupportsPriority::PRIORITY_HIGH;
 490   }
 491
 492   AdjustPriorityInternal(delta);
 493   mBoostCategoriesRequested |= newRequestedCategory;
 494 }
 495
 496 void imgRequest::SetIsInCache(bool aInCache) {
 497   LOG_FUNC_WITH_PARAM(gImgLog, "imgRequest::SetIsCacheable", "aInCache",
 498                       aInCache);
 499   MutexAutoLock lock(mMutex);
 500   mIsInCache = aInCache;
 501 }
 502
 503 void imgRequest::UpdateCacheEntrySize() {
 504   if (!mCacheEntry) {
 505     return;
 506   }
 507
 508   RefPtr<Image> image = GetImage();
 509   SizeOfState state(moz_malloc_size_of);
 510   size_t size = image->SizeOfSourceWithComputedFallback(state);
 511   mCacheEntry->SetDataSize(size);
 512 }
 513
 514 void imgRequest::SetCacheValidation(imgCacheEntry* aCacheEntry,
 515                                     nsIRequest* aRequest) {
 516   /* get the expires info */
 517   if (aCacheEntry) {
 518     // Expiration time defaults to 0. We set the expiration time on our
 519     // entry if it hasn't been set yet.
 520     if (aCacheEntry->GetExpiryTime() == 0) {
 521       uint32_t expiration = 0;
 522       nsCOMPtr<nsICacheInfoChannel> cacheChannel(do_QueryInterface(aRequest));
 523       if (cacheChannel) {
 524         /* get the expiration time from the caching channel's token */
 525         cacheChannel->GetCacheTokenExpirationTime(&expiration);
 526       }
 527       if (expiration == 0) {
 528         // If the channel doesn't support caching, then ensure this expires the
 529         // next time it is used.
 530         expiration = imgCacheEntry::SecondsFromPRTime(PR_Now()) - 1;
 531       }
 532       aCacheEntry->SetExpiryTime(expiration);
 533     }
 534
 535     // Determine whether the cache entry must be revalidated when we try to use
 536     // it. Currently, only HTTP specifies this information...
 537     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aRequest));
 538     if (httpChannel) {
 539       bool bMustRevalidate = false;
 540
 541       Unused << httpChannel->IsNoStoreResponse(&bMustRevalidate);
 542
 543       if (!bMustRevalidate) {
 544         Unused << httpChannel->IsNoCacheResponse(&bMustRevalidate);
 545       }
 546
 547       if (!bMustRevalidate) {
 548         nsAutoCString cacheHeader;
 549
 550         Unused << httpChannel->GetResponseHeader(
 551             NS_LITERAL_CSTRING("Cache-Control"), cacheHeader);
 552         if (PL_strcasestr(cacheHeader.get(), "must-revalidate")) {
 553           bMustRevalidate = true;
 554         }
 555       }
 556
 557       // Cache entries default to not needing to validate. We ensure that
 558       // multiple calls to this function don't override an earlier decision to
 559       // validate by making validation a one-way decision.
 560       if (bMustRevalidate) {
 561         aCacheEntry->SetMustValidate(bMustRevalidate);
 562       }
 563     }
 564   }
 565 }
 566
 567 namespace {
 568
 569 already_AddRefed<nsIApplicationCache> GetApplicationCache(
 570     nsIRequest* aRequest) {
 571   nsresult rv;
 572
 573   nsCOMPtr<nsIApplicationCacheChannel> appCacheChan =
 574       do_QueryInterface(aRequest);
 575   if (!appCacheChan) {
 576     return nullptr;
 577   }
 578
 579   bool fromAppCache;
 580   rv = appCacheChan->GetLoadedFromApplicationCache(&fromAppCache);
 581   NS_ENSURE_SUCCESS(rv, nullptr);
 582
 583   if (!fromAppCache) {
 584     return nullptr;
 585   }
 586
 587   nsCOMPtr<nsIApplicationCache> appCache;
 588   rv = appCacheChan->GetApplicationCache(getter_AddRefs(appCache));
 589   NS_ENSURE_SUCCESS(rv, nullptr);
 590
 591   return appCache.forget();
 592 }
 593
 594 }  // namespace
 595
 596 bool imgRequest::CacheChanged(nsIRequest* aNewRequest) {
 597   nsCOMPtr<nsIApplicationCache> newAppCache = GetApplicationCache(aNewRequest);
 598
 599   // Application cache not involved at all or the same app cache involved
 600   // in both of the loads (original and new).
 601   if (newAppCache == mApplicationCache) {
 602     return false;
 603   }
 604
 605   // In a rare case it may happen that two objects still refer
 606   // the same application cache version.
 607   if (newAppCache && mApplicationCache) {
 608     nsresult rv;
 609
 610     nsAutoCString oldAppCacheClientId, newAppCacheClientId;
 611     rv = mApplicationCache->GetClientID(oldAppCacheClientId);
 612     NS_ENSURE_SUCCESS(rv, true);
 613     rv = newAppCache->GetClientID(newAppCacheClientId);
 614     NS_ENSURE_SUCCESS(rv, true);
 615
 616     if (oldAppCacheClientId == newAppCacheClientId) {
 617       return false;
 618     }
 619   }
 620
 621   // When we get here, app caches differ or app cache is involved
 622   // just in one of the loads what we also consider as a change
 623   // in a loading cache.
 624   return true;
 625 }
 626
 627 bool imgRequest::GetMultipart() const {
 628   MutexAutoLock lock(mMutex);
 629   return mIsMultiPartChannel;
 630 }
 631
 632 bool imgRequest::HadInsecureRedirect() const {
 633   MutexAutoLock lock(mMutex);
 634   return mHadInsecureRedirect;
 635 }
 636
 637 /** nsIRequestObserver methods **/
 638
 639 NS_IMETHODIMP
 640 imgRequest::OnStartRequest(nsIRequest* aRequest) {
 641   LOG_SCOPE(gImgLog, "imgRequest::OnStartRequest");
 642
 643   RefPtr<Image> image;
 644
 645   // Figure out if we're multipart.
 646   nsCOMPtr<nsIMultiPartChannel> multiPartChannel = do_QueryInterface(aRequest);
 647   MOZ_ASSERT(multiPartChannel || !mIsMultiPartChannel,
 648              "Stopped being multipart?");
 649   {
 650     MutexAutoLock lock(mMutex);
 651     mNewPartPending = true;
 652     image = mImage;
 653     mIsMultiPartChannel = bool(multiPartChannel);
 654   }
 655
 656   // If we're not multipart, we shouldn't have an image yet.
 657   if (image && !multiPartChannel) {
 658     MOZ_ASSERT_UNREACHABLE("Already have an image for a non-multipart request");
 659     Cancel(NS_IMAGELIB_ERROR_FAILURE);
 660     return NS_ERROR_FAILURE;
 661   }
 662
 663   /*
 664    * If mRequest is null here, then we need to set it so that we'll be able to
 665    * cancel it if our Cancel() method is called.  Note that this can only
 666    * happen for multipart channels.  We could simply not null out mRequest for
 667    * non-last parts, if GetIsLastPart() were reliable, but it's not.  See
 668    * https://bugzilla.mozilla.org/show_bug.cgi?id=339610
 669    */
 670   if (!mRequest) {
 671     MOZ_ASSERT(multiPartChannel, "Should have mRequest unless we're multipart");
 672     nsCOMPtr<nsIChannel> baseChannel;
 673     multiPartChannel->GetBaseChannel(getter_AddRefs(baseChannel));
 674     mRequest = baseChannel;
 675   }
 676
 677   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
 678   if (channel) {
 679     /* Get our principal */
 680     nsCOMPtr<nsIScriptSecurityManager> secMan =
 681         nsContentUtils::GetSecurityManager();
 682     if (secMan) {
 683       nsresult rv = secMan->GetChannelResultPrincipal(
 684           channel, getter_AddRefs(mPrincipal));
 685       if (NS_FAILED(rv)) {
 686         return rv;
 687       }
 688     }
 689   }
 690
 691   SetCacheValidation(mCacheEntry, aRequest);
 692
 693   mApplicationCache = GetApplicationCache(aRequest);
 694
 695   // Shouldn't we be dead already if this gets hit?
 696   // Probably multipart/x-mixed-replace...
 697   RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 698   if (progressTracker->ObserverCount() == 0) {
 699     this->Cancel(NS_IMAGELIB_ERROR_FAILURE);
 700   }
 701
 702   // Try to retarget OnDataAvailable to a decode thread. We must process data
 703   // URIs synchronously as per the spec however.
 704   if (!channel || IsData()) {
 705     return NS_OK;
 706   }
 707
 708   nsCOMPtr<nsIThreadRetargetableRequest> retargetable =
 709       do_QueryInterface(aRequest);
 710   if (retargetable) {
 711     nsAutoCString mimeType;
 712     nsresult rv = channel->GetContentType(mimeType);
 713     if (NS_SUCCEEDED(rv) && !mimeType.EqualsLiteral(IMAGE_SVG_XML)) {
 714       // Retarget OnDataAvailable to the DecodePool's IO thread.
 715       nsCOMPtr<nsIEventTarget> target =
 716           DecodePool::Singleton()->GetIOEventTarget();
 717       rv = retargetable->RetargetDeliveryTo(target);
 718     }
 719     MOZ_LOG(gImgLog, LogLevel::Warning,
 720             ("[this=%p] imgRequest::OnStartRequest -- "
 721              "RetargetDeliveryTo rv %" PRIu32 "=%s\n",
 722              this, static_cast<uint32_t>(rv),
 723              NS_SUCCEEDED(rv) ? "succeeded" : "failed"));
 724   }
 725
 726   return NS_OK;
 727 }
 728
 729 NS_IMETHODIMP
 730 imgRequest::OnStopRequest(nsIRequest* aRequest, nsresult status) {
 731   LOG_FUNC(gImgLog, "imgRequest::OnStopRequest");
 732   MOZ_ASSERT(NS_IsMainThread(), "Can't send notifications off-main-thread");
 733
 734   RefPtr<Image> image = GetImage();
 735
 736   RefPtr<imgRequest> strongThis = this;
 737
 738   if (mIsMultiPartChannel && mNewPartPending) {
 739     OnDataAvailable(aRequest, nullptr, 0, 0);
 740   }
 741
 742   // XXXldb What if this is a non-last part of a multipart request?
 743   // xxx before we release our reference to mRequest, lets
 744   // save the last status that we saw so that the
 745   // imgRequestProxy will have access to it.
 746   if (mRequest) {
 747     mRequest = nullptr;  // we no longer need the request
 748   }
 749
 750   // stop holding a ref to the channel, since we don't need it anymore
 751   if (mChannel) {
 752     mChannel->SetNotificationCallbacks(mPrevChannelSink);
 753     mPrevChannelSink = nullptr;
 754     mChannel = nullptr;
 755   }
 756
 757   bool lastPart = true;
 758   nsCOMPtr<nsIMultiPartChannel> mpchan(do_QueryInterface(aRequest));
 759   if (mpchan) {
 760     mpchan->GetIsLastPart(&lastPart);
 761   }
 762
 763   bool isPartial = false;
 764   if (image && (status == NS_ERROR_NET_PARTIAL_TRANSFER)) {
 765     isPartial = true;
 766     status = NS_OK;  // fake happy face
 767   }
 768
 769   // Tell the image that it has all of the source data. Note that this can
 770   // trigger a failure, since the image might be waiting for more non-optional
 771   // data and this is the point where we break the news that it's not coming.
 772   if (image) {
 773     nsresult rv =
 774         image->OnImageDataComplete(aRequest, nullptr, status, lastPart);
 775
 776     // If we got an error in the OnImageDataComplete() call, we don't want to
 777     // proceed as if nothing bad happened. However, we also want to give
 778     // precedence to failure status codes from necko, since presumably they're
 779     // more meaningful.
 780     if (NS_FAILED(rv) && NS_SUCCEEDED(status)) {
 781       status = rv;
 782     }
 783   }
 784
 785   // If the request went through, update the cache entry size. Otherwise,
 786   // cancel the request, which removes us from the cache.
 787   if (image && NS_SUCCEEDED(status) && !isPartial) {
 788     // We update the cache entry size here because this is where we finish
 789     // loading compressed source data, which is part of our size calculus.
 790     UpdateCacheEntrySize();
 791
 792   } else if (isPartial) {
 793     // Remove the partial image from the cache.
 794     this->EvictFromCache();
 795
 796   } else {
 797     mImageErrorCode = status;
 798
 799     // if the error isn't "just" a partial transfer
 800     // stops animations, removes from cache
 801     this->Cancel(status);
 802   }
 803
 804   if (!image) {
 805     // We have to fire the OnStopRequest notifications ourselves because there's
 806     // no image capable of doing so.
 807     Progress progress =
 808         LoadCompleteProgress(lastPart, /* aError = */ false, status);
 809
 810     RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 811     progressTracker->SyncNotifyProgress(progress);
 812   }
 813
 814   mTimedChannel = nullptr;
 815   return NS_OK;
 816 }
 817
 818 struct mimetype_closure {
 819   nsACString* newType;
 820 };
 821
 822 /* prototype for these defined below */
 823 static nsresult sniff_mimetype_callback(nsIInputStream* in, void* closure,
 824                                         const char* fromRawSegment,
 825                                         uint32_t toOffset, uint32_t count,
 826                                         uint32_t* writeCount);
 827
 828 /** nsThreadRetargetableStreamListener methods **/
 829 NS_IMETHODIMP
 830 imgRequest::CheckListenerChain() {
 831   // TODO Might need more checking here.
 832   NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!");
 833   return NS_OK;
 834 }
 835
 836 /** nsIStreamListener methods **/
 837
 838 struct NewPartResult final {
 839   explicit NewPartResult(image::Image* aExistingImage)
 840       : mImage(aExistingImage),
 841         mIsFirstPart(!aExistingImage),
 842         mSucceeded(false),
 843         mShouldResetCacheEntry(false) {}
 844
 845   nsAutoCString mContentType;
 846   nsAutoCString mContentDisposition;
 847   RefPtr<image::Image> mImage;
 848   const bool mIsFirstPart;
 849   bool mSucceeded;
 850   bool mShouldResetCacheEntry;
 851 };
 852
 853 static NewPartResult PrepareForNewPart(nsIRequest* aRequest,
 854                                        nsIInputStream* aInStr, uint32_t aCount,
 855                                        nsIURI* aURI, bool aIsMultipart,
 856                                        image::Image* aExistingImage,
 857                                        ProgressTracker* aProgressTracker,
 858                                        uint32_t aInnerWindowId) {
 859   NewPartResult result(aExistingImage);
 860
 861   if (aInStr) {
 862     mimetype_closure closure;
 863     closure.newType = &result.mContentType;
 864
 865     // Look at the first few bytes and see if we can tell what the data is from
 866     // that since servers tend to lie. :(
 867     uint32_t out;
 868     aInStr->ReadSegments(sniff_mimetype_callback, &closure, aCount, &out);
 869   }
 870
 871   nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest));
 872   if (result.mContentType.IsEmpty()) {
 873     nsresult rv =
 874         chan ? chan->GetContentType(result.mContentType) : NS_ERROR_FAILURE;
 875     if (NS_FAILED(rv)) {
 876       MOZ_LOG(gImgLog, LogLevel::Error,
 877               ("imgRequest::PrepareForNewPart -- "
 878                "Content type unavailable from the channel\n"));
 879       if (!aIsMultipart) {
 880         return result;
 881       }
 882     }
 883   }
 884
 885   if (chan) {
 886     chan->GetContentDispositionHeader(result.mContentDisposition);
 887   }
 888
 889   MOZ_LOG(gImgLog, LogLevel::Debug,
 890           ("imgRequest::PrepareForNewPart -- Got content type %s\n",
 891            result.mContentType.get()));
 892
 893   // XXX If server lied about mimetype and it's SVG, we may need to copy
 894   // the data and dispatch back to the main thread, AND tell the channel to
 895   // dispatch there in the future.
 896
 897   // Create the new image and give it ownership of our ProgressTracker.
 898   if (aIsMultipart) {
 899     // Create the ProgressTracker and image for this part.
 900     RefPtr<ProgressTracker> progressTracker = new ProgressTracker();
 901     RefPtr<image::Image> partImage = image::ImageFactory::CreateImage(
 902         aRequest, progressTracker, result.mContentType, aURI,
 903         /* aIsMultipart = */ true, aInnerWindowId);
 904
 905     if (result.mIsFirstPart) {
 906       // First part for a multipart channel. Create the MultipartImage wrapper.
 907       MOZ_ASSERT(aProgressTracker, "Shouldn't have given away tracker yet");
 908       aProgressTracker->SetIsMultipart();
 909       result.mImage = image::ImageFactory::CreateMultipartImage(
 910           partImage, aProgressTracker);
 911     } else {
 912       // Transition to the new part.
 913       auto multipartImage = static_cast<MultipartImage*>(aExistingImage);
 914       multipartImage->BeginTransitionToPart(partImage);
 915
 916       // Reset our cache entry size so it doesn't keep growing without bound.
 917       result.mShouldResetCacheEntry = true;
 918     }
 919   } else {
 920     MOZ_ASSERT(!aExistingImage, "New part for non-multipart channel?");
 921     MOZ_ASSERT(aProgressTracker, "Shouldn't have given away tracker yet");
 922
 923     // Create an image using our progress tracker.
 924     result.mImage = image::ImageFactory::CreateImage(
 925         aRequest, aProgressTracker, result.mContentType, aURI,
 926         /* aIsMultipart = */ false, aInnerWindowId);
 927   }
 928
 929   MOZ_ASSERT(result.mImage);
 930   if (!result.mImage->HasError() || aIsMultipart) {
 931     // We allow multipart images to fail to initialize (which generally
 932     // indicates a bad content type) without cancelling the load, because
 933     // subsequent parts might be fine.
 934     result.mSucceeded = true;
 935   }
 936
 937   return result;
 938 }
 939
 940 class FinishPreparingForNewPartRunnable final : public Runnable {
 941  public:
 942   FinishPreparingForNewPartRunnable(imgRequest* aImgRequest,
 943                                     NewPartResult&& aResult)
 944       : Runnable("FinishPreparingForNewPartRunnable"),
 945         mImgRequest(aImgRequest),
 946         mResult(aResult) {
 947     MOZ_ASSERT(aImgRequest);
 948   }
 949
 950   NS_IMETHOD Run() override {
 951     mImgRequest->FinishPreparingForNewPart(mResult);
 952     return NS_OK;
 953   }
 954
 955  private:
 956   RefPtr<imgRequest> mImgRequest;
 957   NewPartResult mResult;
 958 };
 959
 960 void imgRequest::FinishPreparingForNewPart(const NewPartResult& aResult) {
 961   MOZ_ASSERT(NS_IsMainThread());
 962
 963   mContentType = aResult.mContentType;
 964
 965   SetProperties(aResult.mContentType, aResult.mContentDisposition);
 966
 967   if (aResult.mIsFirstPart) {
 968     // Notify listeners that we have an image.
 969     mImageAvailable = true;
 970     RefPtr<ProgressTracker> progressTracker = GetProgressTracker();
 971     progressTracker->OnImageAvailable();
 972     MOZ_ASSERT(progressTracker->HasImage());
 973   }
 974
 975   if (aResult.mShouldResetCacheEntry) {
 976     ResetCacheEntry();
 977   }
 978
 979   if (IsDecodeRequested()) {
 980     aResult.mImage->StartDecoding(imgIContainer::FLAG_NONE);
 981   }
 982 }
 983
 984 bool imgRequest::ImageAvailable() const { return mImageAvailable; }
 985
 986 NS_IMETHODIMP
 987 imgRequest::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr,
 988                             uint64_t aOffset, uint32_t aCount) {
 989   LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequest::OnDataAvailable", "count", aCount);
 990
 991   NS_ASSERTION(aRequest, "imgRequest::OnDataAvailable -- no request!");
 992
 993   RefPtr<Image> image;
 994   RefPtr<ProgressTracker> progressTracker;
 995   bool isMultipart = false;
 996   bool newPartPending = false;
 997
 998   // Retrieve and update our state.
 999   {
1000     MutexAutoLock lock(mMutex);
1001     image = mImage;
1002     progressTracker = mProgressTracker;
1003     isMultipart = mIsMultiPartChannel;
1004     newPartPending = mNewPartPending;
1005     mNewPartPending = false;
1006   }
1007
1008   // If this is a new part, we need to sniff its content type and create an
1009   // appropriate image.
1010   if (newPartPending) {
1011     NewPartResult result =
1012         PrepareForNewPart(aRequest, aInStr, aCount, mURI, isMultipart, image,
1013                           progressTracker, mInnerWindowId);
1014     bool succeeded = result.mSucceeded;
1015
1016     if (result.mImage) {
1017       image = result.mImage;
1018       nsCOMPtr<nsIEventTarget> eventTarget;
1019
1020       // Update our state to reflect this new part.
1021       {
1022         MutexAutoLock lock(mMutex);
1023         mImage = image;
1024
1025         // We only get an event target if we are not on the main thread, because
1026         // we have to dispatch in that case. If we are on the main thread, but
1027         // on a different scheduler group than ProgressTracker would give us,
1028         // that is okay because nothing in imagelib requires that, just our
1029         // listeners (which have their own checks).
1030         if (!NS_IsMainThread()) {
1031           eventTarget = mProgressTracker->GetEventTarget();
1032           MOZ_ASSERT(eventTarget);
1033         }
1034
1035         mProgressTracker = nullptr;
1036       }
1037
1038       // Some property objects are not threadsafe, and we need to send
1039       // OnImageAvailable on the main thread, so finish on the main thread.
1040       if (!eventTarget) {
1041         MOZ_ASSERT(NS_IsMainThread());
1042         FinishPreparingForNewPart(result);
1043       } else {
1044         nsCOMPtr<nsIRunnable> runnable =
1045             new FinishPreparingForNewPartRunnable(this, std::move(result));
1046         eventTarget->Dispatch(CreateMediumHighRunnable(runnable.forget()),
1047                               NS_DISPATCH_NORMAL);
1048       }
1049     }
1050
1051     if (!succeeded) {
1052       // Something went wrong; probably a content type issue.
1053       Cancel(NS_IMAGELIB_ERROR_FAILURE);
1054       return NS_BINDING_ABORTED;
1055     }
1056   }
1057
1058   // Notify the image that it has new data.
1059   if (aInStr) {
1060     nsresult rv =
1061         image->OnImageDataAvailable(aRequest, nullptr, aInStr, aOffset, aCount);
1062
1063     if (NS_FAILED(rv)) {
1064       MOZ_LOG(gImgLog, LogLevel::Warning,
1065               ("[this=%p] imgRequest::OnDataAvailable -- "
1066                "copy to RasterImage failed\n",
1067                this));
1068       Cancel(NS_IMAGELIB_ERROR_FAILURE);
1069       return NS_BINDING_ABORTED;
1070     }
1071   }
1072
1073   return NS_OK;
1074 }
1075
1076 void imgRequest::SetProperties(const nsACString& aContentType,
1077                                const nsACString& aContentDisposition) {
1078   /* set our mimetype as a property */
1079   nsCOMPtr<nsISupportsCString> contentType =
1080       do_CreateInstance("@mozilla.org/supports-cstring;1");
1081   if (contentType) {
1082     contentType->SetData(aContentType);
1083     mProperties->Set("type", contentType);
1084   }
1085
1086   /* set our content disposition as a property */
1087   if (!aContentDisposition.IsEmpty()) {
1088     nsCOMPtr<nsISupportsCString> contentDisposition =
1089         do_CreateInstance("@mozilla.org/supports-cstring;1");
1090     if (contentDisposition) {
1091       contentDisposition->SetData(aContentDisposition);
1092       mProperties->Set("content-disposition", contentDisposition);
1093     }
1094   }
1095 }
1096
1097 static nsresult sniff_mimetype_callback(nsIInputStream* in, void* data,
1098                                         const char* fromRawSegment,
1099                                         uint32_t toOffset, uint32_t count,
1100                                         uint32_t* writeCount) {
1101   mimetype_closure* closure = static_cast<mimetype_closure*>(data);
1102
1103   NS_ASSERTION(closure, "closure is null!");
1104
1105   if (count > 0) {
1106     imgLoader::GetMimeTypeFromContent(fromRawSegment, count, *closure->newType);
1107   }
1108
1109   *writeCount = 0;
1110   return NS_ERROR_FAILURE;
1111 }
1112
1113 /** nsIInterfaceRequestor methods **/
1114
1115 NS_IMETHODIMP
1116 imgRequest::GetInterface(const nsIID& aIID, void** aResult) {
1117   if (!mPrevChannelSink || aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
1118     return QueryInterface(aIID, aResult);
1119   }
1120
1121   NS_ASSERTION(
1122       mPrevChannelSink != this,
1123       "Infinite recursion - don't keep track of channel sinks that are us!");
1124   return mPrevChannelSink->GetInterface(aIID, aResult);
1125 }
1126
1127 /** nsIChannelEventSink methods **/
1128 NS_IMETHODIMP
1129 imgRequest::AsyncOnChannelRedirect(nsIChannel* oldChannel,
1130                                    nsIChannel* newChannel, uint32_t flags,
1131                                    nsIAsyncVerifyRedirectCallback* callback) {
1132   NS_ASSERTION(mRequest && mChannel,
1133                "Got a channel redirect after we nulled out mRequest!");
1134   NS_ASSERTION(mChannel == oldChannel,
1135                "Got a channel redirect for an unknown channel!");
1136   NS_ASSERTION(newChannel, "Got a redirect to a NULL channel!");
1137
1138   SetCacheValidation(mCacheEntry, oldChannel);
1139
1140   // Prepare for callback
1141   mRedirectCallback = callback;
1142   mNewRedirectChannel = newChannel;
1143
1144   nsCOMPtr<nsIChannelEventSink> sink(do_GetInterface(mPrevChannelSink));
1145   if (sink) {
1146     nsresult rv =
1147         sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this);
1148     if (NS_FAILED(rv)) {
1149       mRedirectCallback = nullptr;
1150       mNewRedirectChannel = nullptr;
1151     }
1152     return rv;
1153   }
1154
1155   (void)OnRedirectVerifyCallback(NS_OK);
1156   return NS_OK;
1157 }
1158
1159 NS_IMETHODIMP
1160 imgRequest::OnRedirectVerifyCallback(nsresult result) {
1161   NS_ASSERTION(mRedirectCallback, "mRedirectCallback not set in callback");
1162   NS_ASSERTION(mNewRedirectChannel, "mNewRedirectChannel not set in callback");
1163
1164   if (NS_FAILED(result)) {
1165     mRedirectCallback->OnRedirectVerifyCallback(result);
1166     mRedirectCallback = nullptr;
1167     mNewRedirectChannel = nullptr;
1168     return NS_OK;
1169   }
1170
1171   mChannel = mNewRedirectChannel;
1172   mTimedChannel = do_QueryInterface(mChannel);
1173   mNewRedirectChannel = nullptr;
1174
1175   if (LOG_TEST(LogLevel::Debug)) {
1176     LOG_MSG_WITH_PARAM(gImgLog, "imgRequest::OnChannelRedirect", "old",
1177                        mFinalURI ? mFinalURI->GetSpecOrDefault().get() : "");
1178   }
1179
1180   // If the previous URI is a non-HTTPS URI, record that fact for later use by
1181   // security code, which needs to know whether there is an insecure load at any
1182   // point in the redirect chain.
1183   bool schemeLocal = false;
1184   if (NS_FAILED(NS_URIChainHasFlags(mFinalURI,
1185                                     nsIProtocolHandler::URI_IS_LOCAL_RESOURCE,
1186                                     &schemeLocal)) ||
1187       (!mFinalURI->SchemeIs("https") && !mFinalURI->SchemeIs("chrome") &&
1188        !schemeLocal)) {
1189     MutexAutoLock lock(mMutex);
1190
1191     // The csp directive upgrade-insecure-requests performs an internal redirect
1192     // to upgrade all requests from http to https before any data is fetched
1193     // from the network. Do not pollute mHadInsecureRedirect in case of such an
1194     // internal redirect.
1195     nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
1196     bool upgradeInsecureRequests =
1197         loadInfo ? loadInfo->GetUpgradeInsecureRequests() ||
1198                        loadInfo->GetBrowserUpgradeInsecureRequests()
1199                  : false;
1200     if (!upgradeInsecureRequests) {
1201       mHadInsecureRedirect = true;
1202     }
1203   }
1204
1205   // Update the final URI.
1206   mChannel->GetURI(getter_AddRefs(mFinalURI));
1207
1208   if (LOG_TEST(LogLevel::Debug)) {
1209     LOG_MSG_WITH_PARAM(gImgLog, "imgRequest::OnChannelRedirect", "new",
1210                        mFinalURI ? mFinalURI->GetSpecOrDefault().get() : "");
1211   }
1212
1213   // Make sure we have a protocol that returns data rather than opens an
1214   // external application, e.g. 'mailto:'.
1215   bool doesNotReturnData = false;
1216   nsresult rv = NS_URIChainHasFlags(
1217       mFinalURI, nsIProtocolHandler::URI_DOES_NOT_RETURN_DATA,
1218       &doesNotReturnData);
1219
1220   if (NS_SUCCEEDED(rv) && doesNotReturnData) {
1221     rv = NS_ERROR_ABORT;
1222   }
1223
1224   if (NS_FAILED(rv)) {
1225     mRedirectCallback->OnRedirectVerifyCallback(rv);
1226     mRedirectCallback = nullptr;
1227     return NS_OK;
1228   }
1229
1230   mRedirectCallback->OnRedirectVerifyCallback(NS_OK);
1231   mRedirectCallback = nullptr;
1232   return NS_OK;
1233 }