Restructure flushing relationship between GrContext, GrDrawingManager, and GrResourceCache.

src/gpu/GrResourceCache.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 GrResourceCache_DEFINED
 #define GrResourceCache_DEFINED
 
 #include "GrGpuResource.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrGpuResourcePriv.h"
+#include "GrResourceCache.h"
 #include "GrResourceKey.h"
 #include "SkMessageBus.h"
 #include "SkRefCnt.h"
 #include "SkTArray.h"
 #include "SkTDPQueue.h"
 #include "SkTInternalLList.h"
 #include "SkTMultiMap.h"
 
 class GrCaps;
 class SkString;
@@ skipping 132 matching lines @@
         return SkToBool(fUniqueHash.find(key));
     }
 
     /** Purges resources to become under budget and processes resources with invalidated unique
         keys. */
     void purgeAsNeeded();
 
     /** 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);
+    /** Returns true if the cache would like a flush to occur in order to make more resources
+        purgeable. */
+    bool requestsFlush() const { return fRequestFlush; }
 
-    /**
-     * Set the callback the cache should use when it is still over budget after a purge. The 'data'
-     * provided here will be passed back to the callback. Note that the cache will attempt to purge
-     * any resources newly freed by the callback.
-     */
-    void setOverBudgetCallback(PFOverBudgetCB overBudgetCB, void* data) {
-        fOverBudgetCB = overBudgetCB;
-        fOverBudgetData = data;
-    }
-
-    void notifyFlushOccurred();
+    enum FlushType {
+        kExternal,
+        kCacheRequested,
+    };
+    void notifyFlushOccurred(FlushType);
 
 #if GR_CACHE_STATS
     struct Stats {
         int fTotal;
         int fNumPurgeable;
         int fNumNonPurgeable;
 
         int fScratch;
         int fWrapped;
         size_t fUnbudgetedSize;
@@ skipping 126 matching lines @@
 #endif
 
     // our current stats for all resources
     SkDEBUGCODE(int                     fCount;)
     size_t                              fBytes;
 
     // our current stats for resources that count against the budget
     int                                 fBudgetedCount;
     size_t                              fBudgetedBytes;
 
-    PFOverBudgetCB                      fOverBudgetCB;
-    void*                               fOverBudgetData;
+    bool                                fRequestFlush;
 
     // We keep track of the "timestamps" of the last n flushes. If a resource hasn't been used in
     // that time then we well preemptively purge it to reduce memory usage.
     uint32_t*                           fFlushTimestamps;
     int                                 fLastFlushTimestampIndex;
 
     InvalidUniqueKeyInbox               fInvalidUniqueKeyInbox;
 
     // This resource is allowed to be in the nonpurgeable array for the sake of validate() because
     // we're in the midst of converting it to purgeable status.
@@ skipping 79 matching lines @@
 
     friend class GrGpuResource; // To access all the proxy inline methods.
     friend class GrResourceCache; // To create this type.
 };
 
 inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
     return ResourceAccess(this);
 }
 
 #endif