Bug 1282327 (Part 2) - Update SurfaceCache documentation and method names to reflect the fact that cache entries are now ISurfaceProviders. r=dholbert
authorSeth Fowler <mark.seth.fowler@gmail.com>
Fri, 01 Jul 2016 23:33:58 -0600
changeset 303466 a561bae08fbbbbe148f67febb8d6d0d4cd11c2ce
parent 303465 2984a22f9dcb85872ebbccb264bb8a9894bcccba
child 303467 872c207297631b960bea8de9baafe2de5e61d148
push id19853
push usercbook@mozilla.com
push dateMon, 04 Jul 2016 11:08:46 +0000
treeherderfx-team@4191df8e4b8e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdholbert
bugs1282327
milestone50.0a1
Bug 1282327 (Part 2) - Update SurfaceCache documentation and method names to reflect the fact that cache entries are now ISurfaceProviders. r=dholbert
image/RasterImage.cpp
image/SurfaceCache.cpp
image/SurfaceCache.h
image/VectorImage.cpp
--- a/image/RasterImage.cpp
+++ b/image/RasterImage.cpp
@@ -1277,17 +1277,17 @@ RasterImage::Decode(const IntSize& aSize
 
   // We're about to decode again, which may mean that some of the previous sizes
   // we've decoded at aren't useful anymore. We can allow them to expire from
   // the cache by unlocking them here. When the decode finishes, it will send an
   // invalidation that will cause all instances of this image to redraw. If this
   // image is locked, any surfaces that are still useful will become locked
   // again when LookupFrame touches them, and the remainder will eventually
   // expire.
-  SurfaceCache::UnlockSurfaces(ImageKey(this));
+  SurfaceCache::UnlockEntries(ImageKey(this));
 
   Maybe<IntSize> targetSize = mSize != aSize ? Some(aSize) : Nothing();
 
   // Determine which flags we need to decode this image with.
   DecoderFlags decoderFlags = DefaultDecoderFlags();
   if (aFlags & FLAG_ASYNC_NOTIFY) {
     decoderFlags |= DecoderFlags::ASYNC_NOTIFY;
   }
--- a/image/SurfaceCache.cpp
+++ b/image/SurfaceCache.cpp
@@ -432,25 +432,25 @@ public:
   Mutex& GetMutex() { return mMutex; }
 
   InsertOutcome Insert(ISurfaceProvider* aProvider,
                        const Cost        aCost,
                        const ImageKey    aImageKey,
                        const SurfaceKey& aSurfaceKey)
   {
     // If this is a duplicate surface, refuse to replace the original.
-    // XXX(seth): Calling Lookup() and then RemoveSurface() does the lookup
+    // XXX(seth): Calling Lookup() and then RemoveEntry() does the lookup
     // twice. We'll make this more efficient in bug 1185137.
     LookupResult result = Lookup(aImageKey, aSurfaceKey, /* aMarkUsed = */ false);
     if (MOZ_UNLIKELY(result)) {
       return InsertOutcome::FAILURE_ALREADY_PRESENT;
     }
 
     if (result.Type() == MatchType::PENDING) {
-      RemoveSurface(aImageKey, aSurfaceKey);
+      RemoveEntry(aImageKey, aSurfaceKey);
     }
 
     MOZ_ASSERT(result.Type() == MatchType::NOT_FOUND ||
                result.Type() == MatchType::PENDING,
                "A LookupResult with no surface should be NOT_FOUND or PENDING");
 
     // If this is bigger than we can hold after discarding everything we can,
     // refuse to cache it.
@@ -650,18 +650,18 @@ public:
 
     if (matchType == MatchType::EXACT) {
       MarkUsed(surface, cache);
     }
 
     return LookupResult(Move(ref), matchType);
   }
 
-  void RemoveSurface(const ImageKey    aImageKey,
-                     const SurfaceKey& aSurfaceKey)
+  void RemoveEntry(const ImageKey    aImageKey,
+                   const SurfaceKey& aSurfaceKey)
   {
     RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
     if (!cache) {
       return;  // No cached surfaces for this image.
     }
 
     RefPtr<CachedSurface> surface = cache->Lookup(aSurfaceKey);
     if (!surface) {
@@ -696,17 +696,17 @@ public:
     if (!cache || !cache->IsLocked()) {
       return;  // Already unlocked.
     }
 
     cache->SetLocked(false);
     DoUnlockSurfaces(cache);
   }
 
-  void UnlockSurfaces(const ImageKey aImageKey)
+  void UnlockEntries(const ImageKey aImageKey)
   {
     RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
     if (!cache || !cache->IsLocked()) {
       return;  // Already unlocked.
     }
 
     // (Note that we *don't* unlock the per-image cache here; that's the
     // difference between this and UnlockImage.)
@@ -1082,31 +1082,31 @@ SurfaceCache::UnlockImage(Image* aImageK
 {
   if (sInstance) {
     MutexAutoLock lock(sInstance->GetMutex());
     return sInstance->UnlockImage(aImageKey);
   }
 }
 
 /* static */ void
-SurfaceCache::UnlockSurfaces(const ImageKey aImageKey)
+SurfaceCache::UnlockEntries(const ImageKey aImageKey)
 {
   if (sInstance) {
     MutexAutoLock lock(sInstance->GetMutex());
-    return sInstance->UnlockSurfaces(aImageKey);
+    return sInstance->UnlockEntries(aImageKey);
   }
 }
 
 /* static */ void
-SurfaceCache::RemoveSurface(const ImageKey    aImageKey,
-                            const SurfaceKey& aSurfaceKey)
+SurfaceCache::RemoveEntry(const ImageKey    aImageKey,
+                          const SurfaceKey& aSurfaceKey)
 {
   if (sInstance) {
     MutexAutoLock lock(sInstance->GetMutex());
-    sInstance->RemoveSurface(aImageKey, aSurfaceKey);
+    sInstance->RemoveEntry(aImageKey, aSurfaceKey);
   }
 }
 
 /* static */ void
 SurfaceCache::RemoveImage(Image* aImageKey)
 {
   if (sInstance) {
     MutexAutoLock lock(sInstance->GetMutex());
--- a/image/SurfaceCache.h
+++ b/image/SurfaceCache.h
@@ -27,24 +27,25 @@ namespace mozilla {
 namespace image {
 
 class Image;
 class ISurfaceProvider;
 class LookupResult;
 struct SurfaceMemoryCounter;
 
 /*
- * ImageKey contains the information we need to look up all cached surfaces for
- * a particular image.
+ * ImageKey contains the information we need to look up all SurfaceCache entries
+ * for a particular image.
  */
 typedef Image* ImageKey;
 
 /*
- * SurfaceKey contains the information we need to look up a specific cached
- * surface. Together with an ImageKey, this uniquely identifies the surface.
+ * SurfaceKey contains the information we need to look up a specific
+ * SurfaceCache entry. Together with an ImageKey, this uniquely identifies the
+ * surface.
  *
  * Callers should construct a SurfaceKey using the appropriate helper function
  * for their image type - either RasterSurfaceKey or VectorSurfaceKey.
  */
 class SurfaceKey
 {
   typedef gfx::IntSize IntSize;
 
@@ -119,26 +120,29 @@ VectorSurfaceKey(const gfx::IntSize& aSi
 
 enum class InsertOutcome : uint8_t {
   SUCCESS,                 // Success (but see Insert documentation).
   FAILURE,                 // Couldn't insert (e.g., for capacity reasons).
   FAILURE_ALREADY_PRESENT  // A surface with the same key is already present.
 };
 
 /**
- * SurfaceCache is an imagelib-global service that allows caching of temporary
- * surfaces. Surfaces normally expire from the cache automatically if they go
+ * SurfaceCache is an ImageLib-global service that allows caching of decoded
+ * image surfaces, temporary surfaces (e.g. for caching rotated or clipped
+ * versions of images), or dynamically generated surfaces (e.g. for animations).
+ * SurfaceCache entries normally expire from the cache automatically if they go
  * too long without being accessed.
  *
- * SurfaceCache does not hold surfaces directly; instead, it holds imgFrame
- * objects, which hold surfaces but also layer on additional features specific
- * to imagelib's needs like animation, padding support, and transparent support
- * for volatile buffers.
+ * Because SurfaceCache must support both normal surfaces and dynamically
+ * generated surfaces, it does not actually hold surfaces directly. Instead, it
+ * holds ISurfaceProvider objects which can provide access to a surface when
+ * requested; SurfaceCache doesn't care about the details of how this is
+ * accomplished.
  *
- * Sometime it's useful to temporarily prevent surfaces from expiring from the
+ * Sometime it's useful to temporarily prevent entries from expiring from the
  * cache. This is most often because losing the data could harm the user
  * experience (for example, we often don't want to allow surfaces that are
  * currently visible to expire) or because it's not possible to rematerialize
  * the surface. SurfaceCache supports this through the use of image locking; see
  * the comments for Insert() and LockImage() for more details.
  *
  * Any image which stores surfaces in the SurfaceCache *must* ensure that it
  * calls RemoveImage() before it is destroyed. See the comments for
@@ -154,133 +158,133 @@ struct SurfaceCache
   static void Initialize();
 
   /**
    * Release static data. Called during imagelib module shutdown.
    */
   static void Shutdown();
 
   /**
-   * Look up the imgFrame containing a surface in the cache and returns a
-   * drawable reference to that imgFrame.
+   * Looks up the requested cache entry and returns a drawable reference to its
+   * associated surface.
    *
-   * If the image associated with the surface is locked, then the surface will
+   * If the image associated with the cache entry is locked, then the entry will
    * be locked before it is returned.
    *
-   * If the imgFrame was found in the cache, but had stored its surface in a
-   * volatile buffer which was discarded by the OS, then it is automatically
-   * removed from the cache and an empty LookupResult is returned. Note that
-   * this will never happen to surfaces associated with a locked image; the
-   * cache keeps a strong reference to such surfaces internally.
+   * If a matching ISurfaceProvider was found in the cache, but SurfaceCache
+   * couldn't obtain a surface from it (e.g. because it had stored its surface
+   * in a volatile buffer which was discarded by the OS) then it is
+   * automatically removed from the cache and an empty LookupResult is returned.
+   * Note that this will never happen to ISurfaceProviders associated with a
+   * locked image; SurfaceCache tells such ISurfaceProviders to keep a strong
+   * references to their data internally.
    *
-   * @param aImageKey       Key data identifying which image the surface belongs
-   *                        to.
-   *
+   * @param aImageKey       Key data identifying which image the cache entry
+   *                        belongs to.
    * @param aSurfaceKey     Key data which uniquely identifies the requested
-   *                        surface.
-   *
+   *                        cache entry.
    * @return                a LookupResult, which will either contain a
-   *                        DrawableFrameRef to the requested surface, or an
-   *                        empty DrawableFrameRef if the surface was not found.
+   *                        DrawableFrameRef to a surface, or an empty
+   *                        DrawableFrameRef if the cache entry was not found.
    */
   static LookupResult Lookup(const ImageKey    aImageKey,
                              const SurfaceKey& aSurfaceKey);
 
   /**
-   * Looks up the best matching surface in the cache and returns a drawable
-   * reference to the imgFrame containing it.
+   * Looks up the best matching cache entry and returns a drawable reference to
+   * its associated surface.
    *
-   * Returned surfaces may vary from the requested surface only in terms of
-   * size.
+   * The result may vary from the requested cache entry only in terms of size.
    *
-   * @param aImageKey    Key data identifying which image the surface belongs
-   *                     to.
-   *
-   * @param aSurfaceKey  Key data which identifies the ideal surface to return.
-   *
+   * @param aImageKey       Key data identifying which image the cache entry
+   *                        belongs to.
+   * @param aSurfaceKey     Key data which uniquely identifies the requested
+   *                        cache entry.
    * @return                a LookupResult, which will either contain a
    *                        DrawableFrameRef to a surface similar to the
-   *                        requested surface, or an empty DrawableFrameRef if
-   *                        the surface was not found. Callers can use
-   *                        LookupResult::IsExactMatch() to check whether the
-   *                        returned surface exactly matches @aSurfaceKey.
+   *                        the one the caller requested, or an empty
+   *                        DrawableFrameRef if no acceptable match was found.
+   *                        Callers can use LookupResult::IsExactMatch() to check
+   *                        whether the returned surface exactly matches
+   *                        @aSurfaceKey.
    */
   static LookupResult LookupBestMatch(const ImageKey    aImageKey,
                                       const SurfaceKey& aSurfaceKey);
 
   /**
-   * Insert a surface into the cache. If a surface with the same ImageKey and
-   * SurfaceKey is already in the cache, Insert returns FAILURE_ALREADY_PRESENT.
-   * If a matching placeholder is already present, the placeholder is removed.
+   * Insert an ISurfaceProvider into the cache. If an entry with the same
+   * ImageKey and SurfaceKey is already in the cache, Insert returns
+   * FAILURE_ALREADY_PRESENT. If a matching placeholder is already present, the
+   * placeholder is removed.
    *
-   * Surfaces will never expire as long as they remain locked, but if they
+   * Cache entries will never expire as long as they remain locked, but if they
    * become unlocked, they can expire either because the SurfaceCache runs out
    * of capacity or because they've gone too long without being used.  When it
-   * is first inserted, a surface is locked if its associated image is locked.
-   * When that image is later unlocked, the surface becomes unlocked too. To
-   * become locked again at that point, two things must happen: the image must
-   * become locked again (via LockImage()), and the surface must be touched
-   * again (via one of the Lookup() functions).
+   * is first inserted, a cache entry is locked if its associated image is
+   * locked.  When that image is later unlocked, the cache entry becomes
+   * unlocked too. To become locked again at that point, two things must happen:
+   * the image must become locked again (via LockImage()), and the cache entry
+   * must be touched again (via one of the Lookup() functions).
    *
    * All of this means that a very particular procedure has to be followed for
-   * surfaces which cannot be rematerialized. First, they must be inserted
+   * cache entries which cannot be rematerialized. First, they must be inserted
    * *after* the image is locked with LockImage(); if you use the other order,
-   * the surfaces might expire before LockImage() gets called or before the
-   * surface is touched again by Lookup(). Second, the image they are associated
+   * the cache entry might expire before LockImage() gets called or before the
+   * entry is touched again by Lookup(). Second, the image they are associated
    * with must never be unlocked.
    *
-   * If a surface cannot be rematerialized, it may be important to know whether
-   * it was inserted into the cache successfully. Insert() returns FAILURE if it
-   * failed to insert the surface, which could happen because of capacity
-   * reasons, or because it was already freed by the OS. If the surface isn't
-   * associated with a locked image, checking for SUCCESS or FAILURE is useless:
-   * the surface might expire immediately after being inserted, even though
-   * Insert() returned SUCCESS. Thus, many callers do not need to check the
-   * result of Insert() at all.
+   * If a cache entry cannot be rematerialized, it may be important to know
+   * whether it was inserted into the cache successfully. Insert() returns
+   * FAILURE if it failed to insert the cache entry, which could happen because
+   * of capacity reasons, or because it was already freed by the OS. If the
+   * cache entry isn't associated with a locked image, checking for SUCCESS or
+   * FAILURE is useless: the entry might expire immediately after being
+   * inserted, even though Insert() returned SUCCESS. Thus, many callers do not
+   * need to check the result of Insert() at all.
    *
-   * @param aTarget      The new surface (wrapped in an imgFrame) to insert into
-   *                     the cache.
-   * @param aImageKey    Key data identifying which image the surface belongs
-   *                     to.
-   * @param aSurfaceKey  Key data which uniquely identifies the requested
-   *                     surface.
-   * @return SUCCESS if the surface was inserted successfully. (But see above
+   * @param aProvider    The new cache entry to insert into the cache.
+   * @param aImageKey       Key data identifying which image the cache entry
+   *                        belongs to.
+   * @param aSurfaceKey     Key data which uniquely identifies the requested
+   *                        cache entry.
+   * @return SUCCESS if the cache entry was inserted successfully. (But see above
    *           for more information about when you should check this.)
-   *         FAILURE if the surface could not be inserted, e.g. for capacity
+   *         FAILURE if the cache entry could not be inserted, e.g. for capacity
    *           reasons. (But see above for more information about when you
    *           should check this.)
-   *         FAILURE_ALREADY_PRESENT if a surface with the same ImageKey and
+   *         FAILURE_ALREADY_PRESENT if an entry with the same ImageKey and
    *           SurfaceKey already exists in the cache.
    */
   static InsertOutcome Insert(NotNull<ISurfaceProvider*> aProvider,
                               const ImageKey    aImageKey,
                               const SurfaceKey& aSurfaceKey);
 
   /**
-   * Insert a placeholder for a surface into the cache. If a surface with the
-   * same ImageKey and SurfaceKey is already in the cache, InsertPlaceholder()
+   * Insert a placeholder entry into the cache. If an entry with the same
+   * ImageKey and SurfaceKey is already in the cache, InsertPlaceholder()
    * returns FAILURE_ALREADY_PRESENT.
    *
    * Placeholders exist to allow lazy allocation of surfaces. The Lookup*()
-   * methods will report whether a placeholder for an exactly matching surface
-   * existed by returning a MatchType of PENDING or SUBSTITUTE_BECAUSE_PENDING,
-   * but they will never return a placeholder directly. (They couldn't, since
-   * placeholders don't have an associated surface.)
+   * methods will report whether a placeholder for an exactly matching cache
+   * entry existed by returning a MatchType of PENDING or
+   * SUBSTITUTE_BECAUSE_PENDING, but they will never return a placeholder
+   * directly. (They couldn't, since placeholders don't have an associated
+   * surface.)
    *
-   * Once inserted, placeholders can be removed using RemoveSurface() or
-   * RemoveImage(), just like a surface.  They're automatically removed when a
-   * real surface that matches the placeholder is inserted with Insert().
+   * Once inserted, placeholders can be removed using RemoveEntry() or
+   * RemoveImage(), just like a real cache entry.  They're automatically removed
+   * when a real entry that matches the placeholder is inserted with Insert().
    *
-   * @param aImageKey    Key data identifying which image the placeholder
-   *                     belongs to.
-   * @param aSurfaceKey  Key data which uniquely identifies the surface the
-   *                     placeholder stands in for.
+   * @param aImageKey       Key data identifying which image the cache entry
+   *                        belongs to.
+   * @param aSurfaceKey     Key data which uniquely identifies the requested
+   *                        cache entry.
    * @return SUCCESS if the placeholder was inserted successfully.
    *         FAILURE if the placeholder could not be inserted for some reason.
-   *         FAILURE_ALREADY_PRESENT if a surface with the same ImageKey and
+   *         FAILURE_ALREADY_PRESENT if an entry with the same ImageKey and
    *           SurfaceKey already exists in the cache.
    */
   static InsertOutcome InsertPlaceholder(const ImageKey    aImageKey,
                                          const SurfaceKey& aSurfaceKey);
 
   /**
    * Checks if a surface of a given size could possibly be stored in the cache.
    * If CanHold() returns false, Insert() will always fail to insert the
@@ -297,109 +301,109 @@ struct SurfaceCache
    *                        images.
    *
    * @return false if the surface cache can't hold a surface of that size.
    */
   static bool CanHold(const IntSize& aSize, uint32_t aBytesPerPixel = 4);
   static bool CanHold(size_t aSize);
 
   /**
-   * Locks an image. Any of the image's surfaces which are either inserted or
-   * accessed while the image is locked will not expire.
+   * Locks an image. Any of the image's cache entries which are either inserted
+   * or accessed while the image is locked will not expire.
    *
-   * Locking an image does not automatically lock that image's existing
-   * surfaces. A call to LockImage() guarantees that surfaces which are inserted
+   * Locking an image does not automatically lock that image's existing cache
+   * entries. A call to LockImage() guarantees that entries which are inserted
    * afterward will not expire before the next call to UnlockImage() or
-   * UnlockSurfaces() for that image. Surfaces that are accessed via Lookup() or
-   * LookupBestMatch() after a LockImage() call will also not expire until the
-   * next UnlockImage() or UnlockSurfaces() call for that image. Any other
-   * surfaces owned by the image may expire at any time.
+   * UnlockSurfaces() for that image. Cache entries that are accessed via
+   * Lookup() or LookupBestMatch() after a LockImage() call will also not expire
+   * until the next UnlockImage() or UnlockSurfaces() call for that image. Any
+   * other cache entries owned by the image may expire at any time.
    *
-   * Regardless of locking, any of an image's surfaces may be removed using
-   * RemoveSurface(), and all of an image's surfaces are removed by
+   * Regardless of locking, any of an image's cache entries may be removed using
+   * RemoveEntry(), and all of an image's cache entries are removed by
    * RemoveImage(), whether the image is locked or not.
    *
    * It's safe to call LockImage() on an image that's already locked; this has
    * no effect.
    *
    * You must always unlock any image you lock. You may do this explicitly by
    * calling UnlockImage(), or implicitly by calling RemoveImage(). Since you're
    * required to call RemoveImage() when you destroy an image, this doesn't
    * impose any additional requirements, but it's preferable to call
    * UnlockImage() earlier if it's possible.
    *
    * @param aImageKey    The image to lock.
    */
   static void LockImage(const ImageKey aImageKey);
 
   /**
-   * Unlocks an image, allowing any of its surfaces to expire at any time.
+   * Unlocks an image, allowing any of its cache entries to expire at any time.
    *
    * It's OK to call UnlockImage() on an image that's already unlocked; this has
    * no effect.
    *
    * @param aImageKey    The image to unlock.
    */
   static void UnlockImage(const ImageKey aImageKey);
 
   /**
-   * Unlocks the existing surfaces of an image, allowing them to expire at any
-   * time.
+   * Unlocks the existing cache entries of an image, allowing them to expire at
+   * any time.
    *
-   * This does not unlock the image itself, so accessing the surfaces via
+   * This does not unlock the image itself, so accessing the cache entries via
    * Lookup() or LookupBestMatch() will lock them again, and prevent them from
    * expiring.
    *
    * This is intended to be used in situations where it's no longer clear that
-   * all of the surfaces owned by an image are needed. Calling UnlockSurfaces()
-   * and then taking some action that will cause Lookup() to touch any surfaces
-   * that are still useful will permit the remaining surfaces to expire from the
-   * cache.
+   * all of the cache entries owned by an image are needed. Calling
+   * UnlockSurfaces() and then taking some action that will cause Lookup() to
+   * touch any cache entries that are still useful will permit the remaining
+   * entries to expire from the cache.
    *
    * If the image is unlocked, this has no effect.
    *
-   * @param aImageKey    The image which should have its existing surfaces
+   * @param aImageKey    The image which should have its existing cache entries
    *                     unlocked.
    */
-  static void UnlockSurfaces(const ImageKey aImageKey);
+  static void UnlockEntries(const ImageKey aImageKey);
 
   /**
-   * Removes a surface or placeholder from the cache, if it's present. If it's
-   * not present, RemoveSurface() has no effect.
+   * Removes a cache entry (either a real or placeholder) from the cache, if
+   * it's present. If it's not present, RemoveEntry() has no effect.
    *
-   * Use this function to remove individual surfaces that have become invalid.
-   * Prefer RemoveImage() or DiscardAll() when they're applicable, as they have
-   * much better performance than calling this function repeatedly.
+   * Use this function to remove individual cache entries that have become
+   * invalid.  Prefer RemoveImage() or DiscardAll() when they're applicable, as
+   * they have much better performance than calling this function repeatedly.
    *
-   * @param aImageKey    Key data identifying which image the surface belongs
-                         to.
-   * @param aSurfaceKey  Key data which uniquely identifies the requested
-                         surface.
+   * @param aImageKey       Key data identifying which image the cache entry
+   *                        belongs to.
+   * @param aSurfaceKey     Key data which uniquely identifies the requested
+   *                        cache entry.
    */
-  static void RemoveSurface(const ImageKey    aImageKey,
-                            const SurfaceKey& aSurfaceKey);
+  static void RemoveEntry(const ImageKey    aImageKey,
+                          const SurfaceKey& aSurfaceKey);
 
   /**
-   * Removes all cached surfaces and placeholders associated with the given
-   * image from the cache.  If the image is locked, it is automatically
+   * Removes all cache entries (both real and placeholder) associated with the
+   * given image from the cache.  If the image is locked, it is automatically
    * unlocked.
    *
    * This MUST be called, at a minimum, when an Image which could be storing
-   * surfaces in the surface cache is destroyed. If another image were allocated
+   * entries in the surface cache is destroyed. If another image were allocated
    * at the same address it could result in subtle, difficult-to-reproduce bugs.
    *
    * @param aImageKey  The image which should be removed from the cache.
    */
   static void RemoveImage(const ImageKey aImageKey);
 
   /**
-   * Evicts all evictable surfaces from the cache.
+   * Evicts all evictable entries from the cache.
    *
-   * All surfaces are evictable except for surfaces associated with locked
-   * images. Non-evictable surfaces can only be removed by RemoveSurface() or
+   * All entries are evictable except for entries associated with locked images.
+   * Non-evictable entries can only be removed by RemoveEntry() or
    * RemoveImage().
    */
   static void DiscardAll();
 
   /**
    * Collects an accounting of the surfaces contained in the SurfaceCache for
    * the given image, along with their size and various other metadata.
    *
--- a/image/VectorImage.cpp
+++ b/image/VectorImage.cpp
@@ -915,17 +915,17 @@ VectorImage::CreateSurfaceAndShow(const 
   }
 
   // We're about to rerasterize, which may mean that some of the previous
   // surfaces we've rasterized aren't useful anymore. We can allow them to
   // expire from the cache by unlocking them here, and then sending out an
   // invalidation. If this image is locked, any surfaces that are still useful
   // will become locked again when Draw touches them, and the remainder will
   // eventually expire.
-  SurfaceCache::UnlockSurfaces(ImageKey(this));
+  SurfaceCache::UnlockEntries(ImageKey(this));
 
   // Try to create an imgFrame, initializing the surface it contains by drawing
   // our gfxDrawable into it. (We use FILTER_NEAREST since we never scale here.)
   NotNull<RefPtr<imgFrame>> frame = WrapNotNull(new imgFrame);
   nsresult rv =
     frame->InitWithDrawable(svgDrawable, aParams.size,
                             SurfaceFormat::B8G8R8A8,
                             SamplingFilter::POINT, aParams.flags);