Remove GrResourceKey from GrResourceCache

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
@@ skipping 12 matching lines @@
 // The cache listens for these messages to purge junk resources proactively.
 struct GrResourceInvalidatedMessage {
     GrResourceKey key;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrResourceCacheEntry {
 public:
     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(); }
+    static uint32_t Hash(const GrGpuResource* resource) {
+        return static_cast<uint32_t>(reinterpret_cast<intptr_t>(resource));
+    }
 #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 GrGpuResource::didChangeGpuMemorySize,
      *  not directly from here.
      */
     void didChangeResourceSize();
 
 private:
-    GrResourceCacheEntry(GrResourceCache* resourceCache,
-                         const GrResourceKey& key,
-                         GrGpuResource* resource);
+    GrResourceCacheEntry(GrResourceCache*, GrGpuResource*);
     ~GrResourceCacheEntry();
 
     GrResourceCache* fResourceCache;
-    GrResourceKey    fKey;
     GrGpuResource*   fResource;
     size_t           fCachedSize;
-    bool             fIsExclusive;
 
     // Linked list for the LRU ordering.
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrResourceCacheEntry);
 
     friend class GrResourceCache;
     friend class GrContext;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 127 matching lines @@
 
 private:
     void internalDetach(GrResourceCacheEntry*);
     void attachToHead(GrResourceCacheEntry*);
     void purgeInvalidated();
     void internalPurge(int extraCount, size_t extraBytes);
 #ifdef SK_DEBUG
     static size_t countBytes(const SkTInternalLList<GrResourceCacheEntry>& list);
 #endif
 
-    typedef SkTMultiMap<GrResourceCacheEntry, GrResourceKey> CacheMap;
-    CacheMap                                fCache;
-
     // We're an internal doubly linked list
     typedef SkTInternalLList<GrResourceCacheEntry> EntryList;
     EntryList                               fList;
 
     // our budget, used in purgeAsNeeded()
     int                                     fMaxCount;
     size_t                                  fMaxBytes;
 
     // our current stats, related to our budget
 #if GR_CACHE_STATS
     int                                     fHighWaterEntryCount;
     size_t                                  fHighWaterEntryBytes;
 #endif
 
     int                                     fEntryCount;
     size_t                                  fEntryBytes;
 
     // prevents recursive purging
     bool                                    fPurging;
 
     PFOverbudgetCB                          fOverbudgetCB;
     void*                                   fOverbudgetData;
 
     SkAutoTUnref<const GrDrawTargetCaps>    fCaps;
-
-    // Listen for messages that a resource has been invalidated and purge cached junk proactively.
-   typedef  SkMessageBus<GrResourceInvalidatedMessage>::Inbox Inbox;
-   Inbox                                    fInvalidationInbox;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
     class GrAutoResourceCacheValidate {
     public:
         GrAutoResourceCacheValidate(GrResourceCache* cache) : fCache(cache) {
             cache->validate();
         }
         ~GrAutoResourceCacheValidate() {
             fCache->validate();
         }
     private:
         GrResourceCache* fCache;
     };
 #else
     class GrAutoResourceCacheValidate {
     public:
         GrAutoResourceCacheValidate(GrResourceCache*) {}
     };
 #endif
 
 #endif