Restructure flushing relationship between GrContext, GrDrawingManager, and GrResourceCache.

src/gpu/GrResourceCache.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 "GrResourceCache.h"
 
@@ skipping 55 matching lines @@
     , fMaxUnusedFlushes(kDefaultMaxUnusedFlushes)
 #if GR_CACHE_STATS
     , fHighWaterCount(0)
     , fHighWaterBytes(0)
     , fBudgetedHighWaterCount(0)
     , fBudgetedHighWaterBytes(0)
 #endif
     , fBytes(0)
     , fBudgetedCount(0)
     , fBudgetedBytes(0)
-    , fOverBudgetCB(nullptr)
-    , fOverBudgetData(nullptr)
     , fFlushTimestamps(nullptr)
     , fLastFlushTimestampIndex(0)
     , fPreferVRAMUseOverFlushes(caps->preferVRAMUseOverFlushes()) {
     SkDEBUGCODE(fCount = 0;)
     SkDEBUGCODE(fNewlyPurgeableResourceForValidation = nullptr;)
     this->resetFlushTimestamps();
 }
 
 GrResourceCache::~GrResourceCache() {
     this->releaseAll();
@@ skipping 407 matching lines @@
     bool stillOverbudget = this->overBudget();
     while (stillOverbudget && fPurgeableQueue.count()) {
         GrGpuResource* resource = fPurgeableQueue.peek();
         SkASSERT(resource->isPurgeable());
         resource->cacheAccess().release();
         stillOverbudget = this->overBudget();
     }
 
     this->validate();
 
     if (stillOverbudget) {

[robertphillips, 2016/09/02 16:23:06]

GrDrawingManager ?

-        // Despite the purge we're still over budget. Call our over budget callback. If this frees
-        // any resources then we'll get notified and take appropriate action.
-        (*fOverBudgetCB)(fOverBudgetData);
-        this->validate();
+        // Set this so that GrDrawContext will issue a flush to free up resources with pending IO.
+        fRequestFlush = true;
     }
 }
 
 void GrResourceCache::purgeAllUnlocked() {
     // We could disable maintaining the heap property here, but it would add a lot of complexity.
     // Moreover, this is rarely called.
     while (fPurgeableQueue.count()) {
         GrGpuResource* resource = fPurgeableQueue.peek();
         SkASSERT(resource->isPurgeable());
         resource->cacheAccess().release();
@@ skipping 94 matching lines @@
             // count should be the next timestamp we return.
             SkASSERT(fTimestamp == SkToU32(count));
 
             // The historical timestamps of flushes are now invalid.
             this->resetFlushTimestamps();
         }
     }
     return fTimestamp++;
 }
 
-void GrResourceCache::notifyFlushOccurred() {
-    if (fFlushTimestamps) {
-        SkASSERT(SkIsPow2(fMaxUnusedFlushes));
-        fLastFlushTimestampIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
-        // get the timestamp before accessing fFlushTimestamps because getNextTimestamp will
-        // reallocate fFlushTimestamps on timestamp overflow.
-        uint32_t timestamp = this->getNextTimestamp();
-        fFlushTimestamps[fLastFlushTimestampIndex] = timestamp;
-        this->purgeAsNeeded();
+void GrResourceCache::notifyFlushOccurred(FlushType type) {
+    switch (type) {
+        case FlushType::kCacheRequested:
+            SkASSERT(fRequestFlush);
+            fRequestFlush = false;

[robertphillips, 2016/09/02 16:23:06]

pull out purgeAsNeeds calls and just have one at the end?

+            this->purgeAsNeeded();
+            break;
+        case FlushType::kExternal:
+            if (fFlushTimestamps) {
+                SkASSERT(SkIsPow2(fMaxUnusedFlushes));
+                fLastFlushTimestampIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
+                // get the timestamp before accessing fFlushTimestamps because getNextTimestamp will
+                // reallocate fFlushTimestamps on timestamp overflow.
+                uint32_t timestamp = this->getNextTimestamp();
+                fFlushTimestamps[fLastFlushTimestampIndex] = timestamp;
+                this->purgeAsNeeded();
+            }
+            break;
     }
 }
 
 void GrResourceCache::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     for (int i = 0; i < fNonpurgeableResources.count(); ++i) {
         fNonpurgeableResources[i]->dumpMemoryStatistics(traceMemoryDump);
     }
     for (int i = 0; i < fPurgeableQueue.count(); ++i) {
         fPurgeableQueue.at(i)->dumpMemoryStatistics(traceMemoryDump);
     }
@@ skipping 128 matching lines @@
         return true;
     }
     if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index] == resource) {
         return true;
     }
     SkDEBUGFAIL("Resource index should be -1 or the resource should be in the cache.");
     return false;
 }
 
 #endif