Add mock context and use in ResourceCacheTest.

src/gpu/GrTest.cpp

Index: src/gpu/GrTest.cpp
diff --git a/src/gpu/GrTest.cpp b/src/gpu/GrTest.cpp
index 6013b1636bf41a0b012fd37faf82c34e88d1678d..51b0ee9e7415b2544baad1c7a7c87a3286267592 100644
--- a/src/gpu/GrTest.cpp
+++ b/src/gpu/GrTest.cpp
@@ -40,3 +40,139 @@ void GrContext::setMaxTextureSizeOverride(int maxTextureSizeOverride) {
 void GrContext::purgeAllUnlockedResources() {
     fResourceCache->purgeAllUnlocked();
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// Code for the mock context. It's built on a mock GrGpu class that does nothing.
+////
+
+#include "GrBufferAllocPool.h"
+#include "GrInOrderDrawBuffer.h"
+#include "GrGpu.h"
+
+class MockGpu : public GrGpu {
+public:
+    MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrDrawTargetCaps)); }
+    virtual ~MockGpu() { }
+    virtual bool canWriteTexturePixels(const GrTexture*,
+                                       GrPixelConfig srcConfig) const SK_OVERRIDE {
+        return true;
+    }
+
+    virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
+                                           int left, int top,
+                                           int width, int height,
+                                           GrPixelConfig config,
+                                           size_t rowBytes) const SK_OVERRIDE { return false; }
+    virtual void buildProgramDesc(const GrOptDrawState&,
+                                  const GrProgramDesc::DescInfo&,
+                                  GrGpu::DrawType,
+                                  const GrDeviceCoordTexture* dstCopy,
+                                  GrProgramDesc* desc) SK_OVERRIDE { }
+
+    virtual void discard(GrRenderTarget*) SK_OVERRIDE { }
+
+private:
+    virtual void onResetContext(uint32_t resetBits) { };
+    virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc,
+                                       const void* srcData,
+                                       size_t rowBytes)  SK_OVERRIDE {
+        return NULL;
+    }
+
+    virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
+                                                 const void* srcData)  SK_OVERRIDE {
+        return NULL;
+    }
+
+    virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&)  SK_OVERRIDE {
+        return NULL;
+    }
+
+    virtual GrRenderTarget* onWrapBackendRenderTarget(
+                                    const GrBackendRenderTargetDesc&) SK_OVERRIDE {
+        return NULL;
+    }
+
+    virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic)  SK_OVERRIDE {
+        return NULL;
+    }
+
+    virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic)  SK_OVERRIDE {
+        return NULL;
+    }
+
+    virtual void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
+                         bool canIgnoreRect)  SK_OVERRIDE { }
+
+    virtual void onClearStencilClip(GrRenderTarget*,
+                                    const SkIRect& rect,
+                                    bool insideClip)  SK_OVERRIDE { }
+
+                                    virtual void onGpuDraw(const DrawInfo&)  SK_OVERRIDE { }
+    virtual bool onReadPixels(GrRenderTarget* target,
+                              int left, int top, int width, int height,
+                              GrPixelConfig,
+                              void* buffer,
+                              size_t rowBytes)  SK_OVERRIDE {
+        return false;
+    }
+
+    virtual bool onWriteTexturePixels(GrTexture* texture,
+                                      int left, int top, int width, int height,
+                                      GrPixelConfig config, const void* buffer,
+                                      size_t rowBytes)  SK_OVERRIDE {
+        return false;
+    }
+
+    virtual void onResolveRenderTarget(GrRenderTarget* target)  SK_OVERRIDE {
+        return;
+    }
+
+    virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width,
+                                                    int height) SK_OVERRIDE {
+        return false;
+    }
+
+    virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*)  SK_OVERRIDE {
+        return false;
+    }
+
+    virtual bool flushGraphicsState(DrawType,
+                                    const GrClipMaskManager::ScissorState&,
+                                    const GrDeviceCoordTexture* dstCopy)  SK_OVERRIDE {
+        return false;
+    }
+
+    virtual void clearStencil(GrRenderTarget* target)  SK_OVERRIDE  { }
+
+    virtual void didAddGpuTraceMarker() SK_OVERRIDE { }
+    virtual void didRemoveGpuTraceMarker() SK_OVERRIDE { }
+
+    typedef GrGpu INHERITED;
+};
+
+GrContext* GrContext::CreateMockContext() {

[robertphillips, 2014/11/05 18:12:00]

One line ?

[bsalomon, 2014/11/05 19:44:59]

Done.

+    GrContext* context;
+    context = SkNEW_ARGS(GrContext, (Options()));
+
+    context->initMockContext();
+    return context;
+}
+
+void GrContext::initMockContext() {
+    SkASSERT(NULL == fGpu);
+    fGpu = SkNEW_ARGS(MockGpu, (this));
+    SkASSERT(fGpu);
+    this->initCommon();
+
+    // We delete these because we want to test the cache starting with zero resources. Also, none of
+    // these objects are required for any of tests that use this context. TODO: make stop allocating
+    // resources in the buffer pools.
+    SkDELETE(fDrawBuffer);
+    SkDELETE(fDrawBufferVBAllocPool);
+    SkDELETE(fDrawBufferIBAllocPool);
+
+    fDrawBuffer = NULL;
+    fDrawBufferVBAllocPool = NULL;
+    fDrawBufferIBAllocPool = NULL;
+}