diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 2adc842..464f36d 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -63,11 +63,6 @@
      */
     static GrContext* Create(GrBackend, GrBackendContext, const Options* opts = NULL);
 
-    /**
-     * Only defined in test apps.
-     */
-    static GrContext* CreateMockContext();
-
     virtual ~GrContext();
 
     /**
@@ -983,8 +978,6 @@
 
     GrContext(const Options&); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext);
-    void initMockContext();
-    void initCommon();
 
     void setupDrawBuffer();
 
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index a456a79..5891840 100755
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -121,11 +121,7 @@
     if (NULL == fGpu) {
         return false;
     }
-    this->initCommon();
-    return true;
-}
 
-void GrContext::initCommon() {
     fDrawState = SkNEW(GrDrawState);
     fGpu->setDrawState(fDrawState);
 
@@ -145,6 +141,8 @@
     fDidTestPMConversions = false;
 
     this->setupDrawBuffer();
+
+    return true;
 }
 
 GrContext::~GrContext() {
@@ -158,14 +156,14 @@
         (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
     }
 
-    SkDELETE(fResourceCache2);
+    delete fResourceCache2;
     fResourceCache2 = NULL;
-    SkDELETE(fResourceCache);
+    delete fResourceCache;
     fResourceCache = NULL;
-    SkDELETE(fFontCache);
-    SkDELETE(fDrawBuffer);
-    SkDELETE(fDrawBufferVBAllocPool);
-    SkDELETE(fDrawBufferIBAllocPool);
+    delete fFontCache;
+    delete fDrawBuffer;
+    delete fDrawBufferVBAllocPool;
+    delete fDrawBufferIBAllocPool;
 
     fAARectRenderer->unref();
     fOvalRenderer->unref();
diff --git a/src/gpu/GrTest.cpp b/src/gpu/GrTest.cpp
index efb37ca..6013b16 100644
--- a/src/gpu/GrTest.cpp
+++ b/src/gpu/GrTest.cpp
@@ -40,138 +40,3 @@
 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 onGpuClear(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() {
-    GrContext* 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;
-}
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 44e4180..4e6e281 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -11,7 +11,6 @@
 #include "GrContextFactory.h"
 #include "GrGpu.h"
 #include "GrResourceCache.h"
-#include "GrResourceCache2.h"
 #include "SkCanvas.h"
 #include "SkSurface.h"
 #include "Test.h"
@@ -20,7 +19,9 @@
 static const int gHeight = 480;
 
 ////////////////////////////////////////////////////////////////////////////////
-static void test_cache(skiatest::Reporter* reporter, GrContext* context, SkCanvas* canvas) {
+static void test_cache(skiatest::Reporter* reporter,
+                       GrContext* context,
+                       SkCanvas* canvas) {
     const SkIRect size = SkIRect::MakeWH(gWidth, gHeight);
 
     SkBitmap src;
@@ -70,12 +71,12 @@
         , fCache(NULL)
         , fToDelete(NULL)
         , fSize(size) {
-        ++fNumAlive;
+        ++fAlive;
         this->registerWithCache();
     }
 
     ~TestResource() {
-        --fNumAlive;
+        --fAlive;
         if (fToDelete) {
             // Breaks our little 2-element cycle below.
             fToDelete->setDeleteWhenDestroyed(NULL, NULL);
@@ -91,7 +92,7 @@
 
     size_t gpuMemorySize() const SK_OVERRIDE { return fSize; }
 
-    static int NumAlive() { return fNumAlive; }
+    static int alive() { return fAlive; }
 
     void setDeleteWhenDestroyed(GrResourceCache* cache, TestResource* resource) {
         fCache = cache;
@@ -102,11 +103,11 @@
     GrResourceCache* fCache;
     TestResource* fToDelete;
     size_t fSize;
-    static int fNumAlive;
+    static int fAlive;
 
     typedef GrGpuResource INHERITED;
 };
-int TestResource::fNumAlive = 0;
+int TestResource::fAlive = 0;
 
 static void test_purge_invalidated(skiatest::Reporter* reporter, GrContext* context) {
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
@@ -115,34 +116,31 @@
     keyData.fData64[1] = 18;
     GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
     GrResourceKey key(GrCacheID(domain, keyData), t, 0);
-    
-    context->setResourceCacheLimits(5, 30000);
-    GrResourceCache* cache = context->getResourceCache();
-    cache->purgeAllUnlocked();
-    SkASSERT(0 == cache->getCachedResourceCount() && 0 == cache->getCachedResourceBytes());
+
+    GrResourceCache cache(context->getGpu()->caps(), 5, 30000);
 
     // Add two resources with the same key that delete each other from the cache when destroyed.
     TestResource* a = new TestResource(context->getGpu());
     TestResource* b = new TestResource(context->getGpu());
-    cache->addResource(key, a);
-    cache->addResource(key, b);
+    cache.addResource(key, a);
+    cache.addResource(key, b);
     // Circle back.
-    a->setDeleteWhenDestroyed(cache, b);
-    b->setDeleteWhenDestroyed(cache, a);
+    a->setDeleteWhenDestroyed(&cache, b);
+    b->setDeleteWhenDestroyed(&cache, a);
     a->unref();
     b->unref();
 
     // Add a third independent resource also with the same key.
     GrGpuResource* r = new TestResource(context->getGpu());
-    cache->addResource(key, r);
+    cache.addResource(key, r);
     r->unref();
 
     // Invalidate all three, all three should be purged and destroyed.
-    REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive());
+    REPORTER_ASSERT(reporter, 3 == TestResource::alive());
     const GrResourceInvalidatedMessage msg = { key };
     SkMessageBus<GrResourceInvalidatedMessage>::Post(msg);
-    cache->purgeAsNeeded();
-    REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
+    cache.purgeAsNeeded();
+    REPORTER_ASSERT(reporter, 0 == TestResource::alive());
 }
 
 static void test_cache_delete_on_destruction(skiatest::Reporter* reporter,
@@ -156,44 +154,38 @@
     GrResourceKey key(GrCacheID(domain, keyData), t, 0);
 
     {
-        context->setResourceCacheLimits(3, 30000);
-        GrResourceCache* cache = context->getResourceCache();
-        cache->purgeAllUnlocked();
-        SkASSERT(0 == cache->getCachedResourceCount() && 0 == cache->getCachedResourceBytes());
+        {
+            GrResourceCache cache(context->getGpu()->caps(), 3, 30000);
+            TestResource* a = new TestResource(context->getGpu());
+            TestResource* b = new TestResource(context->getGpu());
+            cache.addResource(key, a);
+            cache.addResource(key, b);
 
-        TestResource* a = new TestResource(context->getGpu());
-        TestResource* b = new TestResource(context->getGpu());
-        cache->addResource(key, a);
-        cache->addResource(key, b);
+            a->setDeleteWhenDestroyed(&cache, b);
+            b->setDeleteWhenDestroyed(&cache, a);
 
-        a->setDeleteWhenDestroyed(cache, b);
-        b->setDeleteWhenDestroyed(cache, a);
-
-        a->unref();
-        b->unref();
-        REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
-        cache->purgeAllUnlocked();
-        REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
+            a->unref();
+            b->unref();
+            REPORTER_ASSERT(reporter, 2 == TestResource::alive());
+        }
+        REPORTER_ASSERT(reporter, 0 == TestResource::alive());
     }
     {
-        context->setResourceCacheLimits(3, 30000);
-        GrResourceCache* cache = context->getResourceCache();
-        cache->purgeAllUnlocked();
-        SkASSERT(0 == cache->getCachedResourceCount() && 0 == cache->getCachedResourceBytes());
+        GrResourceCache cache(context->getGpu()->caps(), 3, 30000);
         TestResource* a = new TestResource(context->getGpu());
         TestResource* b = new TestResource(context->getGpu());
-        cache->addResource(key, a);
-        cache->addResource(key, b);
+        cache.addResource(key, a);
+        cache.addResource(key, b);
 
-        a->setDeleteWhenDestroyed(cache, b);
-        b->setDeleteWhenDestroyed(cache, a);
+        a->setDeleteWhenDestroyed(&cache, b);
+        b->setDeleteWhenDestroyed(&cache, a);
 
         a->unref();
         b->unref();
 
-        cache->deleteResource(a->getCacheEntry());
+        cache.deleteResource(a->getCacheEntry());
 
-        REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
+        REPORTER_ASSERT(reporter, 0 == TestResource::alive());
     }
 }
 
@@ -214,54 +206,48 @@
 
     // Test changing resources sizes (both increase & decrease).
     {
-        context->setResourceCacheLimits(3, 30000);
-        GrResourceCache* cache = context->getResourceCache();
-        cache->purgeAllUnlocked();
-        SkASSERT(0 == cache->getCachedResourceCount() && 0 == cache->getCachedResourceBytes());
+        GrResourceCache cache(context->getGpu()->caps(), 2, 300);
 
         TestResource* a = new TestResource(context->getGpu());
         a->setSize(100); // Test didChangeGpuMemorySize() when not in the cache.
-        cache->addResource(key1, a);
+        cache.addResource(key1, a);
         a->unref();
 
         TestResource* b = new TestResource(context->getGpu());
         b->setSize(100);
-        cache->addResource(key2, b);
+        cache.addResource(key2, b);
         b->unref();
 
-        REPORTER_ASSERT(reporter, 200 == cache->getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 2 == cache->getCachedResourceCount());
+        REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
+        REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
 
-        static_cast<TestResource*>(cache->find(key2))->setSize(200);
-        static_cast<TestResource*>(cache->find(key1))->setSize(50);
+        static_cast<TestResource*>(cache.find(key2))->setSize(200);
+        static_cast<TestResource*>(cache.find(key1))->setSize(50);
 
-        REPORTER_ASSERT(reporter, 250 == cache->getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 2 == cache->getCachedResourceCount());
+        REPORTER_ASSERT(reporter, 250 == cache.getCachedResourceBytes());
+        REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
     }
 
     // Test increasing a resources size beyond the cache budget.
     {
-        context->setResourceCacheLimits(2, 300);
-        GrResourceCache* cache = context->getResourceCache();
-        cache->purgeAllUnlocked();
-        SkASSERT(0 == cache->getCachedResourceCount() && 0 == cache->getCachedResourceBytes());
+        GrResourceCache cache(context->getGpu()->caps(), 2, 300);
 
         TestResource* a = new TestResource(context->getGpu(), 100);
-        cache->addResource(key1, a);
+        cache.addResource(key1, a);
         a->unref();
 
         TestResource* b = new TestResource(context->getGpu(), 100);
-        cache->addResource(key2, b);
+        cache.addResource(key2, b);
         b->unref();
 
-        REPORTER_ASSERT(reporter, 200 == cache->getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 2 == cache->getCachedResourceCount());
+        REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
+        REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
 
-        static_cast<TestResource*>(cache->find(key2))->setSize(201);
-        REPORTER_ASSERT(reporter, !cache->hasKey(key1));
+        static_cast<TestResource*>(cache.find(key2))->setSize(201);
+        REPORTER_ASSERT(reporter, NULL == cache.find(key1));
 
-        REPORTER_ASSERT(reporter, 201 == cache->getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 1 == cache->getCachedResourceCount());
+        REPORTER_ASSERT(reporter, 201 == cache.getCachedResourceBytes());
+        REPORTER_ASSERT(reporter, 1 == cache.getCachedResourceCount());
     }
 }
 
@@ -273,6 +259,10 @@
             continue;
         }
         GrContext* context = factory->get(glType);
+        if (NULL == context) {
+            continue;
+        }
+
         GrSurfaceDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
@@ -280,19 +270,12 @@
         desc.fHeight = gHeight;
         SkImageInfo info = SkImageInfo::MakeN32Premul(gWidth, gHeight);
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, info));
+
         test_cache(reporter, context, surface->getCanvas());
+        test_purge_invalidated(reporter, context);
+        test_cache_delete_on_destruction(reporter, context);
+        test_resource_size_changed(reporter, context);
     }
-
-    // The below tests use a mock context.
-    SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
-    REPORTER_ASSERT(reporter, SkToBool(context));
-    if (NULL == context) {
-        return;
-    }
-
-    test_purge_invalidated(reporter, context);
-    test_cache_delete_on_destruction(reporter, context);
-    test_resource_size_changed(reporter, context);
 }
 
 #endif