Add support for creating texture backed images where Skia will delete the texture.

src/gpu/GrTest.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTest.h"
 #include "GrContextOptions.h"
@@ skipping 61 matching lines @@
 #endif
 
 #if GR_CACHE_STATS
 void GrResourceCache::dumpStats(SkString* out) const {
     this->validate();
 
     int locked = fNonpurgeableResources.count();
 
     struct Stats {
         int fScratch;
-        int fWrapped;
+        int fExternal;
+        int fBorrowed;
+        int fAdopted;
         size_t fUnbudgetedSize;
 
-        Stats() : fScratch(0), fWrapped(0), fUnbudgetedSize(0) {}
+        Stats() : fScratch(0), fExternal(0), fBorrowed(0), fAdopted(0), fUnbudgetedSize(0) {}
 
         void update(GrGpuResource* resource) {
             if (resource->cacheAccess().isScratch()) {
                 ++fScratch;
             }
-            if (resource->cacheAccess().isWrapped()) {
-                ++fWrapped;
+            if (resource->cacheAccess().isExternal()) {
+                ++fExternal;
+            }
+            if (resource->cacheAccess().isBorrowed()) {
+                ++fBorrowed;
+            }
+            if (resource->cacheAccess().isAdopted()) {
+                ++fAdopted;
             }
             if (!resource->resourcePriv().isBudgeted()) {
                 fUnbudgetedSize += resource->gpuMemorySize();
             }
         }
     };
 
     Stats stats;
 
     for (int i = 0; i < fNonpurgeableResources.count(); ++i) {
         stats.update(fNonpurgeableResources[i]);
     }
     for (int i = 0; i < fPurgeableQueue.count(); ++i) {
         stats.update(fPurgeableQueue.at(i));
     }
 
     float countUtilization = (100.f * fBudgetedCount) / fMaxCount;
     float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes;
 
     out->appendf("Budget: %d items %d bytes\n", fMaxCount, (int)fMaxBytes);
     out->appendf("\t\tEntry Count: current %d"
-                 " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",
-                 this->getResourceCount(), fBudgetedCount, stats.fWrapped, locked, stats.fScratch,
-                 countUtilization, fHighWaterCount);
+                 " (%d budgeted, %d external(%d borrowed, %d adopted), %d locked, %d scratch %.2g%% full), high %d\n",
+                 this->getResourceCount(), fBudgetedCount, stats.fExternal, stats.fBorrowed,
+                 stats.fAdopted, locked, stats.fScratch, countUtilization, fHighWaterCount);
     out->appendf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n",
                  SkToInt(fBytes), SkToInt(fBudgetedBytes), byteUtilization,
                  SkToInt(stats.fUnbudgetedSize), SkToInt(fHighWaterBytes));
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrResourceCache::changeTimestamp(uint32_t newTimestamp) { fTimestamp = newTimestamp; }
@@ skipping 45 matching lines @@
     GrTexture* onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle lifeCycle,
                                const void* srcData, size_t rowBytes) override {
         return NULL;
     }
 
     GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle,
                                          const void* srcData) override {
         return NULL;
     }
 
-    GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) override { return NULL; }
+    GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&,
+                                    GrWrapOwnership) override { return NULL; }
 
-    GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override {
+    GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
+                                              GrWrapOwnership) override {
         return NULL;
     }
 
     GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override { return NULL; }
 
     GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override { return NULL; }
 
     void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
                          bool canIgnoreRect) override {}
 
@@ skipping 48 matching lines @@
     SkASSERT(NULL == fGpu);
     fGpu = SkNEW_ARGS(MockGpu, (this, options));
     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.
     fDrawingMgr.abandon();
 }