Reimplement gpu message bus for invalidated bitmap gen IDs

src/gpu/GrResourceCache2.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrResourceCache2.h"
 #include "GrGpuResource.h"  
 
 #include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkMessageBus.h"
 
-DECLARE_SKMESSAGEBUS_MESSAGE(GrResourceInvalidatedMessage);
+DECLARE_SKMESSAGEBUS_MESSAGE(GrContentKeyInvalidatedMessage);
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
     static int32_t gType = INHERITED::kInvalidDomain + 1;
 
     int32_t type = sk_atomic_inc(&gType);
     if (type > SK_MaxU16) {
         SkFAIL("Too many Resource Types");
     }
@@ skipping 186 matching lines @@
         this->validate();
     }
     return resource;
 }
 
 void GrResourceCache2::willRemoveScratchKey(const GrGpuResource* resource) {
     SkASSERT(resource->cacheAccess().getScratchKey().isValid());
     fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
 }
 
+void GrResourceCache2::willRemoveContentKey(const GrGpuResource* resource) {
+    // Someone has a ref to this resource in order to invalidate it. When the ref count reaches
+    // zero we will get a notifyPurgable() and figure out what to do with it.
+    SkASSERT(resource->getContentKey().isValid());
+    fContentHash.remove(resource->getContentKey());
+}
+
 bool GrResourceCache2::didSetContentKey(GrGpuResource* resource) {
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     SkASSERT(resource->getContentKey().isValid());
 
     GrGpuResource* res = fContentHash.find(resource->getContentKey());
     if (NULL != res) {
         return false;
     }
@@ skipping 165 matching lines @@
         }
 
         if (!fNewlyPurgeableResourceWhilePurging && fCount && fOverBudgetCB) {
             (*fOverBudgetCB)(fOverBudgetData);
         }
     } while (fNewlyPurgeableResourceWhilePurging);
     fPurging = false;
     this->validate();
 }
 
+void GrResourceCache2::processInvalidContentKeys(
+    const SkTArray<GrContentKeyInvalidatedMessage>& msgs) {
+    for (int i = 0; i < msgs.count(); ++i) {
+        GrGpuResource* resource = this->findAndRefContentResource(msgs[i].key());
+        if (resource) {
+            resource->cacheAccess().removeContentKey();
+            resource->unref(); // will call notifyPurgeable, if it is indeed now purgeable.
+        }
+    }
+}
+
 #ifdef SK_DEBUG
 void GrResourceCache2::validate() const {
     // Reduce the frequency of validations for large resource counts.
     static SkRandom gRandom;
     int mask = (SkNextPow2(fCount + 1) >> 5) - 1;
     if (~mask && (gRandom.nextU() & mask)) {
         return;
     }
 
     size_t bytes = 0;
@@ skipping 57 matching lines @@
 #endif
     SkASSERT(content == fContentHash.count());
     SkASSERT(scratch + couldBeScratch == fScratchMap.count());
 
     // This assertion is not currently valid because we can be in recursive notifyIsPurgeable()
     // calls. This will be fixed when subresource registration is explicit.
     // bool overBudget = budgetedBytes > fMaxBytes || budgetedCount > fMaxCount;
     // SkASSERT(!overBudget || locked == count || fPurging);
 }
 #endif