Revert "Add a new GrResourceCache purging mechanism for purging unused resources."

This reverts commit fbb56ce83fc717b7c6722324bbccd1ae73c350a4.

Reason for revert: Chrome's ancient libstdc++ doesn't like use of steady_clock

Original change's description:
> Add a new GrResourceCache purging mechanism for purging unused resources.
> 
> The client may call GrContext::purgeResourceNotUsedSince() with a stead_clock::time_point and all resources that have been purgeable since before that time point are purged.
> 
> This is intended to replace the "max unused flushes" purging mechanism once Chrome adopts it.
> 
> Change-Id: I28881dd2959cc01c0acca81b2d6001ee5626439d
> Reviewed-on: https://skia-review.googlesource.com/8920
> Commit-Queue: Brian Salomon <bsalomon@google.com>
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> Reviewed-by: Eric Karl <ericrk@google.com>
> 

TBR=bsalomon@google.com,robertphillips@google.com,ericrk@google.com,reviews@skia.org,ericrk@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Change-Id: I3baa3b2e80302315b757d4d625732459e13795d4
Reviewed-on: https://skia-review.googlesource.com/10004
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

4 files changed, 2 insertions, 42 deletions

diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index efce0b205c..bcb93b30be 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -193,11 +193,6 @@ void GrContext::freeGpuResources() {
     fResourceCache->purgeAllUnlocked();
 }
 
-void GrContext::purgeResourcesNotUsedSince(std::chrono::steady_clock::time_point purgeTime) {
-    ASSERT_SINGLE_OWNER
-    fResourceCache->purgeResourcesNotUsedSince(purgeTime);
-}
-
 void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
     ASSERT_SINGLE_OWNER
 
diff --git a/src/gpu/GrGpuResourceCacheAccess.h b/src/gpu/GrGpuResourceCacheAccess.h
index e679aff696..e91f899cf2 100644
--- a/src/gpu/GrGpuResourceCacheAccess.h
+++ b/src/gpu/GrGpuResourceCacheAccess.h
@@ -63,10 +63,6 @@ private:
         SkASSERT(fResource->isPurgeable());
         fResource->fExternalFlushCntWhenBecamePurgeable = cnt;
     }
-    void setTimeWhenResourceBecomePurgeable() {
-        SkASSERT(fResource->isPurgeable());
-        fResource->fTimeWhenBecamePurgeable = std::chrono::steady_clock::now();
-    }
     /**
      * Called by the cache to determine whether this resource has been puregable for more than
      * a threshold number of external flushes.
@@ -75,14 +71,6 @@ private:
         SkASSERT(fResource->isPurgeable());
         return fResource->fExternalFlushCntWhenBecamePurgeable;
     }
-    /**
-     * Called by the cache to determine whether this resource should be purged based on the length
-     * of time it has been available for purging.
-     */
-    std::chrono::steady_clock::time_point timeWhenResourceBecamePurgeable() {
-        SkASSERT(fResource->isPurgeable());
-        return fResource->fTimeWhenBecamePurgeable;
-    }
 
     int* accessCacheIndex() const { return &fResource->fCacheArrayIndex; }
 
diff --git a/src/gpu/GrResourceCache.cpp b/src/gpu/GrResourceCache.cpp
index 97d3b96808..9462a7384d 100644
--- a/src/gpu/GrResourceCache.cpp
+++ b/src/gpu/GrResourceCache.cpp
@@ -365,7 +365,6 @@ void GrResourceCache::notifyCntReachedZero(GrGpuResource* resource, uint32_t fla
     this->removeFromNonpurgeableArray(resource);
     fPurgeableQueue.insert(resource);
     resource->cacheAccess().setFlushCntWhenResourceBecamePurgeable(fExternalFlushCnt);
-    resource->cacheAccess().setTimeWhenResourceBecomePurgeable();
 
     if (SkBudgeted::kNo == resource->resourcePriv().isBudgeted()) {
         // Check whether this resource could still be used as a scratch resource.
@@ -505,24 +504,6 @@ void GrResourceCache::purgeAllUnlocked() {
     this->validate();
 }
 
-void GrResourceCache::purgeResourcesNotUsedSince(std::chrono::steady_clock::time_point purgeTime) {
-    while (fPurgeableQueue.count()) {
-        const std::chrono::steady_clock::time_point resourceTime =
-                fPurgeableQueue.peek()->cacheAccess().timeWhenResourceBecamePurgeable();
-        if (resourceTime >= purgeTime) {
-            // Resources were given both LRU timestamps and tagged with a frame number when
-            // they first became purgeable. The LRU timestamp won't change again until the
-            // resource is made non-purgeable again. So, at this point all the remaining
-            // resources in the timestamp-sorted queue will have a frame number >= to this
-            // one.
-            break;
-        }
-        GrGpuResource* resource = fPurgeableQueue.peek();
-        SkASSERT(resource->isPurgeable());
-        resource->cacheAccess().release();
-    }
-}
-
 void GrResourceCache::processInvalidUniqueKeys(
     const SkTArray<GrUniqueKeyInvalidatedMessage>& msgs) {
     for (int i = 0; i < msgs.count(); ++i) {
diff --git a/src/gpu/GrResourceCache.h b/src/gpu/GrResourceCache.h
index aef9a5c8df..5f08a51aa0 100644
--- a/src/gpu/GrResourceCache.h
+++ b/src/gpu/GrResourceCache.h
@@ -50,9 +50,8 @@ public:
     static const int    kDefaultMaxCount            = 2 * (1 << 12);
     // Default maximum number of bytes of gpu memory of budgeted resources in the cache.
     static const size_t kDefaultMaxSize             = 96 * (1 << 20);
-    // Default number of external flushes a budgeted resources can go unused in the cache before it
-    // is purged. Using a value <= 0 disables this feature. This will be removed once Chrome
-    // starts using time-based purging.
+    // Default number of external flushes a budgeted resources can go unused in the cache before it 
+    // is purged. Using a value <= 0 disables this feature.
     static const int    kDefaultMaxUnusedFlushes =
             1  * /* flushes per frame */
             60 * /* fps */
@@ -160,9 +159,6 @@ public:
     /** Purges all resources that don't have external owners. */
     void purgeAllUnlocked();
 
-    /** Purge all resources not used since the passed in time. */
-    void purgeResourcesNotUsedSince(std::chrono::steady_clock::time_point);
-
     /** Returns true if the cache would like a flush to occur in order to make more resources
         purgeable. */
     bool requestsFlush() const { return fRequestFlush; }