Reimplement gpu message bus for invalidated bitmap gen IDs

src/gpu/GrResourceCache2.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
 
 #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.
@@ skipping 95 matching lines @@
         return resource;
     }
 
     /**
      * Query whether a content key exists in the cache.
      */
     bool hasContentKey(const GrContentKey& contentKey) const {
         return SkToBool(fContentHash.find(contentKey));
     }
 
+    /** Purges resources to become under budget and processes resources with invalidated content
+        keys. */
+    void purgeAsNeeded() {
+        SkTArray<GrContentKeyInvalidatedMessage> invalidKeyMsgs;
+        fInvalidContentKeyInbox.poll(&invalidKeyMsgs);
+        if (invalidKeyMsgs.count()) {
+            this->processInvalidContentKeys(invalidKeyMsgs);
+        }
+        if (fPurging || (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes)) {
+            return;
+        }
+        this->internalPurgeAsNeeded();
+    }
+
     /** Purges all resources that don't have external owners. */
     void purgeAllUnlocked();
 
     /**
      * The callback function used by the cache when it is still over budget after a purge. The
      * passed in 'data' is the same 'data' handed to setOverbudgetCallback.
      */
     typedef void (*PFOverBudgetCB)(void* data);
 
     /**
@@ skipping 13 matching lines @@
 private:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
     void notifyPurgeable(GrGpuResource*);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     bool didSetContentKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
+    void willRemoveContentKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
     void makeResourceMRU(GrGpuResource*);
     /// @}
 
-    void purgeAsNeeded() {
-        if (fPurging || (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes)) {
-            return;
-        }
-        this->internalPurgeAsNeeded();
-    }
-
     void internalPurgeAsNeeded();
+    void processInvalidContentKeys(const SkTArray<GrContentKeyInvalidatedMessage>&);
 
 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const { return fResources.isInList(r); }
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     class AutoValidate;
 
@@ skipping 12 matching lines @@
         static const GrContentKey& GetKey(const GrGpuResource& r) {
             return r.getContentKey();
         }
 
         static uint32_t Hash(const GrContentKey& key) { return key.hash(); }
     };
     typedef SkTDynamicHash<GrGpuResource, GrContentKey, ContentHashTraits> ContentHash;
 
     typedef SkTInternalLList<GrGpuResource> ResourceList;
 
+    typedef SkMessageBus<GrContentKeyInvalidatedMessage>::Inbox InvalidContentKeyInbox;
+
     ResourceList                        fResources;
     // This map holds all resources that can be used as scratch resources.
     ScratchMap                          fScratchMap;
     // This holds all resources that have content keys.
     ContentHash                         fContentHash;
 
     // our budget, used in purgeAsNeeded()
     int                                 fMaxCount;
     size_t                              fMaxBytes;
 
@@ skipping 12 matching lines @@
     int                                 fBudgetedCount;
     size_t                              fBudgetedBytes;
 
     // prevents recursive purging
     bool                                fPurging;
     bool                                fNewlyPurgeableResourceWhilePurging;
 
     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;
 
+    InvalidContentKeyInbox              fInvalidContentKeyInbox;
+
 };
 
 class GrResourceCache2::ResourceAccess {
 private:
     ResourceAccess(GrResourceCache2* cache) : fCache(cache) { }
     ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
     ResourceAccess& operator=(const ResourceAccess&); // unimpl
 
     /**
      * Insert a resource into the cache.
@@ skipping 21 matching lines @@
      * Called by GrGpuResources when their content keys change.
      *
      * This currently returns a bool and fails when an existing resource has a key that collides
      * with the new content key. In the future it will null out the content key for the existing
      * resource. The failure is a temporary measure taken because duties are split between two
      * cache objects currently.
      */
     bool didSetContentKey(GrGpuResource* resource) { return fCache->didSetContentKey(resource); }
 
     /**
-     * Called by GrGpuResources when the remove their scratch key.
+     * Called by a GrGpuResource when it removes its content key.
+     */
+    void willRemoveContentKey(GrGpuResource* resource) {
+        return fCache->willRemoveContentKey(resource);
+    }
+
+    /**
+     * Called by a GrGpuResource when it removes its scratch key.
      */
     void willRemoveScratchKey(const GrGpuResource* resource) {
         fCache->willRemoveScratchKey(resource);
     }
 
     /**
      * 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;
 
     friend class GrGpuResource; // To access all the proxy inline methods.
     friend class GrResourceCache2; // To create this type.
 };
 
 inline GrResourceCache2::ResourceAccess GrResourceCache2::resourceAccess() {
     return ResourceAccess(this);
 }
 
 #endif