dom/canvas/CanvasImageCache.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 "CanvasImageCache.h"
   7 #include "nsIImageLoadingContent.h"
   8 #include "nsExpirationTracker.h"
   9 #include "imgIRequest.h"
  10 #include "mozilla/dom/Element.h"
  11 #include "nsTHashtable.h"
  12 #include "mozilla/dom/HTMLCanvasElement.h"
  13 #include "nsContentUtils.h"
  14 #include "mozilla/Preferences.h"
  15 #include "mozilla/StaticPrefs_canvas.h"
  16 #include "mozilla/UniquePtr.h"
  17 #include "mozilla/gfx/2D.h"
  18 #include "gfx2DGlue.h"
  19
  20 namespace mozilla {
  21
  22 using namespace dom;
  23 using namespace gfx;
  24
  25 /**
  26  * Used for images specific to this one canvas. Required
  27  * due to CORS security.
  28  */
  29 struct ImageCacheKey {
  30   ImageCacheKey(imgIContainer* aImage, HTMLCanvasElement* aCanvas)
  31       : mImage(aImage), mCanvas(aCanvas) {}
  32   nsCOMPtr<imgIContainer> mImage;
  33   HTMLCanvasElement* mCanvas;
  34 };
  35
  36 /**
  37  * Cache data needs to be separate from the entry
  38  * for nsExpirationTracker.
  39  */
  40 struct ImageCacheEntryData {
  41   ImageCacheEntryData(const ImageCacheEntryData& aOther)
  42       : mImage(aOther.mImage),
  43         mCanvas(aOther.mCanvas),
  44         mSourceSurface(aOther.mSourceSurface),
  45         mSize(aOther.mSize),
  46         mIntrinsicSize(aOther.mIntrinsicSize) {}
  47   explicit ImageCacheEntryData(const ImageCacheKey& aKey)
  48       : mImage(aKey.mImage), mCanvas(aKey.mCanvas) {}
  49
  50   nsExpirationState* GetExpirationState() { return &mState; }
  51   size_t SizeInBytes() { return mSize.width * mSize.height * 4; }
  52
  53   // Key
  54   nsCOMPtr<imgIContainer> mImage;
  55   HTMLCanvasElement* mCanvas;
  56   // Value
  57   RefPtr<SourceSurface> mSourceSurface;
  58   IntSize mSize;
  59   IntSize mIntrinsicSize;
  60   nsExpirationState mState;
  61 };
  62
  63 class ImageCacheEntry : public PLDHashEntryHdr {
  64  public:
  65   typedef ImageCacheKey KeyType;
  66   typedef const ImageCacheKey* KeyTypePointer;
  67
  68   explicit ImageCacheEntry(const KeyType* aKey)
  69       : mData(new ImageCacheEntryData(*aKey)) {}
  70   ImageCacheEntry(const ImageCacheEntry& toCopy)
  71       : mData(new ImageCacheEntryData(*toCopy.mData)) {}
  72   ~ImageCacheEntry() = default;
  73
  74   bool KeyEquals(KeyTypePointer key) const {
  75     return mData->mImage == key->mImage && mData->mCanvas == key->mCanvas;
  76   }
  77
  78   static KeyTypePointer KeyToPointer(KeyType& key) { return &key; }
  79   static PLDHashNumber HashKey(KeyTypePointer key) {
  80     return HashGeneric(key->mImage.get(), key->mCanvas);
  81   }
  82   enum { ALLOW_MEMMOVE = true };
  83
  84   UniquePtr<ImageCacheEntryData> mData;
  85 };
  86
  87 /**
  88  * Used for all images across all canvases.
  89  */
  90 struct AllCanvasImageCacheKey {
  91   explicit AllCanvasImageCacheKey(imgIContainer* aImage) : mImage(aImage) {}
  92
  93   nsCOMPtr<imgIContainer> mImage;
  94 };
  95
  96 class AllCanvasImageCacheEntry : public PLDHashEntryHdr {
  97  public:
  98   typedef AllCanvasImageCacheKey KeyType;
  99   typedef const AllCanvasImageCacheKey* KeyTypePointer;
 100
 101   explicit AllCanvasImageCacheEntry(const KeyType* aKey)
 102       : mImage(aKey->mImage) {}
 103
 104   AllCanvasImageCacheEntry(const AllCanvasImageCacheEntry& toCopy)
 105       : mImage(toCopy.mImage), mSourceSurface(toCopy.mSourceSurface) {}
 106
 107   ~AllCanvasImageCacheEntry() = default;
 108
 109   bool KeyEquals(KeyTypePointer key) const { return mImage == key->mImage; }
 110
 111   static KeyTypePointer KeyToPointer(KeyType& key) { return &key; }
 112   static PLDHashNumber HashKey(KeyTypePointer key) {
 113     return HashGeneric(key->mImage.get());
 114   }
 115   enum { ALLOW_MEMMOVE = true };
 116
 117   nsCOMPtr<imgIContainer> mImage;
 118   RefPtr<SourceSurface> mSourceSurface;
 119 };
 120
 121 class ImageCacheObserver;
 122
 123 class ImageCache final : public nsExpirationTracker<ImageCacheEntryData, 4> {
 124  public:
 125   // We use 3 generations of 1 second each to get a 2-3 seconds timeout.
 126   enum { GENERATION_MS = 1000 };
 127   ImageCache();
 128   ~ImageCache();
 129
 130   virtual void NotifyExpired(ImageCacheEntryData* aObject) override {
 131     mTotal -= aObject->SizeInBytes();
 132     RemoveObject(aObject);
 133
 134     // Remove from the all canvas cache entry first since nsExpirationTracker
 135     // will delete aObject.
 136     mAllCanvasCache.RemoveEntry(AllCanvasImageCacheKey(aObject->mImage));
 137
 138     // Deleting the entry will delete aObject since the entry owns aObject.
 139     mCache.RemoveEntry(ImageCacheKey(aObject->mImage, aObject->mCanvas));
 140   }
 141
 142   nsTHashtable<ImageCacheEntry> mCache;
 143   nsTHashtable<AllCanvasImageCacheEntry> mAllCanvasCache;
 144   size_t mTotal;
 145   RefPtr<ImageCacheObserver> mImageCacheObserver;
 146 };
 147
 148 static ImageCache* gImageCache = nullptr;
 149
 150 // Listen memory-pressure event for image cache purge.
 151 class ImageCacheObserver final : public nsIObserver {
 152  public:
 153   NS_DECL_ISUPPORTS
 154
 155   explicit ImageCacheObserver(ImageCache* aImageCache)
 156       : mImageCache(aImageCache) {
 157     RegisterObserverEvents();
 158   }
 159
 160   void Destroy() {
 161     UnregisterObserverEvents();
 162     mImageCache = nullptr;
 163   }
 164
 165   NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
 166                      const char16_t* aSomeData) override {
 167     if (!mImageCache || (strcmp(aTopic, "memory-pressure") != 0 &&
 168                          strcmp(aTopic, "canvas-device-reset") != 0)) {
 169       return NS_OK;
 170     }
 171
 172     mImageCache->AgeAllGenerations();
 173     return NS_OK;
 174   }
 175
 176  private:
 177   virtual ~ImageCacheObserver() = default;
 178
 179   void RegisterObserverEvents() {
 180     nsCOMPtr<nsIObserverService> observerService =
 181         mozilla::services::GetObserverService();
 182
 183     MOZ_ASSERT(observerService);
 184
 185     if (observerService) {
 186       observerService->AddObserver(this, "memory-pressure", false);
 187       observerService->AddObserver(this, "canvas-device-reset", false);
 188     }
 189   }
 190
 191   void UnregisterObserverEvents() {
 192     nsCOMPtr<nsIObserverService> observerService =
 193         mozilla::services::GetObserverService();
 194
 195     // Do not assert on observerService here. This might be triggered by
 196     // the cycle collector at a late enough time, that XPCOM services are
 197     // no longer available. See bug 1029504.
 198     if (observerService) {
 199       observerService->RemoveObserver(this, "memory-pressure");
 200       observerService->RemoveObserver(this, "canvas-device-reset");
 201     }
 202   }
 203
 204   ImageCache* mImageCache;
 205 };
 206
 207 NS_IMPL_ISUPPORTS(ImageCacheObserver, nsIObserver)
 208
 209 class CanvasImageCacheShutdownObserver final : public nsIObserver {
 210   ~CanvasImageCacheShutdownObserver() = default;
 211
 212  public:
 213   NS_DECL_ISUPPORTS
 214   NS_DECL_NSIOBSERVER
 215 };
 216
 217 ImageCache::ImageCache()
 218     : nsExpirationTracker<ImageCacheEntryData, 4>(GENERATION_MS, "ImageCache"),
 219       mTotal(0) {
 220   mImageCacheObserver = new ImageCacheObserver(this);
 221   MOZ_RELEASE_ASSERT(mImageCacheObserver,
 222                      "GFX: Can't alloc ImageCacheObserver");
 223 }
 224
 225 ImageCache::~ImageCache() {
 226   AgeAllGenerations();
 227   mImageCacheObserver->Destroy();
 228 }
 229
 230 static already_AddRefed<imgIContainer> GetImageContainer(dom::Element* aImage) {
 231   nsCOMPtr<imgIRequest> request;
 232   nsCOMPtr<nsIImageLoadingContent> ilc = do_QueryInterface(aImage);
 233   if (!ilc) {
 234     return nullptr;
 235   }
 236
 237   ilc->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
 238                   getter_AddRefs(request));
 239   if (!request) {
 240     return nullptr;
 241   }
 242
 243   nsCOMPtr<imgIContainer> imgContainer;
 244   request->GetImage(getter_AddRefs(imgContainer));
 245   if (!imgContainer) {
 246     return nullptr;
 247   }
 248
 249   return imgContainer.forget();
 250 }
 251
 252 void CanvasImageCache::NotifyDrawImage(Element* aImage,
 253                                        HTMLCanvasElement* aCanvas,
 254                                        SourceSurface* aSource,
 255                                        const IntSize& aSize,
 256                                        const IntSize& aIntrinsicSize) {
 257   if (!gImageCache) {
 258     gImageCache = new ImageCache();
 259     nsContentUtils::RegisterShutdownObserver(
 260         new CanvasImageCacheShutdownObserver());
 261   }
 262
 263   nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
 264   if (!imgContainer) {
 265     return;
 266   }
 267
 268   AllCanvasImageCacheKey allCanvasCacheKey(imgContainer);
 269   ImageCacheKey canvasCacheKey(imgContainer, aCanvas);
 270   ImageCacheEntry* entry = gImageCache->mCache.PutEntry(canvasCacheKey);
 271
 272   if (entry) {
 273     if (entry->mData->mSourceSurface) {
 274       // We are overwriting an existing entry.
 275       gImageCache->mTotal -= entry->mData->SizeInBytes();
 276       gImageCache->RemoveObject(entry->mData.get());
 277       gImageCache->mAllCanvasCache.RemoveEntry(allCanvasCacheKey);
 278     }
 279
 280     gImageCache->AddObject(entry->mData.get());
 281     entry->mData->mSourceSurface = aSource;
 282     entry->mData->mSize = aSize;
 283     entry->mData->mIntrinsicSize = aIntrinsicSize;
 284     gImageCache->mTotal += entry->mData->SizeInBytes();
 285
 286     AllCanvasImageCacheEntry* allEntry =
 287         gImageCache->mAllCanvasCache.PutEntry(allCanvasCacheKey);
 288     if (allEntry) {
 289       allEntry->mSourceSurface = aSource;
 290     }
 291   }
 292
 293   if (!StaticPrefs::canvas_image_cache_limit()) {
 294     return;
 295   }
 296
 297   // Expire the image cache early if its larger than we want it to be.
 298   while (gImageCache->mTotal >
 299          size_t(StaticPrefs::canvas_image_cache_limit())) {
 300     gImageCache->AgeOneGeneration();
 301   }
 302 }
 303
 304 SourceSurface* CanvasImageCache::LookupAllCanvas(Element* aImage) {
 305   if (!gImageCache) {
 306     return nullptr;
 307   }
 308
 309   nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
 310   if (!imgContainer) {
 311     return nullptr;
 312   }
 313
 314   AllCanvasImageCacheEntry* entry = gImageCache->mAllCanvasCache.GetEntry(
 315       AllCanvasImageCacheKey(imgContainer));
 316   if (!entry) {
 317     return nullptr;
 318   }
 319
 320   return entry->mSourceSurface;
 321 }
 322
 323 SourceSurface* CanvasImageCache::LookupCanvas(Element* aImage,
 324                                               HTMLCanvasElement* aCanvas,
 325                                               IntSize* aSizeOut,
 326                                               IntSize* aIntrinsicSizeOut) {
 327   if (!gImageCache) {
 328     return nullptr;
 329   }
 330
 331   nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
 332   if (!imgContainer) {
 333     return nullptr;
 334   }
 335
 336   ImageCacheEntry* entry =
 337       gImageCache->mCache.GetEntry(ImageCacheKey(imgContainer, aCanvas));
 338   if (!entry) {
 339     return nullptr;
 340   }
 341
 342   MOZ_ASSERT(aSizeOut);
 343
 344   gImageCache->MarkUsed(entry->mData.get());
 345   *aSizeOut = entry->mData->mSize;
 346   *aIntrinsicSizeOut = entry->mData->mIntrinsicSize;
 347   return entry->mData->mSourceSurface;
 348 }
 349
 350 NS_IMPL_ISUPPORTS(CanvasImageCacheShutdownObserver, nsIObserver)
 351
 352 NS_IMETHODIMP
 353 CanvasImageCacheShutdownObserver::Observe(nsISupports* aSubject,
 354                                           const char* aTopic,
 355                                           const char16_t* aData) {
 356   if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
 357     delete gImageCache;
 358     gImageCache = nullptr;
 359
 360     nsContentUtils::UnregisterShutdownObserver(this);
 361   }
 362
 363   return NS_OK;
 364 }
 365
 366 }  // namespace mozilla