Rename GrGpuObject to GrGpuResource

src/gpu/GrResourceCache.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
 #ifndef GrResourceCache_DEFINED
 #define GrResourceCache_DEFINED
 
 #include "GrConfig.h"
 #include "GrTypes.h"
 #include "SkTMultiMap.h"
 #include "GrBinHashKey.h"
 #include "SkMessageBus.h"
 #include "SkTInternalLList.h"
 
-class GrGpuObject;
+class GrGpuResource;
 class GrResourceCache;
 class GrResourceCacheEntry;
 
 class GrResourceKey {
 public:
     static GrCacheID::Domain ScratchDomain() {
         static const GrCacheID::Domain gDomain = GrCacheID::GenerateDomain();
         return gDomain;
     }
 
-    /** Uniquely identifies the GrGpuObject subclass in the key to avoid collisions
+    /** Uniquely identifies the GrGpuResource subclass in the key to avoid collisions
         across resource types. */
     typedef uint8_t ResourceType;
 
-    /** Flags set by the GrGpuObject subclass. */
+    /** Flags set by the GrGpuResource subclass. */
     typedef uint8_t ResourceFlags;
 
     /** Generate a unique ResourceType */
     static ResourceType GenerateResourceType();
 
     /** Creates a key for resource */
     GrResourceKey(const GrCacheID& id, ResourceType type, ResourceFlags flags) {
         this->init(id.getDomain(), id.getKey(), type, flags);
     };
 
@@ skipping 64 matching lines @@
 
 // The cache listens for these messages to purge junk resources proactively.
 struct GrResourceInvalidatedMessage {
     GrResourceKey key;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrResourceCacheEntry {
 public:
-    GrGpuObject* resource() const { return fResource; }
+    GrGpuResource* resource() const { return fResource; }
     const GrResourceKey& key() const { return fKey; }
 
     static const GrResourceKey& GetKey(const GrResourceCacheEntry& e) { return e.key(); }
     static uint32_t Hash(const GrResourceKey& key) { return key.getHash(); }
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     /**
      *  Update the cached size for this entry and inform the resource cache that
-     *  it has changed. Usually invoked from GrGpuObject::didChangeGpuMemorySize,
+     *  it has changed. Usually invoked from GrGpuResource::didChangeGpuMemorySize,
      *  not directly from here.
      */
     void didChangeResourceSize();
 
 private:
     GrResourceCacheEntry(GrResourceCache* resourceCache,
                          const GrResourceKey& key,
-                         GrGpuObject* resource);
+                         GrGpuResource* resource);
     ~GrResourceCacheEntry();
 
     GrResourceCache* fResourceCache;
     GrResourceKey    fKey;

[robertphillips, 2014/07/25 14:58:09]

Fix indent ?

[bsalomon, 2014/07/25 16:16:15]

Done.

-    GrGpuObject*     fResource;
+    GrGpuResource*     fResource;
     size_t           fCachedSize;
     bool             fIsExclusive;
 
     // Linked list for the LRU ordering.
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrResourceCacheEntry);
 
     friend class GrResourceCache;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
- *  Cache of GrGpuObject objects.
+ *  Cache of GrGpuResource objects.
  *
  *  These have a corresponding GrResourceKey, built from 128bits identifying the
  *  resource. Multiple resources can map to same GrResourceKey.
  *
  *  The cache stores the entries in a double-linked list, which is its LRU.
  *  When an entry is "locked" (i.e. given to the caller), it is moved to the
  *  head of the list. If/when we must purge some of the entries, we walk the
  *  list backwards from the tail, since those are the least recently used.
  *
  *  For fast searches, we maintain a hash map based on the GrResourceKey.
  *
  *  It is a goal to make the GrResourceCache the central repository and bookkeeper
- *  of all resources. It should replace the linked list of GrGpuObjects that
+ *  of all resources. It should replace the linked list of GrGpuResources that
  *  GrGpu uses to call abandon/release.
  */
 class GrResourceCache {
 public:
     GrResourceCache(int maxCount, size_t maxBytes);
     ~GrResourceCache();
 
     /**
      *  Return the current resource cache limits.
      *
@@ skipping 55 matching lines @@
      *  Search for an entry with the same Key. If found, return it.
      *  If not found, return null.
      *  If ownershipFlags includes kNoOtherOwners and a resource is returned
      *  then that resource has no other refs to it.
      *  If ownershipFlags includes kHide and a resource is returned then that
      *  resource will not be returned from future 'find' calls until it is
      *  'freed' (and recycled) or makeNonExclusive is called.
      *  For a resource to be completely exclusive to a caller both kNoOtherOwners
      *  and kHide must be specified.
      */
-    GrGpuObject* find(const GrResourceKey& key,
+    GrGpuResource* find(const GrResourceKey& key,

[robertphillips, 2014/07/25 14:58:09]

fix indent ?

[bsalomon, 2014/07/25 16:16:15]

Done.

                       uint32_t ownershipFlags = 0);
 
     /**
      *  Add the new resource to the cache (by creating a new cache entry based
      *  on the provided key and resource).
      *
      *  Ownership of the resource is transferred to the resource cache,
      *  which will unref() it when it is purged or deleted.
      *
      *  If ownershipFlags includes kHide, subsequent calls to 'find' will not
      *  return 'resource' until it is 'freed' (and recycled) or makeNonExclusive
      *  is called.
      */
     void addResource(const GrResourceKey& key,
-                     GrGpuObject* resource,
+                     GrGpuResource* resource,
                      uint32_t ownershipFlags = 0);
 
     /**
      * Determines if the cache contains an entry matching a key. If a matching
      * entry exists but was detached then it will not be found.
      */
     bool hasKey(const GrResourceKey& key) const { return NULL != fCache.find(key); }
 
     /**
      * Hide 'entry' so that future searches will not find it. Such
@@ skipping 119 matching lines @@
         GrResourceCache* fCache;
     };
 #else
     class GrAutoResourceCacheValidate {
     public:
         GrAutoResourceCacheValidate(GrResourceCache*) {}
     };
 #endif
 
 #endif