Revert of 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();
 
-    /** Returns true if the cache would like a flush to occur in order to make more resources
-        purgeable. */
-    bool requestsFlush() const { return fRequestFlush; }
+    /**
+     * 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);
 
-    enum FlushType {
-        kExternal,
-        kImmediateMode,
-        kCacheRequested,
-    };
-    void notifyFlushOccurred(FlushType);
+    /**
+     * 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();
 
 #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;
 
-    bool                                fRequestFlush;
+    PFOverBudgetCB                      fOverBudgetCB;
+    void*                               fOverBudgetData;
 
     // 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