Revert of Replace GrResourceCache with GrResourceCache2.

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrSingleTextureEffect.h"
 
 #include "GrAARectRenderer.h"
 #include "GrBufferAllocPool.h"
 #include "GrGpu.h"
 #include "GrGpuResource.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrDistanceFieldTextContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrIndexBuffer.h"
 #include "GrInOrderDrawBuffer.h"
 #include "GrLayerCache.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrPathUtils.h"
+#include "GrResourceCache.h"
 #include "GrResourceCache2.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrStencilBuffer.h"
 #include "GrStencilAndCoverTextContext.h"
 #include "GrStrokeInfo.h"
 #include "GrSurfacePriv.h"
 #include "GrTextStrike.h"
 #include "GrTexturePriv.h"
 #include "GrTraceMarker.h"
 #include "GrTracing.h"
 #include "SkDashPathPriv.h"
 #include "SkConfig8888.h"
 #include "SkGr.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTraceEvent.h"
 
 #ifdef SK_DEBUG
     // change this to a 1 to see notifications when partial coverage fails
     #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
 #else
     #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
 #endif
 
+static const size_t MAX_RESOURCE_CACHE_COUNT = GR_DEFAULT_RESOURCE_CACHE_COUNT_LIMIT;
+static const size_t MAX_RESOURCE_CACHE_BYTES = GR_DEFAULT_RESOURCE_CACHE_MB_LIMIT * 1024 * 1024;
+
 static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 15;
 static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
 
 static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 1 << 11;
 static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 4;
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 
 // Glorified typedef to avoid including GrDrawState.h in GrContext.h
 class GrContext::AutoRestoreEffects : public GrDrawState::AutoRestoreEffects {};
 
