summaryrefslogtreecommitdiffstats
path: root/dom/canvas/CanvasImageCache.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
commit0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch)
treea31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /dom/canvas/CanvasImageCache.cpp
parentInitial commit. (diff)
downloadfirefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.tar.xz
firefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.zip
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--dom/canvas/CanvasImageCache.cpp397
1 files changed, 397 insertions, 0 deletions
diff --git a/dom/canvas/CanvasImageCache.cpp b/dom/canvas/CanvasImageCache.cpp
new file mode 100644
index 0000000000..96a1505a40
--- /dev/null
+++ b/dom/canvas/CanvasImageCache.cpp
@@ -0,0 +1,397 @@
+/* -*- 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 "nsIImageLoadingContent.h"
+#include "nsExpirationTracker.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/StaticPrefs_canvas.h"
+#include "mozilla/UniquePtr.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,
+ BackendType aBackendType)
+ : mImage(aImage), mCanvas(aCanvas), mBackendType(aBackendType) {}
+ nsCOMPtr<imgIContainer> mImage;
+ HTMLCanvasElement* mCanvas;
+ BackendType mBackendType;
+};
+
+/**
+ * Cache data needs to be separate from the entry
+ * for nsExpirationTracker.
+ */
+struct ImageCacheEntryData {
+ ImageCacheEntryData(const ImageCacheEntryData& aOther)
+ : mImage(aOther.mImage),
+ mCanvas(aOther.mCanvas),
+ mBackendType(aOther.mBackendType),
+ mSourceSurface(aOther.mSourceSurface),
+ mSize(aOther.mSize),
+ mIntrinsicSize(aOther.mIntrinsicSize) {}
+ explicit ImageCacheEntryData(const ImageCacheKey& aKey)
+ : mImage(aKey.mImage),
+ mCanvas(aKey.mCanvas),
+ mBackendType(aKey.mBackendType) {}
+
+ nsExpirationState* GetExpirationState() { return &mState; }
+ size_t SizeInBytes() { return mSize.width * mSize.height * 4; }
+
+ // Key
+ nsCOMPtr<imgIContainer> mImage;
+ HTMLCanvasElement* mCanvas;
+ BackendType mBackendType;
+ // Value
+ RefPtr<SourceSurface> mSourceSurface;
+ IntSize mSize;
+ IntSize mIntrinsicSize;
+ nsExpirationState mState;
+};
+
+class ImageCacheEntry : public PLDHashEntryHdr {
+ public:
+ using KeyType = ImageCacheKey;
+ using KeyTypePointer = const ImageCacheKey*;
+
+ explicit ImageCacheEntry(const KeyType* aKey)
+ : mData(new ImageCacheEntryData(*aKey)) {}
+ ImageCacheEntry(const ImageCacheEntry& toCopy)
+ : mData(new ImageCacheEntryData(*toCopy.mData)) {}
+ ~ImageCacheEntry() = default;
+
+ bool KeyEquals(KeyTypePointer key) const {
+ return mData->mImage == key->mImage && mData->mCanvas == key->mCanvas &&
+ mData->mBackendType == key->mBackendType;
+ }
+
+ static KeyTypePointer KeyToPointer(KeyType& key) { return &key; }
+ static PLDHashNumber HashKey(KeyTypePointer key) {
+ return HashGeneric(key->mImage.get(), key->mCanvas, key->mBackendType);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ UniquePtr<ImageCacheEntryData> mData;
+};
+
+/**
+ * Used for all images across all canvases.
+ */
+struct AllCanvasImageCacheKey {
+ explicit AllCanvasImageCacheKey(imgIContainer* aImage,
+ BackendType aBackendType)
+ : mImage(aImage), mBackendType(aBackendType) {}
+
+ nsCOMPtr<imgIContainer> mImage;
+ BackendType mBackendType;
+};
+
+class AllCanvasImageCacheEntry : public PLDHashEntryHdr {
+ public:
+ using KeyType = AllCanvasImageCacheKey;
+ using KeyTypePointer = const AllCanvasImageCacheKey*;
+
+ explicit AllCanvasImageCacheEntry(const KeyType* aKey)
+ : mImage(aKey->mImage), mBackendType(aKey->mBackendType) {}
+
+ AllCanvasImageCacheEntry(const AllCanvasImageCacheEntry& toCopy)
+ : mImage(toCopy.mImage),
+ mSourceSurface(toCopy.mSourceSurface),
+ mBackendType(toCopy.mBackendType) {}
+
+ ~AllCanvasImageCacheEntry() = default;
+
+ bool KeyEquals(KeyTypePointer key) const {
+ return mImage == key->mImage && mBackendType == key->mBackendType;
+ }
+
+ static KeyTypePointer KeyToPointer(KeyType& key) { return &key; }
+ static PLDHashNumber HashKey(KeyTypePointer key) {
+ return HashGeneric(key->mImage.get(), key->mBackendType);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ nsCOMPtr<imgIContainer> mImage;
+ RefPtr<SourceSurface> mSourceSurface;
+ BackendType mBackendType;
+};
+
+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) override {
+ mTotal -= aObject->SizeInBytes();
+ RemoveObject(aObject);
+
+ // Remove from the all canvas cache entry first since nsExpirationTracker
+ // will delete aObject.
+ mAllCanvasCache.RemoveEntry(
+ AllCanvasImageCacheKey(aObject->mImage, aObject->mBackendType));
+
+ // Deleting the entry will delete aObject since the entry owns aObject.
+ mCache.RemoveEntry(ImageCacheKey(aObject->mImage, aObject->mCanvas,
+ aObject->mBackendType));
+ }
+
+ 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) {
+ RegisterObserverEvents();
+ }
+
+ void Destroy() {
+ UnregisterObserverEvents();
+ mImageCache = nullptr;
+ }
+
+ NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aSomeData) override {
+ if (!mImageCache || (strcmp(aTopic, "memory-pressure") != 0 &&
+ strcmp(aTopic, "canvas-device-reset") != 0)) {
+ return NS_OK;
+ }
+
+ mImageCache->AgeAllGenerations();
+ return NS_OK;
+ }
+
+ private:
+ virtual ~ImageCacheObserver() = default;
+
+ void RegisterObserverEvents() {
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+
+ MOZ_ASSERT(observerService);
+
+ if (observerService) {
+ observerService->AddObserver(this, "memory-pressure", false);
+ observerService->AddObserver(this, "canvas-device-reset", false);
+ }
+ }
+
+ void UnregisterObserverEvents() {
+ 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");
+ observerService->RemoveObserver(this, "canvas-device-reset");
+ }
+ }
+
+ ImageCache* mImageCache;
+};
+
+NS_IMPL_ISUPPORTS(ImageCacheObserver, nsIObserver)
+
+class CanvasImageCacheShutdownObserver final : public nsIObserver {
+ ~CanvasImageCacheShutdownObserver() = default;
+
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+};
+
+ImageCache::ImageCache()
+ : nsExpirationTracker<ImageCacheEntryData, 4>(GENERATION_MS, "ImageCache"),
+ mTotal(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,
+ DrawTarget* aTarget,
+ SourceSurface* aSource,
+ const IntSize& aSize,
+ const IntSize& aIntrinsicSize) {
+ if (!aTarget) {
+ return;
+ }
+
+ if (!gImageCache) {
+ gImageCache = new ImageCache();
+ nsContentUtils::RegisterShutdownObserver(
+ new CanvasImageCacheShutdownObserver());
+ }
+
+ nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
+ if (!imgContainer) {
+ return;
+ }
+
+ BackendType backendType = aTarget->GetBackendType();
+ AllCanvasImageCacheKey allCanvasCacheKey(imgContainer, backendType);
+ ImageCacheKey canvasCacheKey(imgContainer, aCanvas, backendType);
+ 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.get());
+ gImageCache->mAllCanvasCache.RemoveEntry(allCanvasCacheKey);
+ }
+
+ gImageCache->AddObject(entry->mData.get());
+ entry->mData->mSourceSurface = aSource;
+ entry->mData->mSize = aSize;
+ entry->mData->mIntrinsicSize = aIntrinsicSize;
+ gImageCache->mTotal += entry->mData->SizeInBytes();
+
+ AllCanvasImageCacheEntry* allEntry =
+ gImageCache->mAllCanvasCache.PutEntry(allCanvasCacheKey);
+ if (allEntry) {
+ allEntry->mSourceSurface = aSource;
+ }
+ }
+
+ if (!StaticPrefs::canvas_image_cache_limit()) {
+ return;
+ }
+
+ // Expire the image cache early if its larger than we want it to be.
+ while (gImageCache->mTotal >
+ size_t(StaticPrefs::canvas_image_cache_limit())) {
+ gImageCache->AgeOneGeneration();
+ }
+}
+
+SourceSurface* CanvasImageCache::LookupAllCanvas(Element* aImage,
+ DrawTarget* aTarget) {
+ if (!gImageCache || !aTarget) {
+ return nullptr;
+ }
+
+ nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
+ if (!imgContainer) {
+ return nullptr;
+ }
+
+ AllCanvasImageCacheEntry* entry = gImageCache->mAllCanvasCache.GetEntry(
+ AllCanvasImageCacheKey(imgContainer, aTarget->GetBackendType()));
+ if (!entry) {
+ return nullptr;
+ }
+
+ return entry->mSourceSurface;
+}
+
+SourceSurface* CanvasImageCache::LookupCanvas(Element* aImage,
+ HTMLCanvasElement* aCanvas,
+ DrawTarget* aTarget,
+ IntSize* aSizeOut,
+ IntSize* aIntrinsicSizeOut) {
+ if (!gImageCache || !aTarget) {
+ return nullptr;
+ }
+
+ nsCOMPtr<imgIContainer> imgContainer = GetImageContainer(aImage);
+ if (!imgContainer) {
+ return nullptr;
+ }
+
+ // We filter based on the backend type because we don't want a surface that
+ // was optimized for one backend to be preferred for another backend, as this
+ // could have performance implications. For example, a Skia optimized surface
+ // given to a D2D backend would cause an upload each time, and similarly a D2D
+ // optimized surface given to a Skia backend would cause a readback. For
+ // details, see bug 1794442.
+ ImageCacheEntry* entry = gImageCache->mCache.GetEntry(
+ ImageCacheKey(imgContainer, aCanvas, aTarget->GetBackendType()));
+ if (!entry) {
+ return nullptr;
+ }
+
+ MOZ_ASSERT(aSizeOut);
+
+ gImageCache->MarkUsed(entry->mData.get());
+ *aSizeOut = entry->mData->mSize;
+ *aIntrinsicSizeOut = entry->mData->mIntrinsicSize;
+ 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