Rename GrResourceCache2 to GrResourceCache

include/gpu/GrGpuResource.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 GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
 #include "GrResourceKey.h"
 #include "GrTypesPriv.h"
 #include "SkData.h"
 #include "SkInstCnt.h"
 #include "SkTInternalLList.h"
 
 class GrContext;
 class GrGpu;
-class GrResourceCache2;
+class GrResourceCache;
 
 /**
  * Base class for GrGpuResource. Handles the various types of refs we need. Separated out as a base
  * class to isolate the ref-cnting behavior and provide friendship without exposing all of
  * GrGpuResource.
  *
  * Gpu resources can have three types of refs:
  *   1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls
  *      that read and write the resource via GrDrawTarget and by any object that must own a
  *      GrGpuResource and is itself owned (directly or indirectly) by Skia-client code.
@@ skipping 76 matching lines @@
             static_cast<const DERIVED*>(this)->notifyIsPurgeable();
         }
     }
 
     mutable int32_t fRefCnt;
     mutable int32_t fPendingReads;
     mutable int32_t fPendingWrites;
 
     // This class is used to manage conversion of refs to pending reads/writes.
     friend class GrGpuResourceRef;
-    friend class GrResourceCache2; // to check IO ref counts.
+    friend class GrResourceCache; // to check IO ref counts.
 
     template <typename, GrIOType> friend class GrPendingIOResource;
 };
 
 /**
- * Base class for objects that can be kept in the GrResourceCache2.
+ * Base class for objects that can be kept in the GrResourceCache.
  */
 class SK_API GrGpuResource : public GrIORef<GrGpuResource> {
 public:
     SK_DECLARE_INST_COUNT(GrGpuResource)
 
     enum LifeCycle {
         /**
          * The resource is cached and owned by Skia. Resources with this status may be kept alive
          * by the cache as either scratch or content resources even when there are no refs to them.
          * The cache may release them whenever there are no refs.
@@ skipping 136 matching lines @@
     void removeScratchKey();
     void makeBudgeted();
     void makeUnbudgeted();
 
 #ifdef SK_DEBUG
     friend class GrGpu; // for assert in GrGpu to access getGpu
 #endif
 
     static uint32_t CreateUniqueID();
 
-    // We're in an internal doubly linked list owned by GrResourceCache2
+    // We're in an internal doubly linked list owned by GrResourceCache
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource);
 
 
     static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     GrScratchKey                fScratchKey;
     GrContentKey                fContentKey;
 
     // This is not ref'ed but abandon() or release() will be called before the GrGpu object
     // is destroyed. Those calls set will this to NULL.
     GrGpu*                      fGpu;
     mutable size_t              fGpuMemorySize;
 
     LifeCycle                   fLifeCycle;
     const uint32_t              fUniqueID;
 
     SkAutoTUnref<const SkData>  fData;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyIsPurgeable.
 };
 
 #endif