+class GrContext::AutoCheckFlush {
+public:
+    AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
+
+    ~AutoCheckFlush() {
+        if (fContext->fFlushToReduceCacheSize) {
+            fContext->flush();
+        }
+    }
+
+private:
+    GrContext* fContext;
+};
+
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext,
                              const Options* opts) {
     GrContext* context;
     if (NULL == opts) {
         context = SkNEW_ARGS(GrContext, (Options()));
     } else {
         context = SkNEW_ARGS(GrContext, (*opts));
     }
 
     if (context->init(backend, backendContext)) {
         return context;
     } else {
         context->unref();
         return NULL;
     }
 }
 
 GrContext::GrContext(const Options& opts) : fOptions(opts) {
     fDrawState = NULL;
     fGpu = NULL;
     fClip = NULL;
     fPathRendererChain = NULL;
     fSoftwarePathRenderer = NULL;
+    fResourceCache = NULL;
     fResourceCache2 = NULL;
     fFontCache = NULL;
     fDrawBuffer = NULL;
     fDrawBufferVBAllocPool = NULL;
     fDrawBufferIBAllocPool = NULL;
+    fFlushToReduceCacheSize = false;
     fAARectRenderer = NULL;
     fOvalRenderer = NULL;
     fViewMatrix.reset();
     fMaxTextureSizeOverride = 1 << 20;
 }
 
 bool GrContext::init(GrBackend backend, GrBackendContext backendContext) {
     SkASSERT(NULL == fGpu);
 
     fGpu = GrGpu::Create(backend, backendContext, this);
     if (NULL == fGpu) {
         return false;
     }
     this->initCommon();
     return true;
 }
 
 void GrContext::initCommon() {
     fDrawState = SkNEW(GrDrawState);
 
+    fResourceCache = SkNEW_ARGS(GrResourceCache, (fGpu->caps(),
+                                                  MAX_RESOURCE_CACHE_COUNT,
+                                                  MAX_RESOURCE_CACHE_BYTES));
+    fResourceCache->setOverbudgetCallback(OverbudgetCB, this);
     fResourceCache2 = SkNEW(GrResourceCache2);
-    fResourceCache2->setOverBudgetCallback(OverBudgetCB, this);
 
     fFontCache = SkNEW_ARGS(GrFontCache, (fGpu));
 
     fLayerCache.reset(SkNEW_ARGS(GrLayerCache, (this)));
 
     fAARectRenderer = SkNEW_ARGS(GrAARectRenderer, (fGpu));
     fOvalRenderer = SkNEW(GrOvalRenderer);
 
     fDidTestPMConversions = false;
 
     this->setupDrawBuffer();
 }
 
 GrContext::~GrContext() {
     if (NULL == fGpu) {
         return;
     }
 
     this->flush();
 
     for (int i = 0; i < fCleanUpData.count(); ++i) {
         (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
     }
 
     SkDELETE(fResourceCache2);
+    fResourceCache2 = NULL;
+    SkDELETE(fResourceCache);
+    fResourceCache = NULL;
     SkDELETE(fFontCache);
     SkDELETE(fDrawBuffer);
     SkDELETE(fDrawBufferVBAllocPool);
     SkDELETE(fDrawBufferIBAllocPool);
 
     fAARectRenderer->unref();
     fOvalRenderer->unref();
 
     fGpu->unref();
     SkSafeUnref(fPathRendererChain);
@@ skipping 18 matching lines @@
 
     delete fDrawBufferVBAllocPool;
     fDrawBufferVBAllocPool = NULL;
 
     delete fDrawBufferIBAllocPool;
     fDrawBufferIBAllocPool = NULL;
 
     fAARectRenderer->reset();
     fOvalRenderer->reset();
 
+    fResourceCache->purgeAllUnlocked();
+
     fFontCache->freeAll();
     fLayerCache->freeAll();
 }
 
 void GrContext::resetContext(uint32_t state) {
     fGpu->markContextDirty(state);
 }
 
 void GrContext::freeGpuResources() {
     this->flush();
 
     if (fDrawBuffer) {
         fDrawBuffer->purgeResources();
     }
 
     fAARectRenderer->reset();
     fOvalRenderer->reset();
 
+    fResourceCache->purgeAllUnlocked();
     fFontCache->freeAll();
     fLayerCache->freeAll();
     // a path renderer may be holding onto resources
     SkSafeSetNull(fPathRendererChain);
     SkSafeSetNull(fSoftwarePathRenderer);
 }
 
 void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
-    if (resourceCount) {
-        *resourceCount = fResourceCache2->getResourceCount();
-    }
-    if (resourceBytes) {
-        *resourceBytes = fResourceCache2->getResourceBytes();
-    }
+  if (resourceCount) {
+    *resourceCount = fResourceCache->getCachedResourceCount();
+  }
+  if (resourceBytes) {
+    *resourceBytes = fResourceCache->getCachedResourceBytes();
+  }
 }
 
 GrTextContext* GrContext::createTextContext(GrRenderTarget* renderTarget,
                                             const SkDeviceProperties&
                                             leakyProperties,
                                             bool enableDistanceFieldFonts) {
     if (fGpu->caps()->pathRenderingSupport() && renderTarget->getStencilBuffer() && 
                                                 renderTarget->isMultisampled()) {
         return GrStencilAndCoverTextContext::Create(this, leakyProperties);
     } 
@@ skipping 17 matching lines @@
 }
 
 bool GrContext::isTextureInCache(const GrSurfaceDesc& desc,
                                  const GrCacheID& cacheID,
                                  const GrTextureParams* params) const {
     GrResourceKey resourceKey = GrTexturePriv::ComputeKey(fGpu, params, desc, cacheID);
     return fResourceCache2->hasContentKey(resourceKey);
 }
 
 void GrContext::addStencilBuffer(GrStencilBuffer* sb) {
-    // TODO: Make GrStencilBuffers use the scratch mechanism rather than content keys.
     ASSERT_OWNED_RESOURCE(sb);
 
     GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(sb->width(),
                                                             sb->height(),
                                                             sb->numSamples());
-    SkAssertResult(sb->cacheAccess().setContentKey(resourceKey));
+    fResourceCache->addResource(resourceKey, sb);
 }
 
 GrStencilBuffer* GrContext::findAndRefStencilBuffer(int width, int height, int sampleCnt) {
     GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(width, height, sampleCnt);
     GrGpuResource* resource = this->findAndRefCachedResource(resourceKey);
     return static_cast<GrStencilBuffer*>(resource);
 }
 
 static void stretch_image(void* dst,
                           int dstW,
@@ skipping 121 matching lines @@
         SkASSERT(!GrPixelConfigIsCompressed(desc.fConfig));
 
         texture = this->createResizedTexture(desc, cacheID,
                                              srcData, rowBytes,
                                              GrTexturePriv::NeedsBilerp(resourceKey));
     } else {
         texture = fGpu->createTexture(desc, srcData, rowBytes);
     }
 
     if (texture) {
-        if (texture->cacheAccess().setContentKey(resourceKey)) {
-            if (cacheKey) {
-                *cacheKey = resourceKey;
-            }
-        } else {
-            texture->unref();
-            texture = NULL;
+        fResourceCache->addResource(resourceKey, texture);
+
+        if (cacheKey) {
+            *cacheKey = resourceKey;
         }
     }
 
     return texture;
 }
 
