/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "CanvasImageCache.h" #include "nsAutoPtr.h" #include "nsIImageLoadingContent.h" #include "nsExpirationTracker.h" #include "imgIContainer.h" #include "imgIRequest.h" #include "mozilla/dom/Element.h" #include "nsTHashtable.h" #include "mozilla/dom/HTMLCanvasElement.h" #include "nsContentUtils.h" #include "mozilla/Preferences.h" #include "mozilla/gfx/2D.h" #include "gfx2DGlue.h" namespace mozilla { using namespace dom; using namespace gfx; /** * Used for images specific to this one canvas. Required * due to CORS security. */ struct ImageCacheKey { ImageCacheKey(imgIContainer* aImage, HTMLCanvasElement* aCanvas, bool aIsAccelerated) : mImage(aImage) , mCanvas(aCanvas) , mIsAccelerated(aIsAccelerated) {} nsCOMPtr<imgIContainer> mImage; HTMLCanvasElement* mCanvas; bool mIsAccelerated; }; /** * Cache data needs to be separate from the entry * for nsExpirationTracker. */ struct ImageCacheEntryData { ImageCacheEntryData(const ImageCacheEntryData& aOther) : mImage(aOther.mImage) , mCanvas(aOther.mCanvas) , mIsAccelerated(aOther.mIsAccelerated) , mSourceSurface(aOther.mSourceSurface) , mSize(aOther.mSize) {} explicit ImageCacheEntryData(const ImageCacheKey& aKey) : mImage(aKey.mImage) , mCanvas(aKey.mCanvas) , mIsAccelerated(aKey.mIsAccelerated) {} nsExpirationState* GetExpirationState() { return &mState; } size_t SizeInBytes() { return mSize.width * mSize.height * 4; } // Key nsCOMPtr<imgIContainer> mImage; HTMLCanvasElement* mCanvas; bool mIsAccelerated; // Value RefPtr<SourceSurface> mSourceSurface; IntSize mSize; nsExpirationState mState; }; class ImageCacheEntry : public PLDHashEntryHdr { public: typedef ImageCacheKey KeyType; typedef const ImageCacheKey* KeyTypePointer; explicit ImageCacheEntry(const KeyType* aKey) : mData(new ImageCacheEntryData(*aKey)) {} ImageCacheEntry(const ImageCacheEntry& toCopy) : mData(new ImageCacheEntryData(*toCopy.mData)) {} ~ImageCacheEntry() {} bool KeyEquals(KeyTypePointer key) const { return mData->mImage == key->mImage && mData->mCanvas == key->mCanvas && mData->mIsAccelerated == key->mIsAccelerated; } static KeyTypePointer KeyToPointer(KeyType& key) { return &key; } static PLDHashNumber HashKey(KeyTypePointer key) { return HashGeneric(key->mImage.get(), key->mCanvas, key->mIsAccelerated); } enum { ALLOW_MEMMOVE = true }; nsAutoPtr<ImageCacheEntryData> mData; }; /** * Used for all images across all canvases. */ struct AllCanvasImageCacheKey { AllCanvasImageCacheKey(imgIContainer* aImage, bool aIsAccelerated) : mImage(aImage) , mIsAccelerated(aIsAccelerated) {} nsCOMPtr<imgIContainer> mImage; bool mIsAccelerated; }; class AllCanvasImageCacheEntry : public PLDHashEntryHdr { public: typedef AllCanvasImageCacheKey KeyType; typedef const AllCanvasImageCacheKey* KeyTypePointer; explicit AllCanvasImageCacheEntry(const KeyType* aKey) : mImage(aKey->mImage) , mIsAccelerated(aKey->mIsAccelerated) {} AllCanvasImageCacheEntry(const AllCanvasImageCacheEntry &toCopy) : mImage(toCopy.mImage) , mIsAccelerated(toCopy.mIsAccelerated) , mSourceSurface(toCopy.mSourceSurface) {} ~AllCanvasImageCacheEntry() {} bool KeyEquals(KeyTypePointer key) const { return mImage == key->mImage && mIsAccelerated == key->mIsAccelerated; } static KeyTypePointer KeyToPointer(KeyType& key) { return &key; } static PLDHashNumber HashKey(KeyTypePointer key) { return HashGeneric(key->mImage.get(), key->mIsAccelerated); } enum { ALLOW_MEMMOVE = true }; nsCOMPtr<imgIContainer> mImage; bool mIsAccelerated; RefPtr<SourceSurface> mSourceSurface; }; static bool sPrefsInitialized = false; static int32_t sCanvasImageCacheLimit = 0; class ImageCacheObserver; class ImageCache final : public nsExpirationTracker<ImageCacheEntryData,4> { public: // We use 3 generations of 1 second each to get a 2-3 seconds timeout. enum { GENERATION_MS = 1000 }; ImageCache(); ~ImageCache(); virtual void NotifyExpired(ImageCacheEntryData* aObject) { mTotal -= aObject->SizeInBytes(); RemoveObject(aObject); // Remove from the all canvas cache entry first since nsExpirationTracker // will delete aObject. mAllCanvasCache.RemoveEntry(AllCanvasImageCacheKey(aObject->mImage, aObject->mIsAccelerated)); // Deleting the entry will delete aObject since the entry owns aObject. mCache.RemoveEntry(ImageCacheKey(aObject->mImage, aObject->mCanvas, aObject->mIsAccelerated)); } nsTHashtable<ImageCacheEntry> mCache; nsTHashtable<AllCanvasImageCacheEntry> mAllCanvasCache; size_t mTotal; RefPtr<ImageCacheObserver> mImageCacheObserver; }; static ImageCache* gImageCache = nullptr; // Listen memory-pressure event for image cache purge. class ImageCacheObserver final : public nsIObserver { public: NS_DECL_ISUPPORTS explicit ImageCacheObserver(ImageCache* aImageCache) : mImageCache(aImageCache) { RegisterMemoryPressureEvent(); } void Destroy() { UnregisterMemoryPressureEvent(); mImageCache = nullptr; } NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aSomeData) override { if (!mImageCache || strcmp(aTopic, "memory-pressure")) { return NS_OK; } mImageCache->AgeAllGenerations(); return NS_OK; } private: virtual ~ImageCacheObserver() { } void RegisterMemoryPressureEvent() { nsCOMPtr<nsIObserverService> observerService = mozilla::services::GetObserverService(); MOZ_ASSERT(observerService); if (observerService) { observerService->AddObserver(this, "memory-pressure", false); } } void UnregisterMemoryPressureEvent() { nsCOMPtr<nsIObserverService> observerService = mozilla::services::GetObserverService(); // Do not assert on observerService here. This might be triggered by // the cycle collector at a late enough time, that XPCOM services are // no longer available. See bug 1029504. if (observerService) { observerService->RemoveObserver(this, "memory-pressure"); } } ImageCache* mImageCache; }; NS_IMPL_ISUPPORTS(ImageCacheObserver, nsIObserver) class CanvasImageCacheShutdownObserver final : public nsIObserver { ~CanvasImageCacheShutdownObserver() {} public: NS_DECL_ISUPPORTS NS_DECL_NSIOBSERVER }; ImageCache::ImageCache() : nsExpirationTracker<ImageCacheEntryData,4>(GENERATION_MS, "ImageCache") , mTotal(0) { if (!sPrefsInitialized) { sPrefsInitialized = true; Preferences::AddIntVarCache(&sCanvasImageCacheLimit, "canvas.image.cache.limit", 0); } mImageCacheObserver = new ImageCacheObserver(this); MOZ_RELEASE_ASSERT(mImageCacheObserver, "GFX: Can't alloc ImageCacheObserver"); } ImageCache::~ImageCache() { AgeAllGenerations(); mImageCacheObserver->Destroy(); } static already_AddRefed<imgIContainer> GetImageContainer(dom::Element* aImage) { nsCOMPtr<imgIRequest> request; nsCOMPtr<nsIImageLoadingContent> ilc = do_QueryInterface(aImage); if (!ilc) { return nullptr; } ilc->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST, getter_AddRefs(request)); if (!request) { return nullptr; } nsCOMPtr<imgIContainer> imgContainer; request->GetImage(getter_AddRefs(imgContainer)); if (!imgContainer) { return nullptr; } return imgContainer.forget(); } void CanvasImageCache::NotifyDrawImage(Element* aImage, HTMLCanvasElement* aCanvas, SourceSurface* aSource, const IntSize& aSize, bool aIsAccelerated) { if (!gImageCache) { gImageCache = new ImageCache(); nsContentUtils::RegisterShutdownObserver(new CanvasImageCacheShutdownObserver()); } nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage); if (!imgContainer) { return; } AllCanvasImageCacheKey allCanvasCacheKey(imgContainer, aIsAccelerated); ImageCacheKey canvasCacheKey(imgContainer, aCanvas, aIsAccelerated); ImageCacheEntry* entry = gImageCache->mCache.PutEntry(canvasCacheKey); if (entry) { if (entry->mData->mSourceSurface) { // We are overwriting an existing entry. gImageCache->mTotal -= entry->mData->SizeInBytes(); gImageCache->RemoveObject(entry->mData); gImageCache->mAllCanvasCache.RemoveEntry(allCanvasCacheKey); } gImageCache->AddObject(entry->mData); entry->mData->mSourceSurface = aSource; entry->mData->mSize = aSize; gImageCache->mTotal += entry->mData->SizeInBytes(); AllCanvasImageCacheEntry* allEntry = gImageCache->mAllCanvasCache.PutEntry(allCanvasCacheKey); if (allEntry) { allEntry->mSourceSurface = aSource; } } if (!sCanvasImageCacheLimit) return; // Expire the image cache early if its larger than we want it to be. while (gImageCache->mTotal > size_t(sCanvasImageCacheLimit)) gImageCache->AgeOneGeneration(); } SourceSurface* CanvasImageCache::LookupAllCanvas(Element* aImage, bool aIsAccelerated) { if (!gImageCache) { return nullptr; } nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage); if (!imgContainer) { return nullptr; } AllCanvasImageCacheEntry* entry = gImageCache->mAllCanvasCache.GetEntry(AllCanvasImageCacheKey(imgContainer, aIsAccelerated)); if (!entry) { return nullptr; } return entry->mSourceSurface; } SourceSurface* CanvasImageCache::LookupCanvas(Element* aImage, HTMLCanvasElement* aCanvas, IntSize* aSizeOut, bool aIsAccelerated) { if (!gImageCache) { return nullptr; } nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage); if (!imgContainer) { return nullptr; } ImageCacheEntry* entry = gImageCache->mCache.GetEntry(ImageCacheKey(imgContainer, aCanvas, aIsAccelerated)); if (!entry) { return nullptr; } MOZ_ASSERT(aSizeOut); gImageCache->MarkUsed(entry->mData); *aSizeOut = entry->mData->mSize; return entry->mData->mSourceSurface; } NS_IMPL_ISUPPORTS(CanvasImageCacheShutdownObserver, nsIObserver) NS_IMETHODIMP CanvasImageCacheShutdownObserver::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) { if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) { delete gImageCache; gImageCache = nullptr; nsContentUtils::UnregisterShutdownObserver(this); } return NS_OK; } } // namespace mozilla