image/ImageCacheKey.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "ImageCacheKey.h"
   7
   8 #include "mozilla/Move.h"
   9 #include "File.h"
  10 #include "ImageURL.h"
  11 #include "nsHostObjectProtocolHandler.h"
  12 #include "nsString.h"
  13 #include "mozilla/dom/workers/ServiceWorkerManager.h"
  14 #include "nsIDOMDocument.h"
  15 #include "nsIDocument.h"
  16 #include "nsPrintfCString.h"
  17
  18 namespace mozilla {
  19
  20 using namespace dom;
  21
  22 namespace image {
  23
  24 bool
  25 URISchemeIs(ImageURL* aURI, const char* aScheme)
  26 {
  27   bool schemeMatches = false;
  28   if (NS_WARN_IF(NS_FAILED(aURI->SchemeIs(aScheme, &schemeMatches)))) {
  29     return false;
  30   }
  31   return schemeMatches;
  32 }
  33
  34 static Maybe<uint64_t>
  35 BlobSerial(ImageURL* aURI)
  36 {
  37   nsAutoCString spec;
  38   aURI->GetSpec(spec);
  39
  40   RefPtr<BlobImpl> blob;
  41   if (NS_SUCCEEDED(NS_GetBlobForBlobURISpec(spec, getter_AddRefs(blob))) &&
  42       blob) {
  43     return Some(blob->GetSerialNumber());
  44   }
  45
  46   return Nothing();
  47 }
  48
  49 ImageCacheKey::ImageCacheKey(nsIURI* aURI, nsIDOMDocument* aDocument)
  50   : mURI(new ImageURL(aURI))
  51   , mControlledDocument(GetControlledDocumentToken(aDocument))
  52   , mIsChrome(URISchemeIs(mURI, "chrome"))
  53 {
  54   MOZ_ASSERT(NS_IsMainThread());
  55
  56   if (URISchemeIs(mURI, "blob")) {
  57     mBlobSerial = BlobSerial(mURI);
  58   }
  59
  60   mHash = ComputeHash(mURI, mBlobSerial, mControlledDocument);
  61 }
  62
  63 ImageCacheKey::ImageCacheKey(ImageURL* aURI, nsIDOMDocument* aDocument)
  64   : mURI(aURI)
  65   , mControlledDocument(GetControlledDocumentToken(aDocument))
  66   , mIsChrome(URISchemeIs(mURI, "chrome"))
  67 {
  68   MOZ_ASSERT(aURI);
  69
  70   if (URISchemeIs(mURI, "blob")) {
  71     mBlobSerial = BlobSerial(mURI);
  72   }
  73
  74   mHash = ComputeHash(mURI, mBlobSerial, mControlledDocument);
  75 }
  76
  77 ImageCacheKey::ImageCacheKey(const ImageCacheKey& aOther)
  78   : mURI(aOther.mURI)
  79   , mBlobSerial(aOther.mBlobSerial)
  80   , mControlledDocument(aOther.mControlledDocument)
  81   , mHash(aOther.mHash)
  82   , mIsChrome(aOther.mIsChrome)
  83 { }
  84
  85 ImageCacheKey::ImageCacheKey(ImageCacheKey&& aOther)
  86   : mURI(Move(aOther.mURI))
  87   , mBlobSerial(Move(aOther.mBlobSerial))
  88   , mControlledDocument(aOther.mControlledDocument)
  89   , mHash(aOther.mHash)
  90   , mIsChrome(aOther.mIsChrome)
  91 { }
  92
  93 bool
  94 ImageCacheKey::operator==(const ImageCacheKey& aOther) const
  95 {
  96   // Don't share the image cache between a controlled document and anything else.
  97   if (mControlledDocument != aOther.mControlledDocument) {
  98     return false;
  99   }
 100   if (mBlobSerial || aOther.mBlobSerial) {
 101     // If at least one of us has a blob serial, just compare the blob serial and
 102     // the ref portion of the URIs.
 103     return mBlobSerial == aOther.mBlobSerial &&
 104            mURI->HasSameRef(*aOther.mURI);
 105   }
 106
 107   // For non-blob URIs, compare the URIs.
 108   return *mURI == *aOther.mURI;
 109 }
 110
 111 const char*
 112 ImageCacheKey::Spec() const
 113 {
 114   return mURI->Spec();
 115 }
 116
 117 /* static */ uint32_t
 118 ImageCacheKey::ComputeHash(ImageURL* aURI,
 119                            const Maybe<uint64_t>& aBlobSerial,
 120                            void* aControlledDocument)
 121 {
 122   // Since we frequently call Hash() several times in a row on the same
 123   // ImageCacheKey, as an optimization we compute our hash once and store it.
 124
 125   nsPrintfCString ptr("%p", aControlledDocument);
 126   if (aBlobSerial) {
 127     // For blob URIs, we hash the serial number of the underlying blob, so that
 128     // different blob URIs which point to the same blob share a cache entry. We
 129     // also include the ref portion of the URI to support -moz-samplesize, which
 130     // requires us to create different Image objects even if the source data is
 131     // the same.
 132     nsAutoCString ref;
 133     aURI->GetRef(ref);
 134     return HashGeneric(*aBlobSerial, HashString(ref + ptr));
 135   }
 136
 137   // For non-blob URIs, we hash the URI spec.
 138   nsAutoCString spec;
 139   aURI->GetSpec(spec);
 140   return HashString(spec + ptr);
 141 }
 142
 143 /* static */ void*
 144 ImageCacheKey::GetControlledDocumentToken(nsIDOMDocument* aDocument)
 145 {
 146   // For non-controlled documents, we just return null.  For controlled
 147   // documents, we cast the pointer into a void* to avoid dereferencing
 148   // it (since we only use it for comparisons), and return it.
 149   void* pointer = nullptr;
 150   using dom::workers::ServiceWorkerManager;
 151   RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
 152   nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDocument);
 153   if (doc && swm) {
 154     ErrorResult rv;
 155     if (swm->IsControlled(doc, rv)) {
 156       pointer = doc;
 157     }
 158   }
 159   return pointer;
 160 }
 161
 162 } // namespace image
 163 } // namespace mozilla