+GrTexture* GrContext::createNewScratchTexture(const GrSurfaceDesc& desc) {
+    GrTexture* texture = fGpu->createTexture(desc, NULL, 0);
+    if (!texture) {
+        return NULL;
+    }
+    fResourceCache->addResource(texture->cacheAccess().getScratchKey(), texture);
+    return texture;
+}
+
 GrTexture* GrContext::refScratchTexture(const GrSurfaceDesc& inDesc, ScratchTexMatch match,
                                         bool calledDuringFlush) {
     // kNoStencil has no meaning if kRT isn't set.
     SkASSERT((inDesc.fFlags & kRenderTarget_GrSurfaceFlag) ||
              !(inDesc.fFlags & kNoStencil_GrSurfaceFlag));
 
     // Make sure caller has checked for renderability if kRT is set.
     SkASSERT(!(inDesc.fFlags & kRenderTarget_GrSurfaceFlag) ||
              this->isConfigRenderable(inDesc.fConfig, inDesc.fSampleCnt > 0));
 
@@ skipping 14 matching lines @@
             uint32_t scratchFlags = 0;
             if (calledDuringFlush) {
                 scratchFlags = GrResourceCache2::kRequireNoPendingIO_ScratchFlag;
             } else  if (!(desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
                 // If it is not a render target then it will most likely be populated by
                 // writePixels() which will trigger a flush if the texture has pending IO.
                 scratchFlags = GrResourceCache2::kPreferNoPendingIO_ScratchFlag;
             }
             GrGpuResource* resource = fResourceCache2->findAndRefScratchResource(key, scratchFlags);
             if (resource) {
+                fResourceCache->makeResourceMRU(resource);
                 return static_cast<GrSurface*>(resource)->asTexture();
             }
 
             if (kExact_ScratchTexMatch == match) {
                 break;
             }
             // We had a cache miss and we are in approx mode, relax the fit of the flags.
 
             // We no longer try to reuse textures that were previously used as render targets in
             // situations where no RT is needed; doing otherwise can confuse the video driver and
             // cause significant performance problems in some cases.
             if (desc->fFlags & kNoStencil_GrSurfaceFlag) {
                 desc.writable()->fFlags = desc->fFlags & ~kNoStencil_GrSurfaceFlag;
             } else {
                 break;
             }
 
         } while (true);
 
         desc.writable()->fFlags = origFlags;
     }
 
-    GrTexture* texture = fGpu->createTexture(*desc, NULL, 0);
+    GrTexture* texture = this->createNewScratchTexture(*desc);
     SkASSERT(NULL == texture || 
              texture->cacheAccess().getScratchKey() == GrTexturePriv::ComputeScratchKey(*desc));
     return texture;
 }
 
