Rename GrResourceCache2 to GrResourceCache

src/gpu/GrResourceCache.h

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#ifndef GrResourceCache2_DEFINED
-#define GrResourceCache2_DEFINED
+#ifndef GrResourceCache_DEFINED
+#define GrResourceCache_DEFINED
 
 #include "GrGpuResource.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrResourceKey.h"
 #include "SkMessageBus.h"
 #include "SkRefCnt.h"
 #include "SkTArray.h"
 #include "SkTInternalLList.h"
 #include "SkTMultiMap.h"
 
 class SkString;
 
 /**
  * Manages the lifetime of all GrGpuResource instances.
  *
  * Resources may have optionally have two types of keys:
  *      1) A scratch key. This is for resources whose allocations are cached but not their contents.
  *         Multiple resources can share the same scratch key. This is so a caller can have two
  *         resource instances with the same properties (e.g. multipass rendering that ping-pongs
  *         between two temporary surfaces. The scratch key is set at resource creation time and
  *         should never change. Resources need not have a scratch key.
  *      2) A content key. This key represents the contents of the resource rather than just its
  *         allocation properties. They may not collide. The content key can be set after resource
  *         creation. Currently it may only be set once and cannot be cleared. This restriction will
  *         be removed.
  * If a resource has neither key type then it will be deleted as soon as the last reference to it
  * is dropped. If a key has both keys the content key takes precedence.
  */
-class GrResourceCache2 {
+class GrResourceCache {
 public:
-    GrResourceCache2();
-    ~GrResourceCache2();
+    GrResourceCache();
+    ~GrResourceCache();
 
     /** Used to access functionality needed by GrGpuResource for lifetime management. */
     class ResourceAccess;
     ResourceAccess resourceAccess();
 
     /**
      * Sets the cache limits in terms of number of resources and max gpu memory byte size.
      */
     void setLimits(int count, size_t bytes);
 
@@ skipping 194 matching lines @@
     bool                                fPurging;
     bool                                fNewlyPurgeableResourceWhilePurging;
 
     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;
 
     InvalidContentKeyInbox              fInvalidContentKeyInbox;
 
 };
 
-class GrResourceCache2::ResourceAccess {
+class GrResourceCache::ResourceAccess {
 private:
-    ResourceAccess(GrResourceCache2* cache) : fCache(cache) { }
+    ResourceAccess(GrResourceCache* cache) : fCache(cache) { }
     ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
     ResourceAccess& operator=(const ResourceAccess&); // unimpl
 
     /**
      * Insert a resource into the cache.
      */
     void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }
 
     /**
      * Removes a resource from the cache.
@@ skipping 38 matching lines @@
 
     /**
      * Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa.
      */
     void didChangeBudgetStatus(GrGpuResource* resource) { fCache->didChangeBudgetStatus(resource); }
 
     // No taking addresses of this type.
     const ResourceAccess* operator&() const;
     ResourceAccess* operator&();
 
-    GrResourceCache2* fCache;
+    GrResourceCache* fCache;
 
     friend class GrGpuResource; // To access all the proxy inline methods.
-    friend class GrResourceCache2; // To create this type.
+    friend class GrResourceCache; // To create this type.
 };
 
-inline GrResourceCache2::ResourceAccess GrResourceCache2::resourceAccess() {
+inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
     return ResourceAccess(this);
 }
 
 #endif