Make GrResourceCache dynamically change between LRU and random replacement strategies.

src/gpu/GrDrawingManager.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawingManager.h"
 
 #include "GrContext.h"
@@ skipping 111 matching lines @@
         SkASSERT(fDrawTargets.count() == 1);
         // Clear out this flag so the topological sort's SkTTopoSort_CheckAllUnmarked check
         // won't bark
         fDrawTargets[0]->resetFlag(GrDrawTarget::kWasOutput_Flag);
     }
 #else
     fDrawTargets.reset();
 #endif
 
     fFlushState.reset();
-    // We always have to notify the cache when it requested a flush so it can reset its state.
-    if (flushed || type == GrResourceCache::FlushType::kCacheRequested) {
+    // Avoid notifying the cache about redundant client flushes.

[robertphillips, 2016/09/13 13:05:21]

Should this 'fLastFlushType' be 'type' ?
I guess I'm not groking what's going on here

[bsalomon, 2016/09/13 13:31:32]

Changing it slightly to:

    // Avoid notifying the cache about successive client flushes where no
rendering occurred between
    // them.
    bool skipNotify = false;
    if (!flushed) {
        skipNotify = GrResourceCache::kExternal == fLastFlushType &&
                     GrResourceCache::kExternal == type;
    }


which hopefully is more correct and clear.

[robertphillips, 2016/09/13 13:56:48]

That is far clearer. \o/

+    bool skipNotify = !flushed && GrResourceCache::kExternal != fLastFlushType;
+    if (!skipNotify) {
         fContext->getResourceCache()->notifyFlushOccurred(type);
     }
+    fLastFlushType = type;
     fFlushing = false;
 }
 
 void GrDrawingManager::prepareSurfaceForExternalIO(GrSurface* surface) {
     if (this->wasAbandoned()) {
         return;
     }
     SkASSERT(surface);
     SkASSERT(surface->getContext() == fContext);
 
     if (surface->surfacePriv().hasPendingIO()) {
         this->flush();
+    } else if (GrResourceCache::kExternal != fLastFlushType) {
+        fContext->getResourceCache()->notifyFlushOccurred(GrResourceCache::kExternal);
+        fLastFlushType = GrResourceCache::kExternal;
     }
 
     GrRenderTarget* rt = surface->asRenderTarget();
     if (fContext->getGpu() && rt) {
         fContext->getGpu()->resolveRenderTarget(rt);
     }
 }
 
 GrDrawTarget* GrDrawingManager::newDrawTarget(GrRenderTarget* rt) {
     SkASSERT(fContext);
@@ skipping 81 matching lines @@
                                                         std::move(colorSpace), surfaceProps,
                                                         fContext->getAuditTrail(), fSingleOwner));
         }
     }
 
     return sk_sp<GrDrawContext>(new GrDrawContext(fContext, this, std::move(rt),
                                                   std::move(colorSpace), surfaceProps,
                                                   fContext->getAuditTrail(),
                                                   fSingleOwner));
 }