-void GrContext::OverBudgetCB(void* data) {
+bool GrContext::OverbudgetCB(void* data) {
+    SkASSERT(data);
+
+    GrContext* context = reinterpret_cast<GrContext*>(data);
+
     // Flush the InOrderDrawBuffer to possibly free up some textures
-    SkASSERT(data);
-    GrContext* context = reinterpret_cast<GrContext*>(data);
-    context->flush();
+    context->fFlushToReduceCacheSize = true;
+
+    return true;
 }
 
 
 GrTexture* GrContext::createUncachedTexture(const GrSurfaceDesc& descIn,
                                             void* srcData,
                                             size_t rowBytes) {
     GrSurfaceDesc descCopy = descIn;
     return fGpu->createTexture(descCopy, srcData, rowBytes);
 }
 
 void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
-    if (maxTextures) {
-        *maxTextures = fResourceCache2->getMaxResourceCount();
-    }
-    if (maxTextureBytes) {
-        *maxTextureBytes = fResourceCache2->getMaxResourceBytes();
-    }
+    fResourceCache->getLimits(maxTextures, maxTextureBytes);
 }
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
-    fResourceCache2->setLimits(maxTextures, maxTextureBytes);
+    fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 int GrContext::getMaxTextureSize() const {
     return SkTMin(fGpu->caps()->maxTextureSize(), fMaxTextureSizeOverride);
 }
 
 int GrContext::getMaxRenderTargetSize() const {
     return fGpu->caps()->maxRenderTargetSize();
 }
 
@@ skipping 35 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::clear(const SkIRect* rect,
                       const GrColor color,
                       bool canIgnoreRect,
                       GrRenderTarget* renderTarget) {
     ASSERT_OWNED_RESOURCE(renderTarget);
     SkASSERT(renderTarget);
 
     AutoRestoreEffects are;
+    AutoCheckFlush acf(this);
     GR_CREATE_TRACE_MARKER_CONTEXT("GrContext::clear", this);
-    GrDrawTarget* target = this->prepareToDraw(NULL, &are);
+    GrDrawTarget* target = this->prepareToDraw(NULL, &are, &acf);
     if (NULL == target) {
         return;
     }
     target->clear(rect, color, canIgnoreRect, renderTarget);
 }
 
 void GrContext::drawPaint(const GrPaint& origPaint) {
     // set rect to be big enough to fill the space, but not super-huge, so we
     // don't overflow fixed-point implementations
     SkRect r;
@@ skipping 111 matching lines @@
                          const SkRect& rect,
                          const GrStrokeInfo* strokeInfo) {
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
         path.addRect(rect);
         this->drawPath(paint, path, *strokeInfo);
         return;
     }
 
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRect", target);
     SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getStrokeRec().getWidth();
     SkMatrix matrix = target->drawState()->getViewMatrix();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
