diff -r 000000000000 -r 6474c204b198 image/src/SurfaceCache.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/image/src/SurfaceCache.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,545 @@
+/* -*- 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/. */
+
+/**
+ * SurfaceCache is a service for caching temporary surfaces in imagelib.
+ */
+
+#include "SurfaceCache.h"
+
+#include <algorithm>
+#include "mozilla/Attributes.h"  // for MOZ_THIS_IN_INITIALIZER_LIST
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticPtr.h"
+#include "nsIMemoryReporter.h"
+#include "gfx2DGlue.h"
+#include "gfxASurface.h"
+#include "gfxPattern.h"  // Workaround for flaw in bug 921753 part 2.
+#include "gfxDrawable.h"
+#include "gfxPlatform.h"
+#include "nsAutoPtr.h"
+#include "nsExpirationTracker.h"
+#include "nsHashKeys.h"
+#include "nsRefPtrHashtable.h"
+#include "nsSize.h"
+#include "nsTArray.h"
+#include "prsystem.h"
+#include "SVGImageContext.h"
+
+using std::max;
+using std::min;
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace image {
+
+class CachedSurface;
+class SurfaceCacheImpl;
+
+///////////////////////////////////////////////////////////////////////////////
+// Static Data
+///////////////////////////////////////////////////////////////////////////////
+
+// The single surface cache instance.
+static StaticRefPtr<SurfaceCacheImpl> sInstance;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// SurfaceCache Implementation
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+ * Cost models the cost of storing a surface in the cache. Right now, this is
+ * simply an estimate of the size of the surface in bytes, but in the future it
+ * may be worth taking into account the cost of rematerializing the surface as
+ * well.
+ */
+typedef size_t Cost;
+
+static Cost ComputeCost(const IntSize& aSize)
+{
+  return aSize.width * aSize.height * 4;  // width * height * 4 bytes (32bpp)
+}
+
+/*
+ * Since we want to be able to make eviction decisions based on cost, we need to
+ * be able to look up the CachedSurface which has a certain cost as well as the
+ * cost associated with a certain CachedSurface. To make this possible, in data
+ * structures we actually store a CostEntry, which contains a weak pointer to
+ * its associated surface.
+ *
+ * To make usage of the weak pointer safe, SurfaceCacheImpl always calls
+ * StartTracking after a surface is stored in the cache and StopTracking before
+ * it is removed.
+ */
+class CostEntry
+{
+public:
+  CostEntry(CachedSurface* aSurface, Cost aCost)
+    : mSurface(aSurface)
+    , mCost(aCost)
+  {
+    MOZ_ASSERT(aSurface, "Must have a surface");
+  }
+
+  CachedSurface* GetSurface() const { return mSurface; }
+  Cost GetCost() const { return mCost; }
+
+  bool operator==(const CostEntry& aOther) const
+  {
+    return mSurface == aOther.mSurface &&
+           mCost == aOther.mCost;
+  }
+
+  bool operator<(const CostEntry& aOther) const
+  {
+    return mCost < aOther.mCost ||
+           (mCost == aOther.mCost && mSurface < aOther.mSurface);
+  }
+
+private:
+  CachedSurface* mSurface;
+  Cost           mCost;
+};
+
+/*
+ * A CachedSurface associates a surface with a key that uniquely identifies that
+ * surface.
+ */
+class CachedSurface
+{
+public:
+  NS_INLINE_DECL_REFCOUNTING(CachedSurface)
+
+  CachedSurface(DrawTarget*       aTarget,
+                const IntSize     aTargetSize,
+                const Cost        aCost,
+                const ImageKey    aImageKey,
+                const SurfaceKey& aSurfaceKey)
+    : mTarget(aTarget)
+    , mTargetSize(aTargetSize)
+    , mCost(aCost)
+    , mImageKey(aImageKey)
+    , mSurfaceKey(aSurfaceKey)
+  {
+    MOZ_ASSERT(mTarget, "Must have a valid DrawTarget");
+    MOZ_ASSERT(mImageKey, "Must have a valid image key");
+  }
+
+  already_AddRefed<gfxDrawable> Drawable() const
+  {
+    nsRefPtr<gfxDrawable> drawable =
+      new gfxSurfaceDrawable(mTarget, ThebesIntSize(mTargetSize));
+    return drawable.forget();
+  }
+
+  ImageKey GetImageKey() const { return mImageKey; }
+  SurfaceKey GetSurfaceKey() const { return mSurfaceKey; }
+  CostEntry GetCostEntry() { return image::CostEntry(this, mCost); }
+  nsExpirationState* GetExpirationState() { return &mExpirationState; }
+
+private:
+  nsExpirationState       mExpirationState;
+  nsRefPtr<DrawTarget>    mTarget;
+  const IntSize           mTargetSize;
+  const Cost              mCost;
+  const ImageKey          mImageKey;
+  const SurfaceKey        mSurfaceKey;
+};
+
+/*
+ * An ImageSurfaceCache is a per-image surface cache. For correctness we must be
+ * able to remove all surfaces associated with an image when the image is
+ * destroyed or invalidated. Since this will happen frequently, it makes sense
+ * to make it cheap by storing the surfaces for each image separately.
+ */
+class ImageSurfaceCache
+{
+public:
+  NS_INLINE_DECL_REFCOUNTING(ImageSurfaceCache)
+
+  typedef nsRefPtrHashtable<nsGenericHashKey<SurfaceKey>, CachedSurface> SurfaceTable;
+
+  bool IsEmpty() const { return mSurfaces.Count() == 0; }
+  
+  void Insert(const SurfaceKey& aKey, CachedSurface* aSurface)
+  {
+    MOZ_ASSERT(aSurface, "Should have a surface");
+    mSurfaces.Put(aKey, aSurface);
+  }
+
+  void Remove(CachedSurface* aSurface)
+  {
+    MOZ_ASSERT(aSurface, "Should have a surface");
+    MOZ_ASSERT(mSurfaces.GetWeak(aSurface->GetSurfaceKey()),
+        "Should not be removing a surface we don't have");
+
+    mSurfaces.Remove(aSurface->GetSurfaceKey());
+  }
+
+  already_AddRefed<CachedSurface> Lookup(const SurfaceKey& aSurfaceKey)
+  {
+    nsRefPtr<CachedSurface> surface;
+    mSurfaces.Get(aSurfaceKey, getter_AddRefs(surface));
+    return surface.forget();
+  }
+
+  void ForEach(SurfaceTable::EnumReadFunction aFunction, void* aData)
+  {
+    mSurfaces.EnumerateRead(aFunction, aData);
+  }
+
+private:
+  SurfaceTable mSurfaces;
+};
+
+/*
+ * SurfaceCacheImpl is responsible for determining which surfaces will be cached
+ * and managing the surface cache data structures. Rather than interact with
+ * SurfaceCacheImpl directly, client code interacts with SurfaceCache, which
+ * maintains high-level invariants and encapsulates the details of the surface
+ * cache's implementation.
+ */
+class SurfaceCacheImpl : public nsIMemoryReporter
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  SurfaceCacheImpl(uint32_t aSurfaceCacheExpirationTimeMS,
+                   uint32_t aSurfaceCacheSize)
+    : mExpirationTracker(MOZ_THIS_IN_INITIALIZER_LIST(),
+                         aSurfaceCacheExpirationTimeMS)
+    , mMemoryPressureObserver(new MemoryPressureObserver)
+    , mMaxCost(aSurfaceCacheSize)
+    , mAvailableCost(aSurfaceCacheSize)
+  {
+    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+    if (os)
+      os->AddObserver(mMemoryPressureObserver, "memory-pressure", false);
+  }
+
+  virtual ~SurfaceCacheImpl()
+  {
+    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+    if (os)
+      os->RemoveObserver(mMemoryPressureObserver, "memory-pressure");
+
+    UnregisterWeakMemoryReporter(this);
+  }
+
+  void InitMemoryReporter() {
+    RegisterWeakMemoryReporter(this);
+  }
+
+  void Insert(DrawTarget*       aTarget,
+              IntSize           aTargetSize,
+              const Cost        aCost,
+              const ImageKey    aImageKey,
+              const SurfaceKey& aSurfaceKey)
+  {
+    MOZ_ASSERT(!Lookup(aImageKey, aSurfaceKey).take(),
+               "Inserting a duplicate drawable into the SurfaceCache");
+
+    // If this is bigger than the maximum cache size, refuse to cache it.
+    if (!CanHold(aCost))
+      return;
+
+    nsRefPtr<CachedSurface> surface =
+      new CachedSurface(aTarget, aTargetSize, aCost, aImageKey, aSurfaceKey);
+
+    // Remove elements in order of cost until we can fit this in the cache.
+    while (aCost > mAvailableCost) {
+      MOZ_ASSERT(!mCosts.IsEmpty(), "Removed everything and it still won't fit");
+      Remove(mCosts.LastElement().GetSurface());
+    }
+
+    // Locate the appropriate per-image cache. If there's not an existing cache
+    // for this image, create it.
+    nsRefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+    if (!cache) {
+      cache = new ImageSurfaceCache;
+      mImageCaches.Put(aImageKey, cache);
+    }
+
+    // Insert.
+    MOZ_ASSERT(aCost <= mAvailableCost, "Inserting despite too large a cost");
+    cache->Insert(aSurfaceKey, surface);
+    StartTracking(surface);
+  }
+
+  void Remove(CachedSurface* aSurface)
+  {
+    MOZ_ASSERT(aSurface, "Should have a surface");
+    const ImageKey imageKey = aSurface->GetImageKey();
+
+    nsRefPtr<ImageSurfaceCache> cache = GetImageCache(imageKey);
+    MOZ_ASSERT(cache, "Shouldn't try to remove a surface with no image cache");
+
+    StopTracking(aSurface);
+    cache->Remove(aSurface);
+
+    // Remove the per-image cache if it's unneeded now.
+    if (cache->IsEmpty()) {
+      mImageCaches.Remove(imageKey);
+    }
+  }
+
+  void StartTracking(CachedSurface* aSurface)
+  {
+    CostEntry costEntry = aSurface->GetCostEntry();
+    MOZ_ASSERT(costEntry.GetCost() <= mAvailableCost,
+               "Cost too large and the caller didn't catch it");
+
+    mAvailableCost -= costEntry.GetCost();
+    mCosts.InsertElementSorted(costEntry);
+    mExpirationTracker.AddObject(aSurface);
+  }
+
+  void StopTracking(CachedSurface* aSurface)
+  {
+    MOZ_ASSERT(aSurface, "Should have a surface");
+    CostEntry costEntry = aSurface->GetCostEntry();
+
+    mExpirationTracker.RemoveObject(aSurface);
+    DebugOnly<bool> foundInCosts = mCosts.RemoveElementSorted(costEntry);
+    mAvailableCost += costEntry.GetCost();
+
+    MOZ_ASSERT(foundInCosts, "Lost track of costs for this surface");
+    MOZ_ASSERT(mAvailableCost <= mMaxCost, "More available cost than we started with");
+  }
+
+  already_AddRefed<gfxDrawable> Lookup(const ImageKey    aImageKey,
+                                       const SurfaceKey& aSurfaceKey)
+  {
+    nsRefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+    if (!cache)
+      return nullptr;  // No cached surfaces for this image.
+    
+    nsRefPtr<CachedSurface> surface = cache->Lookup(aSurfaceKey);
+    if (!surface)
+      return nullptr;  // Lookup in the per-image cache missed.
+    
+    mExpirationTracker.MarkUsed(surface);
+    return surface->Drawable();
+  }
+
+  bool CanHold(const Cost aCost) const
+  {
+    return aCost <= mMaxCost;
+  }
+
+  void Discard(const ImageKey aImageKey)
+  {
+    nsRefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
+    if (!cache)
+      return;  // No cached surfaces for this image, so nothing to do.
+
+    // Discard all of the cached surfaces for this image.
+    // XXX(seth): This is O(n^2) since for each item in the cache we are
+    // removing an element from the costs array. Since n is expected to be
+    // small, performance should be good, but if usage patterns change we should
+    // change the data structure used for mCosts.
+    cache->ForEach(DoStopTracking, this);
+
+    // The per-image cache isn't needed anymore, so remove it as well.
+    mImageCaches.Remove(aImageKey);
+  }
+
+  void DiscardAll()
+  {
+    // Remove in order of cost because mCosts is an array and the other data
+    // structures are all hash tables.
+    while (!mCosts.IsEmpty()) {
+      Remove(mCosts.LastElement().GetSurface());
+    }
+  }
+
+  static PLDHashOperator DoStopTracking(const SurfaceKey&,
+                                        CachedSurface*    aSurface,
+                                        void*             aCache)
+  {
+    static_cast<SurfaceCacheImpl*>(aCache)->StopTracking(aSurface);
+    return PL_DHASH_NEXT;
+  }
+
+  NS_IMETHOD
+  CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData)
+  {
+    return MOZ_COLLECT_REPORT(
+      "imagelib-surface-cache", KIND_OTHER, UNITS_BYTES,
+      SizeOfSurfacesEstimate(),
+      "Memory used by the imagelib temporary surface cache.");
+  }
+
+  // XXX(seth): This is currently only an estimate and, since we don't know
+  // which surfaces are in GPU memory and which aren't, it's reported as
+  // KIND_OTHER and will also show up in heap-unclassified. Bug 923302 will
+  // make this nicer.
+  Cost SizeOfSurfacesEstimate() const
+  {
+    return mMaxCost - mAvailableCost;
+  }
+
+private:
+  already_AddRefed<ImageSurfaceCache> GetImageCache(const ImageKey aImageKey)
+  {
+    nsRefPtr<ImageSurfaceCache> imageCache;
+    mImageCaches.Get(aImageKey, getter_AddRefs(imageCache));
+    return imageCache.forget();
+  }
+
+  struct SurfaceTracker : public nsExpirationTracker<CachedSurface, 2>
+  {
+    SurfaceTracker(SurfaceCacheImpl* aCache, uint32_t aSurfaceCacheExpirationTimeMS)
+      : nsExpirationTracker<CachedSurface, 2>(aSurfaceCacheExpirationTimeMS)
+      , mCache(aCache)
+    { }
+
+  protected:
+    virtual void NotifyExpired(CachedSurface* aSurface) MOZ_OVERRIDE
+    {
+      if (mCache) {
+        mCache->Remove(aSurface);
+      }
+    }
+
+  private:
+    SurfaceCacheImpl* const mCache;  // Weak pointer to owner.
+  };
+
+  struct MemoryPressureObserver : public nsIObserver
+  {
+    NS_DECL_ISUPPORTS
+
+    virtual ~MemoryPressureObserver() { }
+
+    NS_IMETHOD Observe(nsISupports*, const char* aTopic, const char16_t*)
+    {
+      if (sInstance && strcmp(aTopic, "memory-pressure") == 0) {
+        sInstance->DiscardAll();
+      }
+      return NS_OK;
+    }
+  };
+
+
+  nsTArray<CostEntry>                                       mCosts;
+  nsRefPtrHashtable<nsPtrHashKey<Image>, ImageSurfaceCache> mImageCaches;
+  SurfaceTracker                                            mExpirationTracker;
+  nsRefPtr<MemoryPressureObserver>                          mMemoryPressureObserver;
+  const Cost                                                mMaxCost;
+  Cost                                                      mAvailableCost;
+};
+
+NS_IMPL_ISUPPORTS(SurfaceCacheImpl, nsIMemoryReporter)
+NS_IMPL_ISUPPORTS(SurfaceCacheImpl::MemoryPressureObserver, nsIObserver)
+
+///////////////////////////////////////////////////////////////////////////////
+// Public API
+///////////////////////////////////////////////////////////////////////////////
+
+/* static */ void
+SurfaceCache::Initialize()
+{
+  // Initialize preferences.
+  MOZ_ASSERT(!sInstance, "Shouldn't initialize more than once");
+
+  // Length of time before an unused surface is removed from the cache, in milliseconds.
+  // The default value gives an expiration time of 1 minute.
+  uint32_t surfaceCacheExpirationTimeMS =
+    Preferences::GetUint("image.mem.surfacecache.min_expiration_ms", 60 * 1000);
+
+  // Maximum size of the surface cache, in kilobytes.
+  // The default is 100MB. (But we may override this for e.g. B2G.)
+  uint32_t surfaceCacheMaxSizeKB =
+    Preferences::GetUint("image.mem.surfacecache.max_size_kb", 100 * 1024);
+
+  // A knob determining the actual size of the surface cache. Currently the
+  // cache is (size of main memory) / (surface cache size factor) KB
+  // or (surface cache max size) KB, whichever is smaller. The formula
+  // may change in the future, though.
+  // The default value is 64, which yields a 64MB cache on a 4GB machine.
+  // The smallest machines we are likely to run this code on have 256MB
+  // of memory, which would yield a 4MB cache on the default setting.
+  uint32_t surfaceCacheSizeFactor =
+    Preferences::GetUint("image.mem.surfacecache.size_factor", 64);
+
+  // Clamp to avoid division by zero below.
+  surfaceCacheSizeFactor = max(surfaceCacheSizeFactor, 1u);
+
+  // Compute the size of the surface cache.
+  uint32_t proposedSize = PR_GetPhysicalMemorySize() / surfaceCacheSizeFactor;
+  uint32_t surfaceCacheSizeBytes = min(proposedSize, surfaceCacheMaxSizeKB * 1024);
+
+  // Create the surface cache singleton with the requested expiration time and
+  // size. Note that the size is a limit that the cache may not grow beyond, but
+  // we do not actually allocate any storage for surfaces at this time.
+  sInstance = new SurfaceCacheImpl(surfaceCacheExpirationTimeMS,
+                                   surfaceCacheSizeBytes);
+  sInstance->InitMemoryReporter();
+}
+
+/* static */ void
+SurfaceCache::Shutdown()
+{
+  MOZ_ASSERT(sInstance, "No singleton - was Shutdown() called twice?");
+  sInstance = nullptr;
+}
+
+/* static */ already_AddRefed<gfxDrawable>
+SurfaceCache::Lookup(const ImageKey    aImageKey,
+                     const SurfaceKey& aSurfaceKey)
+{
+  MOZ_ASSERT(sInstance, "Should be initialized");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return sInstance->Lookup(aImageKey, aSurfaceKey);
+}
+
+/* static */ void
+SurfaceCache::Insert(DrawTarget*       aTarget,
+                     const ImageKey    aImageKey,
+                     const SurfaceKey& aSurfaceKey)
+{
+  MOZ_ASSERT(sInstance, "Should be initialized");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  Cost cost = ComputeCost(aSurfaceKey.Size());
+  return sInstance->Insert(aTarget, aSurfaceKey.Size(), cost, aImageKey,
+                           aSurfaceKey);
+}
+
+/* static */ bool
+SurfaceCache::CanHold(const IntSize& aSize)
+{
+  MOZ_ASSERT(sInstance, "Should be initialized");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  Cost cost = ComputeCost(aSize);
+  return sInstance->CanHold(cost);
+}
+
+/* static */ void
+SurfaceCache::Discard(Image* aImageKey)
+{
+  MOZ_ASSERT(sInstance, "Should be initialized");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return sInstance->Discard(aImageKey);
+}
+
+/* static */ void
+SurfaceCache::DiscardAll()
+{
+  MOZ_ASSERT(sInstance, "Should be initialized");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return sInstance->DiscardAll();
+}
+
+} // namespace image
+} // namespace mozilla