The Tor Browser: image/src/imgLoader.cpp@ac0c01689b40 (annotated)

image/src/imgLoader.cpp@ac0c01689b40 (annotated)

image/src/imgLoader.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "mozilla/Attributes.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "ImageLogging.h"
 #include "nsPrintfCString.h"
 #include "imgLoader.h"
 #include "imgRequestProxy.h"
 #include "nsCOMPtr.h"
 #include "nsContentUtils.h"
 #include "nsCrossSiteListenerProxy.h"
 #include "nsNetUtil.h"
 #include "nsMimeTypes.h"
 #include "nsStreamUtils.h"
 #include "nsIHttpChannel.h"
 #include "nsICachingChannel.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIProgressEventSink.h"
 #include "nsIChannelEventSink.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 #include "nsIFileURL.h"
 #include "nsCRT.h"
 #include "nsIDocument.h"
 #include "nsINetworkSeer.h"
 #include "nsIConsoleService.h"
 #include "nsIApplicationCache.h"
 #include "nsIApplicationCacheContainer.h"
 #include "nsIMemoryReporter.h"
 #include "Image.h"
 #include "DiscardTracker.h"
 // we want to explore making the document own the load group
 // so we can associate the document URI with the load group.
 // until this point, we have an evil hack:
 #include "nsIHttpChannelInternal.h"
 #include "nsILoadContext.h"
 #include "nsILoadGroupChild.h"
 using namespace mozilla;
 using namespace mozilla::image;
 MOZ_DEFINE_MALLOC_SIZE_OF(ImagesMallocSizeOf)
 class imgMemoryReporter MOZ_FINAL : public nsIMemoryReporter
 {
 public:
   NS_DECL_ISUPPORTS
   NS_IMETHOD CollectReports(nsIMemoryReporterCallback *callback,
                             nsISupports *closure)
   {
     AllSizes chrome;
     AllSizes content;
     for (uint32_t i = 0; i < mKnownLoaders.Length(); i++) {
       mKnownLoaders[i]->mChromeCache.EnumerateRead(EntryAllSizes, &chrome);
       mKnownLoaders[i]->mCache.EnumerateRead(EntryAllSizes, &content);
     }
 #define REPORT(_path, _kind, _amount, _desc)                                  \
     do {                                                                      \
       nsresult rv;                                                            \
       rv = callback->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path),      \
                               _kind, UNITS_BYTES, _amount,                    \
                               NS_LITERAL_CSTRING(_desc), closure);            \
       NS_ENSURE_SUCCESS(rv, rv);                                              \
     } while (0)
     REPORT("explicit/images/chrome/used/raw",
            KIND_HEAP, chrome.mUsedRaw,
            "Memory used by in-use chrome images (compressed data).");
     REPORT("explicit/images/chrome/used/uncompressed-heap",
            KIND_HEAP, chrome.mUsedUncompressedHeap,
            "Memory used by in-use chrome images (uncompressed data).");
     REPORT("explicit/images/chrome/used/uncompressed-nonheap",
            KIND_NONHEAP, chrome.mUsedUncompressedNonheap,
            "Memory used by in-use chrome images (uncompressed data).");
     REPORT("explicit/images/chrome/unused/raw",
            KIND_HEAP, chrome.mUnusedRaw,
            "Memory used by not in-use chrome images (compressed data).");
     REPORT("explicit/images/chrome/unused/uncompressed-heap",
            KIND_HEAP, chrome.mUnusedUncompressedHeap,
            "Memory used by not in-use chrome images (uncompressed data).");
     REPORT("explicit/images/chrome/unused/uncompressed-nonheap",
            KIND_NONHEAP, chrome.mUnusedUncompressedNonheap,
            "Memory used by not in-use chrome images (uncompressed data).");
     REPORT("explicit/images/content/used/raw",
            KIND_HEAP, content.mUsedRaw,
            "Memory used by in-use content images (compressed data).");
     REPORT("explicit/images/content/used/uncompressed-heap",
            KIND_HEAP, content.mUsedUncompressedHeap,
            "Memory used by in-use content images (uncompressed data).");
     REPORT("explicit/images/content/used/uncompressed-nonheap",
            KIND_NONHEAP, content.mUsedUncompressedNonheap,
            "Memory used by in-use content images (uncompressed data).");
     REPORT("explicit/images/content/unused/raw",
            KIND_HEAP, content.mUnusedRaw,
            "Memory used by not in-use content images (compressed data).");
     REPORT("explicit/images/content/unused/uncompressed-heap",
            KIND_HEAP, content.mUnusedUncompressedHeap,
            "Memory used by not in-use content images (uncompressed data).");
     REPORT("explicit/images/content/unused/uncompressed-nonheap",
            KIND_NONHEAP, content.mUnusedUncompressedNonheap,
            "Memory used by not in-use content images (uncompressed data).");
 #undef REPORT
     return NS_OK;
   }
   static int64_t ImagesContentUsedUncompressedDistinguishedAmount()
   {
     size_t n = 0;
     for (uint32_t i = 0; i < imgLoader::sMemReporter->mKnownLoaders.Length(); i++) {
       imgLoader::sMemReporter->mKnownLoaders[i]->mCache.EnumerateRead(EntryUsedUncompressedSize, &n);
     }
     return n;
   }
   void RegisterLoader(imgLoader* aLoader)
   {
     mKnownLoaders.AppendElement(aLoader);
   }
   void UnregisterLoader(imgLoader* aLoader)
   {
     mKnownLoaders.RemoveElement(aLoader);
   }
 private:
   nsTArray<imgLoader*> mKnownLoaders;
   struct AllSizes {
     size_t mUsedRaw;
     size_t mUsedUncompressedHeap;
     size_t mUsedUncompressedNonheap;
     size_t mUnusedRaw;
     size_t mUnusedUncompressedHeap;
     size_t mUnusedUncompressedNonheap;
     AllSizes() {
       memset(this, 0, sizeof(*this));
     }
   };
   static PLDHashOperator EntryAllSizes(const nsACString&,
                                        imgCacheEntry *entry,
                                        void *userArg)
   {
     nsRefPtr<imgRequest> req = entry->GetRequest();
     Image *image = static_cast<Image*>(req->mImage.get());
     if (image) {
       AllSizes *sizes = static_cast<AllSizes*>(userArg);
       if (entry->HasNoProxies()) {
         sizes->mUnusedRaw +=
           image->HeapSizeOfSourceWithComputedFallback(ImagesMallocSizeOf);
         sizes->mUnusedUncompressedHeap +=
           image->HeapSizeOfDecodedWithComputedFallback(ImagesMallocSizeOf);
         sizes->mUnusedUncompressedNonheap += image->NonHeapSizeOfDecoded();
       } else {
         sizes->mUsedRaw +=
           image->HeapSizeOfSourceWithComputedFallback(ImagesMallocSizeOf);
         sizes->mUsedUncompressedHeap +=
           image->HeapSizeOfDecodedWithComputedFallback(ImagesMallocSizeOf);
         sizes->mUsedUncompressedNonheap += image->NonHeapSizeOfDecoded();
       }
     }
     return PL_DHASH_NEXT;
   }
   static PLDHashOperator EntryUsedUncompressedSize(const nsACString&,
                                                    imgCacheEntry *entry,
                                                    void *userArg)
   {
     if (!entry->HasNoProxies()) {
       size_t *n = static_cast<size_t*>(userArg);
       nsRefPtr<imgRequest> req = entry->GetRequest();
       Image *image = static_cast<Image*>(req->mImage.get());
       if (image) {
         // Both this and EntryAllSizes measure images-content-used-uncompressed
         // memory.  This function's measurement is secondary -- the result
         // doesn't go in the "explicit" tree -- so we use moz_malloc_size_of
         // instead of ImagesMallocSizeOf to prevent DMD from seeing it reported
         // twice.
         *n += image->HeapSizeOfDecodedWithComputedFallback(moz_malloc_size_of);
         *n += image->NonHeapSizeOfDecoded();
       }
     }
     return PL_DHASH_NEXT;
   }
 };
 NS_IMPL_ISUPPORTS(imgMemoryReporter, nsIMemoryReporter)
 NS_IMPL_ISUPPORTS(nsProgressNotificationProxy,
                   nsIProgressEventSink,
                   nsIChannelEventSink,
                   nsIInterfaceRequestor)
 NS_IMETHODIMP
 nsProgressNotificationProxy::OnProgress(nsIRequest* request,
                                         nsISupports* ctxt,
                                         uint64_t progress,
                                         uint64_t progressMax)
 {
   nsCOMPtr<nsILoadGroup> loadGroup;
   request->GetLoadGroup(getter_AddRefs(loadGroup));
   nsCOMPtr<nsIProgressEventSink> target;
   NS_QueryNotificationCallbacks(mOriginalCallbacks,
                                 loadGroup,
                                 NS_GET_IID(nsIProgressEventSink),
                                 getter_AddRefs(target));
   if (!target)
     return NS_OK;
   return target->OnProgress(mImageRequest, ctxt, progress, progressMax);
 }
 NS_IMETHODIMP
 nsProgressNotificationProxy::OnStatus(nsIRequest* request,
                                       nsISupports* ctxt,
                                       nsresult status,
                                       const char16_t* statusArg)
 {
   nsCOMPtr<nsILoadGroup> loadGroup;
   request->GetLoadGroup(getter_AddRefs(loadGroup));
   nsCOMPtr<nsIProgressEventSink> target;
   NS_QueryNotificationCallbacks(mOriginalCallbacks,
                                 loadGroup,
                                 NS_GET_IID(nsIProgressEventSink),
                                 getter_AddRefs(target));
   if (!target)
     return NS_OK;
   return target->OnStatus(mImageRequest, ctxt, status, statusArg);
 }
 NS_IMETHODIMP
 nsProgressNotificationProxy::AsyncOnChannelRedirect(nsIChannel *oldChannel,
                                                     nsIChannel *newChannel,
                                                     uint32_t flags,
                                                     nsIAsyncVerifyRedirectCallback *cb)
 {
   // Tell the original original callbacks about it too
   nsCOMPtr<nsILoadGroup> loadGroup;
   newChannel->GetLoadGroup(getter_AddRefs(loadGroup));
   nsCOMPtr<nsIChannelEventSink> target;
   NS_QueryNotificationCallbacks(mOriginalCallbacks,
                                 loadGroup,
                                 NS_GET_IID(nsIChannelEventSink),
                                 getter_AddRefs(target));
   if (!target) {
       cb->OnRedirectVerifyCallback(NS_OK);
       return NS_OK;
   }
   // Delegate to |target| if set, reusing |cb|
   return target->AsyncOnChannelRedirect(oldChannel, newChannel, flags, cb);
 }
 NS_IMETHODIMP
 nsProgressNotificationProxy::GetInterface(const nsIID& iid,
                                           void** result)
 {
   if (iid.Equals(NS_GET_IID(nsIProgressEventSink))) {
     *result = static_cast<nsIProgressEventSink*>(this);
     NS_ADDREF_THIS();
     return NS_OK;
   }
   if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) {
     *result = static_cast<nsIChannelEventSink*>(this);
     NS_ADDREF_THIS();
     return NS_OK;
   }
   if (mOriginalCallbacks)
     return mOriginalCallbacks->GetInterface(iid, result);
   return NS_NOINTERFACE;
 }
 static void NewRequestAndEntry(bool aForcePrincipalCheckForCacheEntry, imgLoader* aLoader,
                                imgRequest **aRequest, imgCacheEntry **aEntry)
 {
   nsRefPtr<imgRequest> request = new imgRequest(aLoader);
   nsRefPtr<imgCacheEntry> entry = new imgCacheEntry(aLoader, request, aForcePrincipalCheckForCacheEntry);
   request.forget(aRequest);
   entry.forget(aEntry);
 }
 static bool ShouldRevalidateEntry(imgCacheEntry *aEntry,
                               nsLoadFlags aFlags,
                               bool aHasExpired)
 {
   bool bValidateEntry = false;
   if (aFlags & nsIRequest::LOAD_BYPASS_CACHE)
     return false;
   if (aFlags & nsIRequest::VALIDATE_ALWAYS) {
     bValidateEntry = true;
   }
   else if (aEntry->GetMustValidate()) {
     bValidateEntry = true;
   }
   //
   // The cache entry has expired...  Determine whether the stale cache
   // entry can be used without validation...
   //
   else if (aHasExpired) {
     //
     // VALIDATE_NEVER and VALIDATE_ONCE_PER_SESSION allow stale cache
     // entries to be used unless they have been explicitly marked to
     // indicate that revalidation is necessary.
     //
     if (aFlags & (nsIRequest::VALIDATE_NEVER |
                   nsIRequest::VALIDATE_ONCE_PER_SESSION))
     {
       bValidateEntry = false;
     }
     //
     // LOAD_FROM_CACHE allows a stale cache entry to be used... Otherwise,
     // the entry must be revalidated.
     //
     else if (!(aFlags & nsIRequest::LOAD_FROM_CACHE)) {
       bValidateEntry = true;
     }
   }
   return bValidateEntry;
 }
 // Returns true if this request is compatible with the given CORS mode on the
 // given loading principal, and false if the request may not be reused due
 // to CORS.
 static bool
 ValidateCORSAndPrincipal(imgRequest* request, bool forcePrincipalCheck,
                          int32_t corsmode, nsIPrincipal* loadingPrincipal)
 {
   // If the entry's CORS mode doesn't match, or the CORS mode matches but the
   // document principal isn't the same, we can't use this request.
   if (request->GetCORSMode() != corsmode) {
     return false;
   } else if (request->GetCORSMode() != imgIRequest::CORS_NONE ||
              forcePrincipalCheck) {
     nsCOMPtr<nsIPrincipal> otherprincipal = request->GetLoadingPrincipal();
     // If we previously had a principal, but we don't now, we can't use this
     // request.
     if (otherprincipal && !loadingPrincipal) {
       return false;
     }
     if (otherprincipal && loadingPrincipal) {
       bool equals = false;
       otherprincipal->Equals(loadingPrincipal, &equals);
       return equals;
     }
   }
   return true;
 }
 static nsresult NewImageChannel(nsIChannel **aResult,
                                 // If aForcePrincipalCheckForCacheEntry is
                                 // true, then we will force a principal check
                                 // even when not using CORS before assuming we
                                 // have a cache hit on a cache entry that we
                                 // create for this channel.  This is an out
                                 // param that should be set to true if this
                                 // channel ends up depending on
                                 // aLoadingPrincipal and false otherwise.
                                 bool *aForcePrincipalCheckForCacheEntry,
                                 nsIURI *aURI,
                                 nsIURI *aFirstPartyIsolationURI,
                                 nsIURI *aReferringURI,
                                 nsILoadGroup *aLoadGroup,
                                 const nsCString& aAcceptHeader,
                                 nsLoadFlags aLoadFlags,
                                 nsIChannelPolicy *aPolicy,
                                 nsIPrincipal *aLoadingPrincipal)
 {
   nsresult rv;
   nsCOMPtr<nsIHttpChannel> newHttpChannel;
   nsCOMPtr<nsIInterfaceRequestor> callbacks;
   if (aLoadGroup) {
     // Get the notification callbacks from the load group for the new channel.
     //
     // XXX: This is not exactly correct, because the network request could be
     //      referenced by multiple windows...  However, the new channel needs
     //      something.  So, using the 'first' notification callbacks is better
     //      than nothing...
     //
     aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
   }
   // Pass in a nullptr loadgroup because this is the underlying network
   // request. This request may be referenced by several proxy image requests
   // (possibly in different documents).
   // If all of the proxy requests are canceled then this request should be
   // canceled too.
   //
   rv = NS_NewChannel(aResult,
                      aURI,        // URI
                      nullptr,      // Cached IOService
                      nullptr,      // LoadGroup
                      callbacks,   // Notification Callbacks
                      aLoadFlags,
                      aPolicy);
   if (NS_FAILED(rv))
     return rv;
   *aForcePrincipalCheckForCacheEntry = false;
   // Initialize HTTP-specific attributes
   newHttpChannel = do_QueryInterface(*aResult);
   if (newHttpChannel) {
     newHttpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"),
                                      aAcceptHeader,
                                      false);
     nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal = do_QueryInterface(newHttpChannel);
     NS_ENSURE_TRUE(httpChannelInternal, NS_ERROR_UNEXPECTED);
     httpChannelInternal->SetDocumentURI(aFirstPartyIsolationURI);
     newHttpChannel->SetReferrer(aReferringURI);
   }
   // Image channels are loaded by default with reduced priority.
   nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(*aResult);
   if (p) {
     uint32_t priority = nsISupportsPriority::PRIORITY_LOW;
     if (aLoadFlags & nsIRequest::LOAD_BACKGROUND)
       ++priority; // further reduce priority for background loads
     p->AdjustPriority(priority);
   }
   bool setOwner = nsContentUtils::SetUpChannelOwner(aLoadingPrincipal,
                                                       *aResult, aURI, false);
   *aForcePrincipalCheckForCacheEntry = setOwner;
   // Create a new loadgroup for this new channel, using the old group as
   // the parent. The indirection keeps the channel insulated from cancels,
   // but does allow a way for this revalidation to be associated with at
   // least one base load group for scheduling/caching purposes.
   nsCOMPtr<nsILoadGroup> loadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID);
   nsCOMPtr<nsILoadGroupChild> childLoadGroup = do_QueryInterface(loadGroup);
   if (childLoadGroup) {
     childLoadGroup->SetParentLoadGroup(aLoadGroup);
   }
   (*aResult)->SetLoadGroup(loadGroup);
   return NS_OK;
 }
 static uint32_t SecondsFromPRTime(PRTime prTime)
 {
   return uint32_t(int64_t(prTime) / int64_t(PR_USEC_PER_SEC));
 }
 imgCacheEntry::imgCacheEntry(imgLoader* loader, imgRequest *request, bool forcePrincipalCheck)
  : mLoader(loader),
    mRequest(request),
    mDataSize(0),
    mTouchedTime(SecondsFromPRTime(PR_Now())),
    mExpiryTime(0),
    mMustValidate(false),
    // We start off as evicted so we don't try to update the cache. PutIntoCache
    // will set this to false.
    mEvicted(true),
    mHasNoProxies(true),
    mForcePrincipalCheck(forcePrincipalCheck)
 {}
 imgCacheEntry::~imgCacheEntry()
 {
   LOG_FUNC(GetImgLog(), "imgCacheEntry::~imgCacheEntry()");
 }
 void imgCacheEntry::Touch(bool updateTime /* = true */)
 {
   LOG_SCOPE(GetImgLog(), "imgCacheEntry::Touch");
   if (updateTime)
     mTouchedTime = SecondsFromPRTime(PR_Now());
   UpdateCache();
 }
 void imgCacheEntry::UpdateCache(int32_t diff /* = 0 */)
 {
   // Don't update the cache if we've been removed from it or it doesn't care
   // about our size or usage.
   if (!Evicted() && HasNoProxies()) {
     nsRefPtr<ImageURL> uri;
     mRequest->GetURI(getter_AddRefs(uri));
     mLoader->CacheEntriesChanged(uri, diff);
   }
 }
 void imgCacheEntry::SetHasNoProxies(bool hasNoProxies)
 {
 #if defined(PR_LOGGING)
   nsRefPtr<ImageURL> uri;
   mRequest->GetURI(getter_AddRefs(uri));
   nsAutoCString spec;
   if (uri)
     uri->GetSpec(spec);
   if (hasNoProxies)
     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgCacheEntry::SetHasNoProxies true", "uri", spec.get());
   else
     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgCacheEntry::SetHasNoProxies false", "uri", spec.get());
 #endif
   mHasNoProxies = hasNoProxies;
 }
 imgCacheQueue::imgCacheQueue()
  : mDirty(false),
    mSize(0)
 {}
 void imgCacheQueue::UpdateSize(int32_t diff)
 {
   mSize += diff;
 }
 uint32_t imgCacheQueue::GetSize() const
 {
   return mSize;
 }
 #include <algorithm>
 using namespace std;
 void imgCacheQueue::Remove(imgCacheEntry *entry)
 {
   queueContainer::iterator it = find(mQueue.begin(), mQueue.end(), entry);
   if (it != mQueue.end()) {
     mSize -= (*it)->GetDataSize();
     mQueue.erase(it);
     MarkDirty();
   }
 }
 void imgCacheQueue::Push(imgCacheEntry *entry)
 {
   mSize += entry->GetDataSize();
   nsRefPtr<imgCacheEntry> refptr(entry);
   mQueue.push_back(refptr);
   MarkDirty();
 }
 already_AddRefed<imgCacheEntry> imgCacheQueue::Pop()
 {
   if (mQueue.empty())
     return nullptr;
   if (IsDirty())
     Refresh();
   nsRefPtr<imgCacheEntry> entry = mQueue[0];
   std::pop_heap(mQueue.begin(), mQueue.end(), imgLoader::CompareCacheEntries);
   mQueue.pop_back();
   mSize -= entry->GetDataSize();
   return entry.forget();
 }
 void imgCacheQueue::Refresh()
 {
   std::make_heap(mQueue.begin(), mQueue.end(), imgLoader::CompareCacheEntries);
   mDirty = false;
 }
 void imgCacheQueue::MarkDirty()
 {
   mDirty = true;
 }
 bool imgCacheQueue::IsDirty()
 {
   return mDirty;
 }
 uint32_t imgCacheQueue::GetNumElements() const
 {
   return mQueue.size();
 }
 imgCacheQueue::iterator imgCacheQueue::begin()
 {
   return mQueue.begin();
 }
 imgCacheQueue::const_iterator imgCacheQueue::begin() const
 {
   return mQueue.begin();
 }
 imgCacheQueue::iterator imgCacheQueue::end()
 {
   return mQueue.end();
 }
 imgCacheQueue::const_iterator imgCacheQueue::end() const
 {
   return mQueue.end();
 }
 nsresult imgLoader::CreateNewProxyForRequest(imgRequest *aRequest, nsILoadGroup *aLoadGroup,
                                              imgINotificationObserver *aObserver,
                                              nsLoadFlags aLoadFlags, imgRequestProxy **_retval)
 {
   LOG_SCOPE_WITH_PARAM(GetImgLog(), "imgLoader::CreateNewProxyForRequest", "imgRequest", aRequest);
   /* XXX If we move decoding onto separate threads, we should save off the
      calling thread here and pass it off to |proxyRequest| so that it call
      proxy calls to |aObserver|.
    */
   imgRequestProxy *proxyRequest = new imgRequestProxy();
   NS_ADDREF(proxyRequest);
   /* It is important to call |SetLoadFlags()| before calling |Init()| because
      |Init()| adds the request to the loadgroup.
    */
   proxyRequest->SetLoadFlags(aLoadFlags);
   nsRefPtr<ImageURL> uri;
   aRequest->GetURI(getter_AddRefs(uri));
   // init adds itself to imgRequest's list of observers
   nsresult rv = proxyRequest->Init(aRequest, aLoadGroup, uri, aObserver);
   if (NS_FAILED(rv)) {
     NS_RELEASE(proxyRequest);
     return rv;
   }
   // transfer reference to caller
   *_retval = proxyRequest;
   return NS_OK;
 }
 class imgCacheObserver MOZ_FINAL : public nsIObserver
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
 };
 NS_IMPL_ISUPPORTS(imgCacheObserver, nsIObserver)
 NS_IMETHODIMP
 imgCacheObserver::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aSomeData)
 {
   if (strcmp(aTopic, "memory-pressure") == 0) {
     DiscardTracker::DiscardAll();
   }
   return NS_OK;
 }
 class imgCacheExpirationTracker MOZ_FINAL
   : public nsExpirationTracker<imgCacheEntry, 3>
 {
   enum { TIMEOUT_SECONDS = 10 };
 public:
   imgCacheExpirationTracker();
 protected:
   void NotifyExpired(imgCacheEntry *entry);
 };
 imgCacheExpirationTracker::imgCacheExpirationTracker()
  : nsExpirationTracker<imgCacheEntry, 3>(TIMEOUT_SECONDS * 1000)
 {}
 void imgCacheExpirationTracker::NotifyExpired(imgCacheEntry *entry)
 {
   // Hold on to a reference to this entry, because the expiration tracker
   // mechanism doesn't.
   nsRefPtr<imgCacheEntry> kungFuDeathGrip(entry);
 #if defined(PR_LOGGING)
   nsRefPtr<imgRequest> req(entry->GetRequest());
   if (req) {
     nsRefPtr<ImageURL> uri;
     req->GetURI(getter_AddRefs(uri));
     nsAutoCString spec;
     uri->GetSpec(spec);
     LOG_FUNC_WITH_PARAM(GetImgLog(), "imgCacheExpirationTracker::NotifyExpired", "entry", spec.get());
   }
 #endif
   // We can be called multiple times on the same entry. Don't do work multiple
   // times.
   if (!entry->Evicted())
     entry->Loader()->RemoveFromCache(entry);
   entry->Loader()->VerifyCacheSizes();
 }
 imgCacheObserver *gCacheObserver;
 double imgLoader::sCacheTimeWeight;
 uint32_t imgLoader::sCacheMaxSize;
 imgMemoryReporter* imgLoader::sMemReporter;
 nsCOMPtr<mozIThirdPartyUtil> imgLoader::sThirdPartyUtilSvc;
 NS_IMPL_ISUPPORTS(imgLoader, imgILoader, nsIContentSniffer, imgICache, nsISupportsWeakReference, nsIObserver)
 static imgLoader* gSingleton = nullptr;
 static imgLoader* gPBSingleton = nullptr;
 imgLoader*
 imgLoader::Singleton()
 {
   if (!gSingleton)
     gSingleton = imgLoader::Create();
   return gSingleton;
 }
 imgLoader*
 imgLoader::PBSingleton()
 {
   if (!gPBSingleton) {
     gPBSingleton = imgLoader::Create();
     gPBSingleton->RespectPrivacyNotifications();
   }
   return gPBSingleton;
 }
 imgLoader::imgLoader()
 : mRespectPrivacy(false)
 {
   sMemReporter->AddRef();
   sMemReporter->RegisterLoader(this);
 }
 already_AddRefed<imgLoader>
 imgLoader::GetInstance()
 {
   static StaticRefPtr<imgLoader> singleton;
   if (!singleton) {
     singleton = imgLoader::Create();
     if (!singleton)
         return nullptr;
     ClearOnShutdown(&singleton);
   }
   nsRefPtr<imgLoader> loader = singleton.get();
   return loader.forget();
 }
 imgLoader::~imgLoader()
 {
   ClearChromeImageCache();
   ClearImageCache();
   sMemReporter->UnregisterLoader(this);
   sMemReporter->Release();
 }
 void imgLoader::VerifyCacheSizes()
 {
 #ifdef DEBUG
   if (!mCacheTracker)
     return;
   uint32_t cachesize = mCache.Count() + mChromeCache.Count();
   uint32_t queuesize = mCacheQueue.GetNumElements() + mChromeCacheQueue.GetNumElements();
   uint32_t trackersize = 0;
   for (nsExpirationTracker<imgCacheEntry, 3>::Iterator it(mCacheTracker); it.Next(); )
     trackersize++;
   NS_ABORT_IF_FALSE(queuesize == trackersize, "Queue and tracker sizes out of sync!");
   NS_ABORT_IF_FALSE(queuesize <= cachesize, "Queue has more elements than cache!");
 #endif
 }
 imgLoader::imgCacheTable & imgLoader::GetCache(nsIURI *aURI)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Cannot use nsIURI off main thread!");
   bool chrome = false;
   aURI->SchemeIs("chrome", &chrome);
   return chrome ? mChromeCache : mCache;
 }
 imgCacheQueue & imgLoader::GetCacheQueue(nsIURI *aURI)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Cannot use nsIURI off main thread!");
   bool chrome = false;
   aURI->SchemeIs("chrome", &chrome);
   return chrome ? mChromeCacheQueue : mCacheQueue;
 }
 imgLoader::imgCacheTable & imgLoader::GetCache(ImageURL *aURI)
 {
   bool chrome = false;
   aURI->SchemeIs("chrome", &chrome);
   return chrome ? mChromeCache : mCache;
 }
 imgCacheQueue & imgLoader::GetCacheQueue(ImageURL *aURI)
 {
   bool chrome = false;
   aURI->SchemeIs("chrome", &chrome);
   return chrome ? mChromeCacheQueue : mCacheQueue;
 }
 void imgLoader::GlobalInit()
 {
   gCacheObserver = new imgCacheObserver();
   NS_ADDREF(gCacheObserver);
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   if (os)
     os->AddObserver(gCacheObserver, "memory-pressure", false);
   int32_t timeweight;
   nsresult rv = Preferences::GetInt("image.cache.timeweight", &timeweight);
   if (NS_SUCCEEDED(rv))
     sCacheTimeWeight = timeweight / 1000.0;
   else
     sCacheTimeWeight = 0.5;
   int32_t cachesize;
   rv = Preferences::GetInt("image.cache.size", &cachesize);
   if (NS_SUCCEEDED(rv))
     sCacheMaxSize = cachesize;
   else
     sCacheMaxSize = 5 * 1024 * 1024;
   sMemReporter = new imgMemoryReporter();
   RegisterStrongMemoryReporter(sMemReporter);
   RegisterImagesContentUsedUncompressedDistinguishedAmount(imgMemoryReporter::ImagesContentUsedUncompressedDistinguishedAmount);
   sThirdPartyUtilSvc = do_GetService(THIRDPARTYUTIL_CONTRACTID);
 }
 nsresult imgLoader::InitCache()
 {
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   if (!os)
     return NS_ERROR_FAILURE;
   os->AddObserver(this, "memory-pressure", false);
   os->AddObserver(this, "chrome-flush-skin-caches", false);
   os->AddObserver(this, "chrome-flush-caches", false);
   os->AddObserver(this, "last-pb-context-exited", false);
   os->AddObserver(this, "profile-before-change", false);
   os->AddObserver(this, "xpcom-shutdown", false);
   mCacheTracker = new imgCacheExpirationTracker();
   return NS_OK;
 }
 nsresult imgLoader::Init()
 {
   InitCache();
   ReadAcceptHeaderPref();
   Preferences::AddWeakObserver(this, "image.http.accept");
     return NS_OK;
 }
 NS_IMETHODIMP
 imgLoader::RespectPrivacyNotifications()
 {
   mRespectPrivacy = true;
   return NS_OK;
 }
 NS_IMETHODIMP
 imgLoader::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
 {
   // We listen for pref change notifications...
   if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
     if (!strcmp(NS_ConvertUTF16toUTF8(aData).get(), "image.http.accept")) {
       ReadAcceptHeaderPref();
     }
   } else if (strcmp(aTopic, "memory-pressure") == 0) {
     MinimizeCaches();
   } else if (strcmp(aTopic, "chrome-flush-skin-caches") == 0 ||
              strcmp(aTopic, "chrome-flush-caches") == 0) {
     MinimizeCaches();
     ClearChromeImageCache();
   } else if (strcmp(aTopic, "last-pb-context-exited") == 0) {
     if (mRespectPrivacy) {
       ClearImageCache();
       ClearChromeImageCache();
     }
   } else if (strcmp(aTopic, "profile-before-change") == 0 ||
              strcmp(aTopic, "xpcom-shutdown") == 0) {
     mCacheTracker = nullptr;
   }
   // (Nothing else should bring us here)
   else {
     NS_ABORT_IF_FALSE(0, "Invalid topic received");
   }
   return NS_OK;
 }
 void imgLoader::ReadAcceptHeaderPref()
 {
   nsAdoptingCString accept = Preferences::GetCString("image.http.accept");
   if (accept)
     mAcceptHeader = accept;
   else
     mAcceptHeader = IMAGE_PNG "," IMAGE_WILDCARD ";q=0.8," ANY_WILDCARD ";q=0.5";
 }
 /* void clearCache (in boolean chrome); */
 NS_IMETHODIMP imgLoader::ClearCache(bool chrome)
 {
   if (chrome)
     return ClearChromeImageCache();
   else
     return ClearImageCache();
 }
 /* void removeEntry(in nsIURI uri); */
 NS_IMETHODIMP imgLoader::RemoveEntry(nsIURI *uri)
 {
   if (RemoveMatchingUrlsFromCache(uri))
     return NS_OK;
   return NS_ERROR_NOT_AVAILABLE;
 }
 static PLDHashOperator EnumAllEntries(const nsACString&,
                                       nsRefPtr<imgCacheEntry> &aData,
                                       void *data)
 {
   nsTArray<nsRefPtr<imgCacheEntry> > *entries =
     reinterpret_cast<nsTArray<nsRefPtr<imgCacheEntry> > *>(data);
   entries->AppendElement(aData);
   return PL_DHASH_NEXT;
 }
 /* imgIRequest findEntry(in nsIURI uri); */
 NS_IMETHODIMP imgLoader::FindEntryProperties(nsIURI *uri, nsIProperties **_retval)
 {
   nsRefPtr<imgCacheEntry> entry;
   imgCacheTable &cache = GetCache(uri);
   *_retval = nullptr;
   // We must traverse the whole cache in O(N) looking for the first
   // matching URI.
   //
   // TODO: For now, it's ok to pick at random here. The images should be
   // identical unless there is a cache-tracking attack. And even if they
   // are not identical due to attack, this code is only used for save
   // dialogs at this point, so no differentiating info is leaked to
   // content.
   nsTArray<nsRefPtr<imgCacheEntry> > entries;
   cache.Enumerate(EnumAllEntries, &entries);
   for (uint32_t i = 0; i < entries.Length(); ++i) {
     bool isEqual = false;
     nsRefPtr<imgRequest> request = entries[i]->GetRequest();
     if (request) {
       request->mURI->Equals(uri, &isEqual);
       if (isEqual) {
         if (mCacheTracker && entries[i]->HasNoProxies()) {
           mCacheTracker->MarkUsed(entries[i]);
         }
         *_retval = request->Properties();
         NS_ADDREF(*_retval);
         break;
       }
     }
   }
   if (*_retval) {
     return NS_OK;
   }
   return NS_ERROR_NOT_AVAILABLE;
 }
 void imgLoader::Shutdown()
 {
   NS_IF_RELEASE(gSingleton);
   NS_IF_RELEASE(gPBSingleton);
   NS_RELEASE(gCacheObserver);
   sThirdPartyUtilSvc = nullptr;
 }
 nsresult imgLoader::ClearChromeImageCache()
 {
   return EvictEntries(mChromeCache);
 }
 nsresult imgLoader::ClearImageCache()
 {
   return EvictEntries(mCache);
 }
 void imgLoader::MinimizeCaches()
 {
   EvictEntries(mCacheQueue);
   EvictEntries(mChromeCacheQueue);
 }
 bool imgLoader::PutIntoCache(nsAutoCString key, imgCacheEntry *entry)
 {
   LOG_STATIC_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::PutIntoCache", "uri", key.get());
   imgCacheTable &cache = GetCache(entry->mRequest->mURI);
   imgCacheQueue &queue = GetCacheQueue(entry->mRequest->mURI);
   // Check to see if this request already exists in the cache and is being
   // loaded on a different thread. If so, don't allow this entry to be added to
   // the cache.
   nsRefPtr<imgCacheEntry> tmpCacheEntry;
   if (cache.Get(key, getter_AddRefs(tmpCacheEntry)) && tmpCacheEntry) {
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("[this=%p] imgLoader::PutIntoCache -- Element already in the cache", nullptr));
     nsRefPtr<imgRequest> tmpRequest = tmpCacheEntry->GetRequest();
     // If it already exists, and we're putting the same key into the cache, we
     // should remove the old version.
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("[this=%p] imgLoader::PutIntoCache -- Replacing cached element", nullptr));
     RemoveFromCache(key, cache, queue);
   } else {
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("[this=%p] imgLoader::PutIntoCache -- Element NOT already in the cache", nullptr));
   }
   cache.Put(key, entry);
   // We can be called to resurrect an evicted entry.
   if (entry->Evicted())
     entry->SetEvicted(false);
   // If we're resurrecting an entry with no proxies, put it back in the
   // tracker and queue.
   if (entry->HasNoProxies()) {
     nsresult addrv = NS_OK;
     if (mCacheTracker)
       addrv = mCacheTracker->AddObject(entry);
     if (NS_SUCCEEDED(addrv)) {
       queue.Push(entry);
     }
   }
   nsRefPtr<imgRequest> request = entry->GetRequest();
   request->SetIsInCache(true);
   return true;
 }
 bool imgLoader::SetHasNoProxies(ImageURL *imgURI, imgCacheEntry *entry)
 {
 #if defined(PR_LOGGING)
   nsAutoCString spec;
   imgURI->GetSpec(spec);
   LOG_STATIC_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::SetHasNoProxies", "uri", spec.get());
 #endif
   if (entry->Evicted())
     return false;
   imgCacheQueue &queue = GetCacheQueue(imgURI);
   nsresult addrv = NS_OK;
   if (mCacheTracker)
     addrv = mCacheTracker->AddObject(entry);
   if (NS_SUCCEEDED(addrv)) {
     queue.Push(entry);
     entry->SetHasNoProxies(true);
   }
   imgCacheTable &cache = GetCache(imgURI);
   CheckCacheLimits(cache, queue);
   return true;
 }
 bool imgLoader::SetHasProxies(nsIURI *firstPartyIsolationURI, ImageURL *imgURI)
 {
   VerifyCacheSizes();
   imgCacheTable &cache = GetCache(imgURI);
   nsAutoCString spec;
   imgURI->GetSpec(spec);
   LOG_STATIC_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::SetHasProxies", "uri", spec.get());
   nsAutoCString key = GetCacheKey(firstPartyIsolationURI, imgURI, nullptr);
   nsRefPtr<imgCacheEntry> entry;
   if (cache.Get(key, getter_AddRefs(entry)) && entry && entry->HasNoProxies()) {
     imgCacheQueue &queue = GetCacheQueue(imgURI);
     queue.Remove(entry);
     if (mCacheTracker)
       mCacheTracker->RemoveObject(entry);
     entry->SetHasNoProxies(false);
     return true;
   }
   return false;
 }
 void imgLoader::CacheEntriesChanged(ImageURL *uri, int32_t sizediff /* = 0 */)
 {
   imgCacheQueue &queue = GetCacheQueue(uri);
   queue.MarkDirty();
   queue.UpdateSize(sizediff);
 }
 void imgLoader::CheckCacheLimits(imgCacheTable &cache, imgCacheQueue &queue)
 {
   if (queue.GetNumElements() == 0)
     NS_ASSERTION(queue.GetSize() == 0,
                  "imgLoader::CheckCacheLimits -- incorrect cache size");
   // Remove entries from the cache until we're back under our desired size.
   while (queue.GetSize() >= sCacheMaxSize) {
     // Remove the first entry in the queue.
     nsRefPtr<imgCacheEntry> entry(queue.Pop());
     NS_ASSERTION(entry, "imgLoader::CheckCacheLimits -- NULL entry pointer");
 #if defined(PR_LOGGING)
     nsRefPtr<imgRequest> req(entry->GetRequest());
     if (req) {
       nsRefPtr<ImageURL> uri;
       req->GetURI(getter_AddRefs(uri));
       nsAutoCString spec;
       uri->GetSpec(spec);
       LOG_STATIC_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::CheckCacheLimits", "entry", spec.get());
     }
 #endif
     if (entry)
       RemoveFromCache(entry);
   }
 }
 bool imgLoader::ValidateRequestWithNewChannel(imgRequest *request,
                                                 nsIURI *aURI,
                                                 nsIURI *aFirstPartyIsolationURI,
                                                 nsIURI *aReferrerURI,
                                                 nsILoadGroup *aLoadGroup,
                                                 imgINotificationObserver *aObserver,
                                                 nsISupports *aCX,
                                                 nsLoadFlags aLoadFlags,
                                                 imgRequestProxy **aProxyRequest,
                                                 nsIChannelPolicy *aPolicy,
                                                 nsIPrincipal* aLoadingPrincipal,
                                                 int32_t aCORSMode)
 {
   // now we need to insert a new channel request object inbetween the real
   // request and the proxy that basically delays loading the image until it
   // gets a 304 or figures out that this needs to be a new request
   nsresult rv;
   // If we're currently in the middle of validating this request, just hand
   // back a proxy to it; the required work will be done for us.
   if (request->mValidator) {
     rv = CreateNewProxyForRequest(request, aLoadGroup, aObserver,
                                   aLoadFlags, aProxyRequest);
     if (NS_FAILED(rv)) {
       return false;
     }
     if (*aProxyRequest) {
       imgRequestProxy* proxy = static_cast<imgRequestProxy*>(*aProxyRequest);
       // We will send notifications from imgCacheValidator::OnStartRequest().
       // In the mean time, we must defer notifications because we are added to
       // the imgRequest's proxy list, and we can get extra notifications
       // resulting from methods such as RequestDecode(). See bug 579122.
       proxy->SetNotificationsDeferred(true);
       // Attach the proxy without notifying
       request->mValidator->AddProxy(proxy);
     }
     return NS_SUCCEEDED(rv);
   } else {
     // We will rely on Necko to cache this request when it's possible, and to
     // tell imgCacheValidator::OnStartRequest whether the request came from its
     // cache.
     nsCOMPtr<nsIChannel> newChannel;
     bool forcePrincipalCheck;
     rv = NewImageChannel(getter_AddRefs(newChannel),
                          &forcePrincipalCheck,
                          aURI,
                          aFirstPartyIsolationURI,
                          aReferrerURI,
                          aLoadGroup,
                          mAcceptHeader,
                          aLoadFlags,
                          aPolicy,
                          aLoadingPrincipal);
     if (NS_FAILED(rv)) {
       return false;
     }
     nsRefPtr<imgRequestProxy> req;
     rv = CreateNewProxyForRequest(request, aLoadGroup, aObserver,
                                   aLoadFlags, getter_AddRefs(req));
     if (NS_FAILED(rv)) {
       return false;
     }
     // Make sure that OnStatus/OnProgress calls have the right request set...
     nsRefPtr<nsProgressNotificationProxy> progressproxy =
         new nsProgressNotificationProxy(newChannel, req);
     if (!progressproxy)
       return false;
     nsRefPtr<imgCacheValidator> hvc =
       new imgCacheValidator(progressproxy, this, request, aCX, forcePrincipalCheck);
     // Casting needed here to get past multiple inheritance.
     nsCOMPtr<nsIStreamListener> listener =
       do_QueryInterface(static_cast<nsIThreadRetargetableStreamListener*>(hvc));
     NS_ENSURE_TRUE(listener, false);
     // We must set the notification callbacks before setting up the
     // CORS listener, because that's also interested inthe
     // notification callbacks.
     newChannel->SetNotificationCallbacks(hvc);
     if (aCORSMode != imgIRequest::CORS_NONE) {
       bool withCredentials = aCORSMode == imgIRequest::CORS_USE_CREDENTIALS;
       nsRefPtr<nsCORSListenerProxy> corsproxy =
         new nsCORSListenerProxy(listener, aLoadingPrincipal, withCredentials);
       rv = corsproxy->Init(newChannel);
       if (NS_FAILED(rv)) {
         return false;
       }
       listener = corsproxy;
     }
     request->mValidator = hvc;
     imgRequestProxy* proxy = static_cast<imgRequestProxy*>
                                (static_cast<imgIRequest*>(req.get()));
     // We will send notifications from imgCacheValidator::OnStartRequest().
     // In the mean time, we must defer notifications because we are added to
     // the imgRequest's proxy list, and we can get extra notifications
     // resulting from methods such as RequestDecode(). See bug 579122.
     proxy->SetNotificationsDeferred(true);
     // Add the proxy without notifying
     hvc->AddProxy(proxy);
     mozilla::net::SeerLearn(aURI, aFirstPartyIsolationURI,
         nsINetworkSeer::LEARN_LOAD_SUBRESOURCE, aLoadGroup);
     rv = newChannel->AsyncOpen(listener, nullptr);
     if (NS_SUCCEEDED(rv))
       NS_ADDREF(*aProxyRequest = req.get());
     return NS_SUCCEEDED(rv);
   }
 }
 bool imgLoader::ValidateEntry(imgCacheEntry *aEntry,
                                 nsIURI *aURI,
                                 nsIURI *aFirstPartyIsolationURI,
                                 nsIURI *aReferrerURI,
                                 nsILoadGroup *aLoadGroup,
                                 imgINotificationObserver *aObserver,
                                 nsISupports *aCX,
                                 nsLoadFlags aLoadFlags,
                                 bool aCanMakeNewChannel,
                                 imgRequestProxy **aProxyRequest,
                                 nsIChannelPolicy *aPolicy,
                                 nsIPrincipal* aLoadingPrincipal,
                                 int32_t aCORSMode)
 {
   LOG_SCOPE(GetImgLog(), "imgLoader::ValidateEntry");
   bool hasExpired;
   uint32_t expirationTime = aEntry->GetExpiryTime();
   if (expirationTime <= SecondsFromPRTime(PR_Now())) {
     hasExpired = true;
   } else {
     hasExpired = false;
   }
   nsresult rv;
   // Special treatment for file URLs - aEntry has expired if file has changed
   nsCOMPtr<nsIFileURL> fileUrl(do_QueryInterface(aURI));
   if (fileUrl) {
     uint32_t lastModTime = aEntry->GetTouchedTime();
     nsCOMPtr<nsIFile> theFile;
     rv = fileUrl->GetFile(getter_AddRefs(theFile));
     if (NS_SUCCEEDED(rv)) {
       PRTime fileLastMod;
       rv = theFile->GetLastModifiedTime(&fileLastMod);
       if (NS_SUCCEEDED(rv)) {
         // nsIFile uses millisec, NSPR usec
         fileLastMod *= 1000;
         hasExpired = SecondsFromPRTime((PRTime)fileLastMod) > lastModTime;
       }
     }
   }
   nsRefPtr<imgRequest> request(aEntry->GetRequest());
   if (!request)
     return false;
   if (!ValidateCORSAndPrincipal(request, aEntry->ForcePrincipalCheck(),
                                 aCORSMode, aLoadingPrincipal))
     return false;
   // Never validate data URIs.
   nsAutoCString scheme;
   aURI->GetScheme(scheme);
   if (scheme.EqualsLiteral("data"))
     return true;
   bool validateRequest = false;
   // If the request's loadId is the same as the aCX, 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.
   //
   void *key = (void *)aCX;
   if (request->mLoadId != key) {
     // If we would need to revalidate this entry, but we're being told to
     // bypass the cache, we don't allow this entry to be used.
     if (aLoadFlags & nsIRequest::LOAD_BYPASS_CACHE)
       return false;
     // Determine whether the cache aEntry must be revalidated...
     validateRequest = ShouldRevalidateEntry(aEntry, aLoadFlags, hasExpired);
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("imgLoader::ValidateEntry validating cache entry. "
             "validateRequest = %d", validateRequest));
   }
 #if defined(PR_LOGGING)
   else if (!key) {
     nsAutoCString spec;
     aURI->GetSpec(spec);
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("imgLoader::ValidateEntry BYPASSING cache validation for %s "
             "because of NULL LoadID", spec.get()));
   }
 #endif
   // We can't use a cached request if it comes from a different
   // application cache than this load is expecting.
   nsCOMPtr<nsIApplicationCacheContainer> appCacheContainer;
   nsCOMPtr<nsIApplicationCache> requestAppCache;
   nsCOMPtr<nsIApplicationCache> groupAppCache;
   if ((appCacheContainer = do_GetInterface(request->mRequest)))
     appCacheContainer->GetApplicationCache(getter_AddRefs(requestAppCache));
   if ((appCacheContainer = do_QueryInterface(aLoadGroup)))
     appCacheContainer->GetApplicationCache(getter_AddRefs(groupAppCache));
   if (requestAppCache != groupAppCache) {
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("imgLoader::ValidateEntry - Unable to use cached imgRequest "
             "[request=%p] because of mismatched application caches\n",
             address_of(request)));
     return false;
   }
   if (validateRequest && aCanMakeNewChannel) {
     LOG_SCOPE(GetImgLog(), "imgLoader::ValidateRequest |cache hit| must validate");
     return ValidateRequestWithNewChannel(request, aURI, aFirstPartyIsolationURI,
                                          aReferrerURI, aLoadGroup, aObserver,
                                          aCX, aLoadFlags, aProxyRequest, aPolicy,
                                          aLoadingPrincipal, aCORSMode);
   }
   return !validateRequest;
 }
 bool imgLoader::RemoveMatchingUrlsFromCache(nsIURI *aImgURI)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Cannot use nsIURI off main thread!");
   if (!aImgURI) return false;
   bool rv = true;
   imgCacheTable &cache = GetCache(aImgURI);
   // We have to make a temporary, since RemoveFromCache removes the element
   // from the queue, invalidating iterators.
   nsTArray<nsRefPtr<imgCacheEntry> > entries;
   cache.Enumerate(EnumAllEntries, &entries);
   for (uint32_t i = 0; i < entries.Length(); ++i) {
     bool isEqual = false;
     entries[i]->mRequest->mURI->Equals(aImgURI, &isEqual);
     if (isEqual && !RemoveFromCache(entries[i]))
       rv = false;
   }
   return rv;
 }
 bool imgLoader::RemoveFromCache(nsAutoCString key,
                                 imgCacheTable &cache,
                                 imgCacheQueue &queue)
 {
   if (key.IsEmpty()) return false;
   nsRefPtr<imgCacheEntry> entry;
   if (cache.Get(key, getter_AddRefs(entry)) && entry) {
     cache.Remove(key);
     NS_ABORT_IF_FALSE(!entry->Evicted(), "Evicting an already-evicted cache entry!");
     // Entries with no proxies are in the tracker.
     if (entry->HasNoProxies()) {
       if (mCacheTracker)
         mCacheTracker->RemoveObject(entry);
       queue.Remove(entry);
     }
     entry->SetEvicted(true);
     nsRefPtr<imgRequest> request = entry->GetRequest();
     request->SetIsInCache(false);
     return true;
   }
   else
     return false;
 }
 bool imgLoader::RemoveFromCache(imgCacheEntry *entry)
 {
   LOG_STATIC_FUNC(GetImgLog(), "imgLoader::RemoveFromCache entry");
   nsRefPtr<imgRequest> request = entry->GetRequest();
   if (request) {
     nsRefPtr<ImageURL> imgURI;
     if (NS_SUCCEEDED(request->GetURI(getter_AddRefs(imgURI))) && imgURI) {
       nsCOMPtr<nsIURI> firstPartyIsolationURI = request->mFirstPartyIsolationURI;
       imgCacheTable &cache = GetCache(imgURI);
       imgCacheQueue &queue = GetCacheQueue(imgURI);
       nsAutoCString spec = GetCacheKey(firstPartyIsolationURI, imgURI, nullptr);
       LOG_STATIC_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::RemoveFromCache", "entry's uri", spec.get());
       cache.Remove(spec);
       if (entry->HasNoProxies()) {
         LOG_STATIC_FUNC(GetImgLog(), "imgLoader::RemoveFromCache removing from tracker");
         if (mCacheTracker)
           mCacheTracker->RemoveObject(entry);
         queue.Remove(entry);
       }
       entry->SetEvicted(true);
       request->SetIsInCache(false);
       return true;
     }
   }
   return false;
 }
 nsresult imgLoader::EvictEntries(imgCacheTable &aCacheToClear)
 {
   nsresult rv = NS_OK;
   LOG_STATIC_FUNC(GetImgLog(), "imgLoader::EvictEntries table");
   // We have to make a temporary, since RemoveFromCache removes the element
   // from the queue, invalidating iterators.
   nsTArray<nsRefPtr<imgCacheEntry> > entries;
   aCacheToClear.Enumerate(EnumAllEntries, &entries);
   for (uint32_t i = 0; i < entries.Length(); ++i)
     if (!RemoveFromCache(entries[i]))
       rv = NS_ERROR_FAILURE;
   return rv;
 }
 nsresult imgLoader::EvictEntries(imgCacheQueue &aQueueToClear)
 {
   LOG_STATIC_FUNC(GetImgLog(), "imgLoader::EvictEntries queue");
   // We have to make a temporary, since RemoveFromCache removes the element
   // from the queue, invalidating iterators.
   nsTArray<nsRefPtr<imgCacheEntry> > entries(aQueueToClear.GetNumElements());
   for (imgCacheQueue::const_iterator i = aQueueToClear.begin(); i != aQueueToClear.end(); ++i)
     entries.AppendElement(*i);
   for (uint32_t i = 0; i < entries.Length(); ++i)
     if (!RemoveFromCache(entries[i]))
       return NS_ERROR_FAILURE;
   return NS_OK;
 }
 #define LOAD_FLAGS_CACHE_MASK    (nsIRequest::LOAD_BYPASS_CACHE | \
                                   nsIRequest::LOAD_FROM_CACHE)
 #define LOAD_FLAGS_VALIDATE_MASK (nsIRequest::VALIDATE_ALWAYS |   \
                                   nsIRequest::VALIDATE_NEVER |    \
                                   nsIRequest::VALIDATE_ONCE_PER_SESSION)
 NS_IMETHODIMP imgLoader::LoadImageXPCOM(nsIURI *aURI,
                                    nsIURI *aInitialDocumentURI,
                                    nsIURI *aReferrerURI,
                                    nsIPrincipal* aLoadingPrincipal,
                                    nsILoadGroup *aLoadGroup,
                                    imgINotificationObserver *aObserver,
                                    nsISupports *aCX,
                                    nsLoadFlags aLoadFlags,
                                    nsISupports *aCacheKey,
                                    nsIChannelPolicy *aPolicy,
                                    imgIRequest **_retval)
 {
     imgRequestProxy *proxy;
     nsresult result = LoadImage(aURI,
                                 aInitialDocumentURI,
                                 aReferrerURI,
                                 aLoadingPrincipal,
                                 aLoadGroup,
                                 aObserver,
                                 aCX,
                                 aLoadFlags,
                                 aCacheKey,
                                 aPolicy,
                                 EmptyString(),
                                 &proxy);
     *_retval = proxy;
     return result;
 }
 /* imgIRequest loadImage (in nsIURI aURI, in nsIURI aUrlBarURI, in nsIPrincipal loadingPrincipal, in nsILoadGroup aLoadGroup, in imgIDecoderObserver aObserver, in nsISupports aCX, in nsLoadFlags aLoadFlags, in nsISupports cacheKey, in imgIRequest aRequest); */
 nsresult imgLoader::LoadImage(nsIURI *aURI,
 			      nsIURI *aFirstPartyIsolationURI,
 			      nsIURI *aReferrerURI,
 			      nsIPrincipal* aLoadingPrincipal,
 			      nsILoadGroup *aLoadGroup,
 			      imgINotificationObserver *aObserver,
 			      nsISupports *aCX,
 			      nsLoadFlags aLoadFlags,
 			      nsISupports *aCacheKey,
 			      nsIChannelPolicy *aPolicy,
 			      const nsAString& initiatorType,
 			      imgRequestProxy **_retval)
 {
 	VerifyCacheSizes();
   NS_ASSERTION(aURI, "imgLoader::LoadImage -- NULL URI pointer");
   if (!aURI)
     return NS_ERROR_NULL_POINTER;
   bool isIsolated = false;
   nsAutoCString spec = GetCacheKey(aFirstPartyIsolationURI, aURI, &isIsolated);
   LOG_SCOPE_WITH_PARAM(GetImgLog(), "imgLoader::LoadImage", "aURI", spec.get());
   *_retval = nullptr;
   nsRefPtr<imgRequest> request;
   nsresult rv;
   nsLoadFlags requestFlags = nsIRequest::LOAD_NORMAL;
 #ifdef DEBUG
   bool isPrivate = false;
   if (aLoadGroup) {
     nsCOMPtr<nsIInterfaceRequestor> callbacks;
     aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
     if (callbacks) {
       nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
       isPrivate = loadContext && loadContext->UsePrivateBrowsing();
     }
   }
   MOZ_ASSERT(isPrivate == mRespectPrivacy);
 #endif
   // Get the default load flags from the loadgroup (if possible)...
   if (aLoadGroup) {
     aLoadGroup->GetLoadFlags(&requestFlags);
   }
   //
   // Merge the default load flags with those passed in via aLoadFlags.
   // Currently, *only* the caching, validation and background load flags
   // are merged...
   //
   // The flags in aLoadFlags take precedence over the default flags!
   //
   if (aLoadFlags & LOAD_FLAGS_CACHE_MASK) {
     // Override the default caching flags...
     requestFlags = (requestFlags & ~LOAD_FLAGS_CACHE_MASK) |
                    (aLoadFlags & LOAD_FLAGS_CACHE_MASK);
   }
   if (aLoadFlags & LOAD_FLAGS_VALIDATE_MASK) {
     // Override the default validation flags...
     requestFlags = (requestFlags & ~LOAD_FLAGS_VALIDATE_MASK) |
                    (aLoadFlags & LOAD_FLAGS_VALIDATE_MASK);
   }
   if (aLoadFlags & nsIRequest::LOAD_BACKGROUND) {
     // Propagate background loading...
     requestFlags |= nsIRequest::LOAD_BACKGROUND;
   }
   int32_t corsmode = imgIRequest::CORS_NONE;
   if (aLoadFlags & imgILoader::LOAD_CORS_ANONYMOUS) {
     corsmode = imgIRequest::CORS_ANONYMOUS;
   } else if (aLoadFlags & imgILoader::LOAD_CORS_USE_CREDENTIALS) {
     corsmode = imgIRequest::CORS_USE_CREDENTIALS;
   }
   nsRefPtr<imgCacheEntry> entry;
   // Look in the cache for our URI, and then validate it.
   // XXX For now ignore aCacheKey. We will need it in the future
   // for correctly dealing with image load requests that are a result
   // of post data.
   imgCacheTable &cache = GetCache(aURI);
   if (cache.Get(spec, getter_AddRefs(entry)) && entry) {
     if (ValidateEntry(entry, aURI, aFirstPartyIsolationURI, aReferrerURI,
                       aLoadGroup, aObserver, aCX, requestFlags, true,
                       _retval, aPolicy, aLoadingPrincipal, corsmode)) {
       request = entry->GetRequest();
       // If this entry has no proxies, its request has no reference to the entry.
       if (entry->HasNoProxies()) {
         LOG_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::LoadImage() adding proxyless entry", "uri", spec.get());
         NS_ABORT_IF_FALSE(!request->HasCacheEntry(), "Proxyless entry's request has cache entry!");
         request->SetCacheEntry(entry);
         if (mCacheTracker)
           mCacheTracker->MarkUsed(entry);
       }
       entry->Touch();
 #ifdef DEBUG_joe
       printf("CACHEGET: %d %s %d\n", time(nullptr), spec.get(), entry->SizeOfData());
 #endif
     }
     else {
       // We can't use this entry. We'll try to load it off the network, and if
       // successful, overwrite the old entry in the cache with a new one.
       entry = nullptr;
     }
   }
   // Keep the channel in this scope, so we can adjust its notificationCallbacks
   // later when we create the proxy.
   nsCOMPtr<nsIChannel> newChannel;
   // If we didn't get a cache hit, we need to load from the network.
   if (!request) {
     LOG_SCOPE(GetImgLog(), "imgLoader::LoadImage |cache miss|");
     bool forcePrincipalCheck;
     rv = NewImageChannel(getter_AddRefs(newChannel),
                          &forcePrincipalCheck,
                          aURI,
                          aFirstPartyIsolationURI,
                          aReferrerURI,
                          aLoadGroup,
                          mAcceptHeader,
                          requestFlags,
                          aPolicy,
                          aLoadingPrincipal);
     if (NS_FAILED(rv))
       return NS_ERROR_FAILURE;
     MOZ_ASSERT(NS_UsePrivateBrowsing(newChannel) == mRespectPrivacy);
     NewRequestAndEntry(forcePrincipalCheck, this, getter_AddRefs(request), getter_AddRefs(entry));
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("[this=%p] imgLoader::LoadImage -- Created new imgRequest [request=%p]\n", this, request.get()));
     nsCOMPtr<nsILoadGroup> channelLoadGroup;
     newChannel->GetLoadGroup(getter_AddRefs(channelLoadGroup));
     request->Init(aURI, aURI, aFirstPartyIsolationURI, channelLoadGroup, newChannel, entry, aCX,
                   aLoadingPrincipal, corsmode);
     // Add the initiator type for this image load
     nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(newChannel);
     if (timedChannel) {
       timedChannel->SetInitiatorType(initiatorType);
     }
     // Pass the inner window ID of the loading document, if possible.
     nsCOMPtr<nsIDocument> doc = do_QueryInterface(aCX);
     if (doc) {
       request->SetInnerWindowID(doc->InnerWindowID());
     }
     // create the proxy listener
     nsCOMPtr<nsIStreamListener> pl = new ProxyListener(request.get());
     // See if we need to insert a CORS proxy between the proxy listener and the
     // request.
     nsCOMPtr<nsIStreamListener> listener = pl;
     if (corsmode != imgIRequest::CORS_NONE) {
       PR_LOG(GetImgLog(), PR_LOG_DEBUG,
              ("[this=%p] imgLoader::LoadImage -- Setting up a CORS load",
               this));
       bool withCredentials = corsmode == imgIRequest::CORS_USE_CREDENTIALS;
       nsRefPtr<nsCORSListenerProxy> corsproxy =
         new nsCORSListenerProxy(pl, aLoadingPrincipal, withCredentials);
       rv = corsproxy->Init(newChannel);
       if (NS_FAILED(rv)) {
         PR_LOG(GetImgLog(), PR_LOG_DEBUG,
                ("[this=%p] imgLoader::LoadImage -- nsCORSListenerProxy "
                 "creation failed: 0x%x\n", this, rv));
         request->CancelAndAbort(rv);
         return NS_ERROR_FAILURE;
       }
       listener = corsproxy;
     }
     PR_LOG(GetImgLog(), PR_LOG_DEBUG,
            ("[this=%p] imgLoader::LoadImage -- Calling channel->AsyncOpen()\n", this));
     mozilla::net::SeerLearn(aURI, aFirstPartyIsolationURI,
         nsINetworkSeer::LEARN_LOAD_SUBRESOURCE, aLoadGroup);
     nsresult openRes = newChannel->AsyncOpen(listener, nullptr);
     if (NS_FAILED(openRes)) {
       PR_LOG(GetImgLog(), PR_LOG_DEBUG,
              ("[this=%p] imgLoader::LoadImage -- AsyncOpen() failed: 0x%x\n",
               this, openRes));
       request->CancelAndAbort(openRes);
       return openRes;
     }
     if (isIsolated) // Try to add the new request into the cache.
       PutIntoCache(spec, entry);
   } else {
     LOG_MSG_WITH_PARAM(GetImgLog(),
                        "imgLoader::LoadImage |cache hit|", "request", request);
   }
   // If we didn't get a proxy when validating the cache entry, we need to create one.
   if (!*_retval) {
     // ValidateEntry() has three return values: "Is valid," "might be valid --
     // validating over network", and "not valid." If we don't have a _retval,
     // we know ValidateEntry is not validating over the network, so it's safe
     // to SetLoadId here because we know this request is valid for this context.
     //
     // Note, however, that this doesn't guarantee the behaviour we want (one
     // URL maps to the same image on a page) if we load the same image in a
     // different tab (see bug 528003), because its load id will get re-set, and
     // that'll cause us to validate over the network.
     request->SetLoadId(aCX);
     LOG_MSG(GetImgLog(), "imgLoader::LoadImage", "creating proxy request.");
     rv = CreateNewProxyForRequest(request, aLoadGroup, aObserver,
                                   requestFlags, _retval);
     if (NS_FAILED(rv)) {
       return rv;
     }
     imgRequestProxy *proxy = *_retval;
     // Make sure that OnStatus/OnProgress calls have the right request set, if
     // we did create a channel here.
     if (newChannel) {
       nsCOMPtr<nsIInterfaceRequestor> requestor(
           new nsProgressNotificationProxy(newChannel, proxy));
       if (!requestor)
         return NS_ERROR_OUT_OF_MEMORY;
       newChannel->SetNotificationCallbacks(requestor);
     }
     // Note that it's OK to add here even if the request is done.  If it is,
     // it'll send a OnStopRequest() to the proxy in imgRequestProxy::Notify and
     // the proxy will be removed from the loadgroup.
     proxy->AddToLoadGroup();
     // If we're loading off the network, explicitly don't notify our proxy,
     // because necko (or things called from necko, such as imgCacheValidator)
     // are going to call our notifications asynchronously, and we can't make it
     // further asynchronous because observers might rely on imagelib completing
     // its work between the channel's OnStartRequest and OnStopRequest.
     if (!newChannel)
       proxy->NotifyListener();
     return rv;
   }
   NS_ASSERTION(*_retval, "imgLoader::LoadImage -- no return value");
   return NS_OK;
 }
 nsAutoCString imgLoader::GetCacheKey(nsIURI *firstPartyIsolationURI, ImageURL *imgURI,
                                      bool *isIsolated)
 {
   NS_ASSERTION(imgURI, "imgLoader::GetCacheKey -- NULL imgURI");
   if (isIsolated)
     *isIsolated = false;
   nsAutoCString spec;
   if (imgURI)
     imgURI->GetSpec(spec);
   nsAutoCString hostKey;
   if (firstPartyIsolationURI && sThirdPartyUtilSvc)
     sThirdPartyUtilSvc->GetFirstPartyHostForIsolation(firstPartyIsolationURI, hostKey);
   if (hostKey.Length() > 0) {
     if (isIsolated)
       *isIsolated = true;
     // Make a new key using host
     // FIXME: This might involve a couple more copies than necessary..
     // But man, 18 string types? Who knows which one I need to use to do
     // this cheaply..
     return hostKey + nsAutoCString("&") + spec;
   } else {
     // No hostKey found, so don't isolate image to a first party.
     return spec;
   }
 }
 nsAutoCString imgLoader::GetCacheKey(nsIURI *firstPartyIsolationURI, nsIURI* uri,
                                      bool *isIsolated) {
   nsRefPtr<ImageURL> imageURI = new ImageURL(uri);
   return GetCacheKey(firstPartyIsolationURI, imageURI, isIsolated);
 }
 /* imgIRequest loadImageWithChannelXPCOM(in nsIChannel channel, in imgINotificationObserver aObserver, in nsISupports cx, out nsIStreamListener); */
 NS_IMETHODIMP imgLoader::LoadImageWithChannelXPCOM(nsIChannel *channel, imgINotificationObserver *aObserver, nsISupports *aCX, nsIStreamListener **listener, imgIRequest **_retval)
 {
     nsresult result;
     imgRequestProxy* proxy;
     result = LoadImageWithChannel(channel,
                                   aObserver,
                                   aCX,
                                   listener,
                                   &proxy);
     *_retval = proxy;
     return result;
 }
 nsresult imgLoader::LoadImageWithChannel(nsIChannel *channel, imgINotificationObserver *aObserver, nsISupports *aCX, nsIStreamListener **listener, imgRequestProxy **_retval)
 {
   NS_ASSERTION(channel, "imgLoader::LoadImageWithChannel -- NULL channel pointer");
   MOZ_ASSERT(NS_UsePrivateBrowsing(channel) == mRespectPrivacy);
   if (!sThirdPartyUtilSvc)
     return NS_ERROR_FAILURE;
   nsRefPtr<imgRequest> request;
   nsCOMPtr<nsIURI> uri;
   channel->GetURI(getter_AddRefs(uri));
   nsCOMPtr<nsIURI> firstPartyIsolationURI;
   sThirdPartyUtilSvc->GetFirstPartyIsolationURI(channel, nullptr,
                                                 getter_AddRefs(firstPartyIsolationURI));
   nsLoadFlags requestFlags = nsIRequest::LOAD_NORMAL;
   channel->GetLoadFlags(&requestFlags);
   nsRefPtr<imgCacheEntry> entry;
   imgCacheTable &cache = GetCache(uri);
   nsAutoCString key = GetCacheKey(firstPartyIsolationURI, uri, nullptr);
   if (requestFlags & nsIRequest::LOAD_BYPASS_CACHE) {
     imgCacheQueue &queue = GetCacheQueue(uri);
     RemoveFromCache(key, cache, queue);
   } else {
     // Look in the cache for our URI, and then validate it.
     // XXX For now ignore aCacheKey. We will need it in the future
     // for correctly dealing with image load requests that are a result
     // of post data.
     if (cache.Get(key, getter_AddRefs(entry)) && entry) {
       // We don't want to kick off another network load. So we ask
       // ValidateEntry to only do validation without creating a new proxy. If
       // it says that the entry isn't valid any more, we'll only use the entry
       // we're getting if the channel is loading from the cache anyways.
       //
       // XXX -- should this be changed? it's pretty much verbatim from the old
       // code, but seems nonsensical.
       if (ValidateEntry(entry, uri, nullptr, nullptr, nullptr, aObserver, aCX,
                         requestFlags, false, nullptr, nullptr, nullptr,
                         imgIRequest::CORS_NONE)) {
         request = entry->GetRequest();
       } else {
         nsCOMPtr<nsICachingChannel> cacheChan(do_QueryInterface(channel));
         bool bUseCacheCopy;
         if (cacheChan)
           cacheChan->IsFromCache(&bUseCacheCopy);
         else
           bUseCacheCopy = false;
         if (!bUseCacheCopy) {
           entry = nullptr;
         } else {
           request = entry->GetRequest();
         }
       }
       if (request && entry) {
         // If this entry has no proxies, its request has no reference to the entry.
         if (entry->HasNoProxies()) {
           LOG_FUNC_WITH_PARAM(GetImgLog(), "imgLoader::LoadImageWithChannel() adding proxyless entry", "uri", key.get());
           NS_ABORT_IF_FALSE(!request->HasCacheEntry(), "Proxyless entry's request has cache entry!");
           request->SetCacheEntry(entry);
           if (mCacheTracker)
             mCacheTracker->MarkUsed(entry);
         }
       }
     }
   }
   nsCOMPtr<nsILoadGroup> loadGroup;
   channel->GetLoadGroup(getter_AddRefs(loadGroup));
   // Filter out any load flags not from nsIRequest
   requestFlags &= nsIRequest::LOAD_REQUESTMASK;
   nsresult rv = NS_OK;
   if (request) {
     // we have this in our cache already.. cancel the current (document) load
     channel->Cancel(NS_ERROR_PARSED_DATA_CACHED); // this should fire an OnStopRequest
     *listener = nullptr; // give them back a null nsIStreamListener
     rv = CreateNewProxyForRequest(request, loadGroup, aObserver,
                                   requestFlags, _retval);
     static_cast<imgRequestProxy*>(*_retval)->NotifyListener();
   } else {
     // Default to doing a principal check because we don't know who
     // started that load and whether their principal ended up being
     // inherited on the channel.
     NewRequestAndEntry(true, this, getter_AddRefs(request), getter_AddRefs(entry));
     // We use originalURI here to fulfil the imgIRequest contract on GetURI.
     nsCOMPtr<nsIURI> originalURI;
     channel->GetOriginalURI(getter_AddRefs(originalURI));
     // No principal specified here, because we're not passed one.
     request->Init(originalURI, uri, firstPartyIsolationURI, channel, channel, entry,
                   aCX, nullptr, imgIRequest::CORS_NONE);
     ProxyListener *pl = new ProxyListener(static_cast<nsIStreamListener *>(request.get()));
     NS_ADDREF(pl);
     *listener = static_cast<nsIStreamListener*>(pl);
     NS_ADDREF(*listener);
     NS_RELEASE(pl);
     bool isIsolated = false;
     nsAutoCString cacheKey = GetCacheKey(firstPartyIsolationURI, originalURI, &isIsolated);
     if (isIsolated) // Try to add the new request into the cache.
       PutIntoCache(cacheKey, entry);
     rv = CreateNewProxyForRequest(request, loadGroup, aObserver,
                                   requestFlags, _retval);
     // Explicitly don't notify our proxy, because we're loading off the
     // network, and necko (or things called from necko, such as
     // imgCacheValidator) are going to call our notifications asynchronously,
     // and we can't make it further asynchronous because observers might rely
     // on imagelib completing its work between the channel's OnStartRequest and
     // OnStopRequest.
   }
   return rv;
 }
 bool imgLoader::SupportImageWithMimeType(const char* aMimeType)
 {
   nsAutoCString mimeType(aMimeType);
   ToLowerCase(mimeType);
   return Image::GetDecoderType(mimeType.get()) != Image::eDecoderType_unknown;
 }
 NS_IMETHODIMP imgLoader::GetMIMETypeFromContent(nsIRequest* aRequest,
                                                 const uint8_t* aContents,
                                                 uint32_t aLength,
                                                 nsACString& aContentType)
 {
   return GetMimeTypeFromContent((const char*)aContents, aLength, aContentType);
 }
 /* static */
 nsresult imgLoader::GetMimeTypeFromContent(const char* aContents, uint32_t aLength, nsACString& aContentType)
 {
   /* Is it a GIF? */
   if (aLength >= 6 && (!nsCRT::strncmp(aContents, "GIF87a", 6) ||
                        !nsCRT::strncmp(aContents, "GIF89a", 6)))
   {
     aContentType.AssignLiteral(IMAGE_GIF);
   }
   /* or a PNG? */
   else if (aLength >= 8 && ((unsigned char)aContents[0]==0x89 &&
                    (unsigned char)aContents[1]==0x50 &&
                    (unsigned char)aContents[2]==0x4E &&
                    (unsigned char)aContents[3]==0x47 &&
                    (unsigned char)aContents[4]==0x0D &&
                    (unsigned char)aContents[5]==0x0A &&
                    (unsigned char)aContents[6]==0x1A &&
                    (unsigned char)aContents[7]==0x0A))
   {
     aContentType.AssignLiteral(IMAGE_PNG);
   }
   /* maybe a JPEG (JFIF)? */
   /* JFIF files start with SOI APP0 but older files can start with SOI DQT
    * so we test for SOI followed by any marker, i.e. FF D8 FF
    * this will also work for SPIFF JPEG files if they appear in the future.
    *
    * (JFIF is 0XFF 0XD8 0XFF 0XE0 <skip 2> 0X4A 0X46 0X49 0X46 0X00)
    */
   else if (aLength >= 3 &&
      ((unsigned char)aContents[0])==0xFF &&
      ((unsigned char)aContents[1])==0xD8 &&
      ((unsigned char)aContents[2])==0xFF)
   {
     aContentType.AssignLiteral(IMAGE_JPEG);
   }
   /* or how about ART? */
   /* ART begins with JG (4A 47). Major version offset 2.
    * Minor version offset 3. Offset 4 must be nullptr.
    */
   else if (aLength >= 5 &&
    ((unsigned char) aContents[0])==0x4a &&
    ((unsigned char) aContents[1])==0x47 &&
    ((unsigned char) aContents[4])==0x00 )
   {
     aContentType.AssignLiteral(IMAGE_ART);
   }
   else if (aLength >= 2 && !nsCRT::strncmp(aContents, "BM", 2)) {
     aContentType.AssignLiteral(IMAGE_BMP);
   }
   // ICOs always begin with a 2-byte 0 followed by a 2-byte 1.
   // CURs begin with 2-byte 0 followed by 2-byte 2.
   else if (aLength >= 4 && (!memcmp(aContents, "\000\000\001\000", 4) ||
                             !memcmp(aContents, "\000\000\002\000", 4))) {
     aContentType.AssignLiteral(IMAGE_ICO);
   }
   else {
     /* none of the above?  I give up */
     return NS_ERROR_NOT_AVAILABLE;
   }
   return NS_OK;
 }
 /**
  * proxy stream listener class used to handle multipart/x-mixed-replace
  */
 #include "nsIRequest.h"
 #include "nsIStreamConverterService.h"
 NS_IMPL_ISUPPORTS(ProxyListener,
                   nsIStreamListener,
                   nsIThreadRetargetableStreamListener,
                   nsIRequestObserver)
 ProxyListener::ProxyListener(nsIStreamListener *dest) :
   mDestListener(dest)
 {
   /* member initializers and constructor code */
 }
 ProxyListener::~ProxyListener()
 {
   /* destructor code */
 }
 /** nsIRequestObserver methods **/
 /* void onStartRequest (in nsIRequest request, in nsISupports ctxt); */
 NS_IMETHODIMP ProxyListener::OnStartRequest(nsIRequest *aRequest, nsISupports *ctxt)
 {
   if (!mDestListener)
     return NS_ERROR_FAILURE;
   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
   if (channel) {
     nsAutoCString contentType;
     nsresult rv = channel->GetContentType(contentType);
     if (!contentType.IsEmpty()) {
      /* If multipart/x-mixed-replace content, we'll insert a MIME decoder
         in the pipeline to handle the content and pass it along to our
         original listener.
       */
       if (NS_LITERAL_CSTRING("multipart/x-mixed-replace").Equals(contentType)) {
         nsCOMPtr<nsIStreamConverterService> convServ(do_GetService("@mozilla.org/streamConverters;1", &rv));
         if (NS_SUCCEEDED(rv)) {
           nsCOMPtr<nsIStreamListener> toListener(mDestListener);
           nsCOMPtr<nsIStreamListener> fromListener;
           rv = convServ->AsyncConvertData("multipart/x-mixed-replace",
                                           "*/*",
                                           toListener,
                                           nullptr,
                                           getter_AddRefs(fromListener));
           if (NS_SUCCEEDED(rv))
             mDestListener = fromListener;
         }
       }
     }
   }
   return mDestListener->OnStartRequest(aRequest, ctxt);
 }
 /* void onStopRequest (in nsIRequest request, in nsISupports ctxt, in nsresult status); */
 NS_IMETHODIMP ProxyListener::OnStopRequest(nsIRequest *aRequest, nsISupports *ctxt, nsresult status)
 {
   if (!mDestListener)
     return NS_ERROR_FAILURE;
   return mDestListener->OnStopRequest(aRequest, ctxt, status);
 }
 /** nsIStreamListener methods **/
 /* void onDataAvailable (in nsIRequest request, in nsISupports ctxt, in nsIInputStream inStr, in unsigned long long sourceOffset, in unsigned long count); */
 NS_IMETHODIMP
 ProxyListener::OnDataAvailable(nsIRequest *aRequest, nsISupports *ctxt,
                                nsIInputStream *inStr, uint64_t sourceOffset,
                                uint32_t count)
 {
   if (!mDestListener)
     return NS_ERROR_FAILURE;
   return mDestListener->OnDataAvailable(aRequest, ctxt, inStr, sourceOffset, count);
 }
 /** nsThreadRetargetableStreamListener methods **/
 NS_IMETHODIMP
 ProxyListener::CheckListenerChain()
 {
   NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!");
   nsresult rv = NS_OK;
   nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener =
     do_QueryInterface(mDestListener, &rv);
   if (retargetableListener) {
     rv = retargetableListener->CheckListenerChain();
   }
   PR_LOG(GetImgLog(), PR_LOG_DEBUG,
          ("ProxyListener::CheckListenerChain %s [this=%p listener=%p rv=%x]",
           (NS_SUCCEEDED(rv) ? "success" : "failure"),
           this, (nsIStreamListener*)mDestListener, rv));
   return rv;
 }
 /**
  * http validate class.  check a channel for a 304
  */
 NS_IMPL_ISUPPORTS(imgCacheValidator, nsIStreamListener, nsIRequestObserver,
                   nsIThreadRetargetableStreamListener,
                   nsIChannelEventSink, nsIInterfaceRequestor,
                   nsIAsyncVerifyRedirectCallback)
 imgCacheValidator::imgCacheValidator(nsProgressNotificationProxy* progress,
                                      imgLoader* loader, imgRequest *request,
                                      void *aContext, bool forcePrincipalCheckForCacheEntry)
  : mProgressProxy(progress),
    mRequest(request),
    mContext(aContext),
    mImgLoader(loader)
 {
   NewRequestAndEntry(forcePrincipalCheckForCacheEntry, loader, getter_AddRefs(mNewRequest),
                      getter_AddRefs(mNewEntry));
 }
 imgCacheValidator::~imgCacheValidator()
 {
   if (mRequest) {
     mRequest->mValidator = nullptr;
   }
 }
 void imgCacheValidator::AddProxy(imgRequestProxy *aProxy)
 {
   // aProxy needs to be in the loadgroup since we're validating from
   // the network.
   aProxy->AddToLoadGroup();
   mProxies.AppendObject(aProxy);
 }
 /** nsIRequestObserver methods **/
 /* void onStartRequest (in nsIRequest request, in nsISupports ctxt); */
 NS_IMETHODIMP imgCacheValidator::OnStartRequest(nsIRequest *aRequest, nsISupports *ctxt)
 {
   // If this request is coming from cache and has the same URI as our
   // imgRequest, the request all our proxies are pointing at is valid, and all
   // we have to do is tell them to notify their listeners.
   nsCOMPtr<nsICachingChannel> cacheChan(do_QueryInterface(aRequest));
   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
   if (cacheChan && channel && !mRequest->CacheChanged(aRequest)) {
     bool isFromCache = false;
     cacheChan->IsFromCache(&isFromCache);
     nsCOMPtr<nsIURI> channelURI;
     bool sameURI = false;
     channel->GetURI(getter_AddRefs(channelURI));
     if (channelURI)
       channelURI->Equals(mRequest->mCurrentURI, &sameURI);
     if (isFromCache && sameURI) {
       uint32_t count = mProxies.Count();
       for (int32_t i = count-1; i>=0; i--) {
         imgRequestProxy *proxy = static_cast<imgRequestProxy *>(mProxies[i]);
         // Proxies waiting on cache validation should be deferring notifications.
         // Undefer them.
         NS_ABORT_IF_FALSE(proxy->NotificationsDeferred(),
                           "Proxies waiting on cache validation should be "
                           "deferring notifications!");
         proxy->SetNotificationsDeferred(false);
         // Notify synchronously, because we're already in OnStartRequest, an
         // asynchronously-called function.
         proxy->SyncNotifyListener();
       }
       // We don't need to load this any more.
       aRequest->Cancel(NS_BINDING_ABORTED);
       mRequest->SetLoadId(mContext);
       mRequest->mValidator = nullptr;
       mRequest = nullptr;
       mNewRequest = nullptr;
       mNewEntry = nullptr;
       return NS_OK;
     }
   }
   // We can't load out of cache. We have to create a whole new request for the
   // data that's coming in off the channel.
   nsCOMPtr<nsIURI> uri;
   {
     nsRefPtr<ImageURL> imageURL;
     mRequest->GetURI(getter_AddRefs(imageURL));
     uri = imageURL->ToIURI();
   }
 #if defined(PR_LOGGING)
   nsAutoCString spec;
   uri->GetSpec(spec);
   LOG_MSG_WITH_PARAM(GetImgLog(), "imgCacheValidator::OnStartRequest creating new request", "uri", spec.get());
 #endif
   int32_t corsmode = mRequest->GetCORSMode();
   nsCOMPtr<nsIPrincipal> loadingPrincipal = mRequest->GetLoadingPrincipal();
   nsCOMPtr<nsIURI> firstPartyIsolationURI = mRequest->mFirstPartyIsolationURI;
   // Doom the old request's cache entry
   mRequest->RemoveFromCache();
   mRequest->mValidator = nullptr;
   mRequest = nullptr;
   // We use originalURI here to fulfil the imgIRequest contract on GetURI.
   nsCOMPtr<nsIURI> originalURI;
   channel->GetOriginalURI(getter_AddRefs(originalURI));
   mNewRequest->Init(originalURI, uri, firstPartyIsolationURI, aRequest, channel,
                     mNewEntry, mContext, loadingPrincipal, corsmode);
   mDestListener = new ProxyListener(mNewRequest);
   // Try to add the new request into the cache. Note that the entry must be in
   // the cache before the proxies' ownership changes, because adding a proxy
   // changes the caching behaviour for imgRequests.
   bool isIsolated = false;
   nsAutoCString key = mImgLoader->GetCacheKey(firstPartyIsolationURI, originalURI,
                                              &isIsolated);
   if (isIsolated)
     mImgLoader->PutIntoCache(key, mNewEntry);
   uint32_t count = mProxies.Count();
   for (int32_t i = count-1; i>=0; i--) {
     imgRequestProxy *proxy = static_cast<imgRequestProxy *>(mProxies[i]);
     proxy->ChangeOwner(mNewRequest);
     // Notify synchronously, because we're already in OnStartRequest, an
     // asynchronously-called function.
     proxy->SetNotificationsDeferred(false);
     proxy->SyncNotifyListener();
   }
   mNewRequest = nullptr;
   mNewEntry = nullptr;
   return mDestListener->OnStartRequest(aRequest, ctxt);
 }
 /* void onStopRequest (in nsIRequest request, in nsISupports ctxt, in nsresult status); */
 NS_IMETHODIMP imgCacheValidator::OnStopRequest(nsIRequest *aRequest, nsISupports *ctxt, nsresult status)
 {
   if (!mDestListener)
     return NS_OK;
   return mDestListener->OnStopRequest(aRequest, ctxt, status);
 }
 /** nsIStreamListener methods **/
 /* void onDataAvailable (in nsIRequest request, in nsISupports ctxt, in nsIInputStream inStr, in unsigned long long sourceOffset, in unsigned long count); */
 NS_IMETHODIMP
 imgCacheValidator::OnDataAvailable(nsIRequest *aRequest, nsISupports *ctxt,
                                    nsIInputStream *inStr,
                                    uint64_t sourceOffset, uint32_t count)
 {
   if (!mDestListener) {
     // XXX see bug 113959
     uint32_t _retval;
     inStr->ReadSegments(NS_DiscardSegment, nullptr, count, &_retval);
     return NS_OK;
   }
   return mDestListener->OnDataAvailable(aRequest, ctxt, inStr, sourceOffset, count);
 }
 /** nsIThreadRetargetableStreamListener methods **/
 NS_IMETHODIMP
 imgCacheValidator::CheckListenerChain()
 {
   NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread!");
   nsresult rv = NS_OK;
   nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener =
     do_QueryInterface(mDestListener, &rv);
   if (retargetableListener) {
     rv = retargetableListener->CheckListenerChain();
   }
   PR_LOG(GetImgLog(), PR_LOG_DEBUG,
          ("[this=%p] imgCacheValidator::CheckListenerChain -- rv %d=%s",
           this, NS_SUCCEEDED(rv) ? "succeeded" : "failed", rv));
   return rv;
 }
 /** nsIInterfaceRequestor methods **/
 NS_IMETHODIMP imgCacheValidator::GetInterface(const nsIID & aIID, void **aResult)
 {
   if (aIID.Equals(NS_GET_IID(nsIChannelEventSink)))
     return QueryInterface(aIID, aResult);
   return mProgressProxy->GetInterface(aIID, aResult);
 }
 // These functions are materially the same as the same functions in imgRequest.
 // We duplicate them because we're verifying whether cache loads are necessary,
 // not unconditionally loading.
 /** nsIChannelEventSink methods **/
 NS_IMETHODIMP imgCacheValidator::AsyncOnChannelRedirect(nsIChannel *oldChannel,
                                                         nsIChannel *newChannel, uint32_t flags,
                                                         nsIAsyncVerifyRedirectCallback *callback)
 {
   // Note all cache information we get from the old channel.
   mNewRequest->SetCacheValidation(mNewEntry, oldChannel);
   // Prepare for callback
   mRedirectCallback = callback;
   mRedirectChannel = newChannel;
   return mProgressProxy->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this);
 }
 NS_IMETHODIMP imgCacheValidator::OnRedirectVerifyCallback(nsresult aResult)
 {
   // If we've already been told to abort, just do so.
   if (NS_FAILED(aResult)) {
       mRedirectCallback->OnRedirectVerifyCallback(aResult);
       mRedirectCallback = nullptr;
       mRedirectChannel = nullptr;
       return NS_OK;
   }
   // make sure we have a protocol that returns data rather than opens
   // an external application, e.g. mailto:
   nsCOMPtr<nsIURI> uri;
   mRedirectChannel->GetURI(getter_AddRefs(uri));
   bool doesNotReturnData = false;
   NS_URIChainHasFlags(uri, nsIProtocolHandler::URI_DOES_NOT_RETURN_DATA,
                       &doesNotReturnData);
   nsresult result = NS_OK;
   if (doesNotReturnData) {
     result = NS_ERROR_ABORT;
   }
   mRedirectCallback->OnRedirectVerifyCallback(result);
   mRedirectCallback = nullptr;
   mRedirectChannel = nullptr;
   return NS_OK;
 }

The Tor Browser / annotate

image/src/imgLoader.cpp@ac0c01689b40 (annotated)

image/src/imgLoader.cpp