@@ skipping 89 matching lines @@
         // filled BW rect
         target->drawSimpleRect(rect);
     }
 }
 
 void GrContext::drawRectToRect(const GrPaint& paint,
                                const SkRect& dstRect,
                                const SkRect& localRect,
                                const SkMatrix* localMatrix) {
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRectToRect", target);
 
     target->drawRect(dstRect, &localRect, localMatrix);
 }
 
 namespace {
@@ skipping 42 matching lines @@
 
 void GrContext::drawVertices(const GrPaint& paint,
                              GrPrimitiveType primitiveType,
                              int vertexCount,
                              const SkPoint positions[],
                              const SkPoint texCoords[],
                              const GrColor colors[],
                              const uint16_t indices[],
                              int indexCount) {
     AutoRestoreEffects are;
-    GrDrawTarget::AutoReleaseGeometry geo;
+    AutoCheckFlush acf(this);
+    GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope
 
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
     if (NULL == target) {
         return;
     }
     GrDrawState* drawState = target->drawState();
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     int colorOffset = -1, texOffset = -1;
     set_vertex_attributes(drawState, texCoords, colors, &colorOffset, &texOffset);
 
@@ skipping 39 matching lines @@
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.addRRect(rrect);
         this->drawPath(paint, path, strokeInfo);
         return;
     }
 
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     if (!fOvalRenderer->drawRRect(target, this, paint.isAntiAlias(), rrect, strokeRec)) {
         SkPath path;
         path.addRRect(rrect);
         this->internalDrawPath(target, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(const GrPaint& paint,
                            const SkRRect& outer,
                            const SkRRect& inner) {
     if (outer.isEmpty()) {
        return;
     }
 
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
 
     GR_CREATE_TRACE_MARKER("GrContext::drawDRRect", target);
 
     if (!fOvalRenderer->drawDRRect(target, this, paint.isAntiAlias(), outer, inner)) {
         SkPath path;
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
@@ skipping 11 matching lines @@
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.addOval(oval);
         this->drawPath(paint, path, strokeInfo);
         return;
     }
 
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
 
     if (!fOvalRenderer->drawOval(target, this, paint.isAntiAlias(), oval, strokeRec)) {
@@ skipping 66 matching lines @@
        if (path.isInverseFillType()) {
            this->drawPaint(paint);
        }
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPoint pts[2];
         if (path.isLine(pts)) {
             AutoRestoreEffects are;
-            GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+            AutoCheckFlush acf(this);
+            GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
             if (NULL == target) {
                 return;
             }
             GrDrawState* drawState = target->drawState();
 
             SkMatrix origViewMatrix = drawState->getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
             if (avmr.setIdentity(target->drawState())) {
                 if (GrDashingEffect::DrawDashLine(pts, paint, strokeInfo, fGpu, target,
                                                   origViewMatrix)) {
@@ skipping 15 matching lines @@
         this->drawPath(paint, path, newStrokeInfo);
         return;
     }
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
     if (NULL == target) {
         return;
     }
     GrDrawState* drawState = target->drawState();
 
     GR_CREATE_TRACE_MARKER1("GrContext::drawPath", target, "Is Convex", path.isConvex());
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     bool useCoverageAA = paint.isAntiAlias() && !drawState->getRenderTarget()->isMultisampled();
@@ skipping 81 matching lines @@
 void GrContext::flush(int flagsBitfield) {
     if (NULL == fDrawBuffer) {
         return;
     }
 
     if (kDiscard_FlushBit & flagsBitfield) {
         fDrawBuffer->reset();
     } else {
         fDrawBuffer->flush();
     }
+    fResourceCache->purgeAsNeeded();
+    fFlushToReduceCacheSize = false;
 }
 
 bool sw_convert_to_premul(GrPixelConfig srcConfig, int width, int height, size_t inRowBytes,
                           const void* inPixels, size_t outRowBytes, void* outPixels) {
     SkSrcPixelInfo srcPI;
     if (!GrPixelConfig2ColorType(srcConfig, &srcPI.fColorType)) {
         return false;
     }
     srcPI.fAlphaType = kUnpremul_SkAlphaType;
     srcPI.fPixels = inPixels;
@@ skipping 99 matching lines @@
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
 
     // This function can be called in the midst of drawing another object (e.g., when uploading a
     // SW-rasterized clip while issuing a draw). So we push the current geometry state before
     // drawing a rect to the render target.
     // The bracket ensures we pop the stack if we wind up flushing below.
     {
-        GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL);
+        GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL);
         GrDrawTarget::AutoGeometryAndStatePush agasp(drawTarget, GrDrawTarget::kReset_ASRInit,
                                                      &matrix);
         GrDrawState* drawState = drawTarget->drawState();
         drawState->addColorProcessor(fp);
         drawState->setRenderTarget(renderTarget);
         drawState->disableState(GrDrawState::kClip_StateBit);
         drawTarget->drawSimpleRect(SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)));
     }
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
@@ skipping 159 matching lines @@
     GrRenderTarget* rt = surface->asRenderTarget();
     if (fGpu && rt) {
         fGpu->resolveRenderTarget(rt);
     }
 }
 
 void GrContext::discardRenderTarget(GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     ASSERT_OWNED_RESOURCE(renderTarget);
     AutoRestoreEffects are;
-    GrDrawTarget* target = this->prepareToDraw(NULL, &are);
+    AutoCheckFlush acf(this);
+    GrDrawTarget* target = this->prepareToDraw(NULL, &are, &acf);
     if (NULL == target) {
         return;
     }
     target->discard(renderTarget);
 }
 
 void GrContext::copySurface(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
                             const SkIPoint& dstPoint, uint32_t pixelOpsFlags) {
     if (NULL == src || NULL == dst) {
         return;
     }
     ASSERT_OWNED_RESOURCE(src);
     ASSERT_OWNED_RESOURCE(dst);
 
     // Since we're going to the draw target and not GPU, no need to check kNoFlush
     // here.
 
-    GrDrawTarget* target = this->prepareToDraw(NULL, NULL);
+    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, NULL);
     if (NULL == target) {
         return;
     }
     target->copySurface(dst, src, srcRect, dstPoint);
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flush();
     }
 }
 
 void GrContext::flushSurfaceWrites(GrSurface* surface) {
     if (surface->surfacePriv().hasPendingWrite()) {
         this->flush();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-GrDrawTarget* GrContext::prepareToDraw(const GrPaint* paint, AutoRestoreEffects* are) {
+GrDrawTarget* GrContext::prepareToDraw(const GrPaint* paint,
+                                       AutoRestoreEffects* are,
+                                       AutoCheckFlush* acf) {
     // All users of this draw state should be freeing up all effects when they're done.
     // Otherwise effects that own resources may keep those resources alive indefinitely.
     SkASSERT(0 == fDrawState->numColorStages() && 0 == fDrawState->numCoverageStages() &&
              !fDrawState->hasGeometryProcessor());
 
     if (NULL == fGpu) {
         return NULL;
     }
 
     ASSERT_OWNED_RESOURCE(fRenderTarget.get());
     if (paint) {
         SkASSERT(are);
+        SkASSERT(acf);
         are->set(fDrawState);
         fDrawState->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
 #if GR_DEBUG_PARTIAL_COVERAGE_CHECK
         if ((paint->hasMask() || 0xff != paint->fCoverage) &&
             !fDrawState->couldApplyCoverage(fGpu->caps())) {
             SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
         }
 #endif
         // Clear any vertex attributes configured for the previous use of the
         // GrDrawState which can effect which blend optimizations are in effect.
@@ skipping 79 matching lines @@
                                    DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS));
 
     fDrawBuffer = SkNEW_ARGS(GrInOrderDrawBuffer, (fGpu,
                                                    fDrawBufferVBAllocPool,
                                                    fDrawBufferIBAllocPool));
 
     fDrawBuffer->setDrawState(fDrawState);
 }
 
 GrDrawTarget* GrContext::getTextTarget() {
-    return this->prepareToDraw(NULL, NULL);
+    return this->prepareToDraw(NULL, NULL, NULL);
 }
 
 const GrIndexBuffer* GrContext::getQuadIndexBuffer() const {
     return fGpu->getQuadIndexBuffer();
 }
 
 namespace {
 void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) {
     GrConfigConversionEffect::PMConversion pmToUPM;
     GrConfigConversionEffect::PMConversion upmToPM;
@@ skipping 29 matching lines @@
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
         return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM, matrix);
     } else {
         return NULL;
     }
 }
 
 void GrContext::addResourceToCache(const GrResourceKey& resourceKey, GrGpuResource* resource) {
-    resource->cacheAccess().setContentKey(resourceKey);
+    fResourceCache->addResource(resourceKey, resource);
 }
 
 GrGpuResource* GrContext::findAndRefCachedResource(const GrResourceKey& resourceKey) {
-    return fResourceCache2->findAndRefContentResource(resourceKey);
+    GrGpuResource* resource = fResourceCache2->findAndRefContentResource(resourceKey);
+    if (resource) {
+        fResourceCache->makeResourceMRU(resource);
+    }
+    return resource;
 }
 
 void GrContext::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->addGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->addGpuTraceMarker(marker);
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
-    fResourceCache2->printStats();
+    fResourceCache->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif