The Tor Browser: image/src/SurfaceCache.cpp@ac0c01689b40 (annotated)

image/src/SurfaceCache.cpp@ac0c01689b40 (annotated)

image/src/SurfaceCache.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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

The Tor Browser / annotate

image/src/SurfaceCache.cpp@ac0c01689b40 (annotated)

image/src/SurfaceCache.cpp