Require explicit GrWrapCacheable specification in more places.

Make all wrapped resources be kUnbudgetedUncacheable except those
created by AHardwareBuffer image generators and as backings for promise
images.

Make all non-wrapped unbudgeted resources be kUnbudgetedUncacheable.

Update unit tests to mostly use GrWrapCacheable::kNo except where they
are testing the distinction.

Update unit tests for new expectations.
Bug: chromium:922851
Change-Id: I4d3bdaa161ffc76390f26334bcb7e2b47dd9319d
Reviewed-on: https://skia-review.googlesource.com/c/185004
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

33 files changed, 226 insertions, 299 deletions

diff --git a/src/gpu/GrAHardwareBufferImageGenerator.cpp b/src/gpu/GrAHardwareBufferImageGenerator.cpp
index 6ed48fb487..55eab91c6e 100644
--- a/src/gpu/GrAHardwareBufferImageGenerator.cpp
+++ b/src/gpu/GrAHardwareBufferImageGenerator.cpp
@@ -600,8 +600,11 @@ sk_sp<GrTextureProxy> GrAHardwareBufferImageGenerator::makeProxy(GrContext* cont
                 SkASSERT(deleteImageProc && deleteImageCtx);
 
                 backendTex.fConfig = pixelConfig;
+                // We make this texture cacheable to avoid recreating a GrTexture every time this
+                // is invoked. We know the owning SkIamge will send an invalidation message when the
+                // image is destroyed, so the texture will be removed at that time.
                 sk_sp<GrTexture> tex = resourceProvider->wrapBackendTexture(
-                        backendTex, kBorrow_GrWrapOwnership, kRead_GrIOType);
+                        backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kYes, kRead_GrIOType);
                 if (!tex) {
                     deleteImageProc(deleteImageCtx);
                     return sk_sp<GrTexture>();
diff --git a/src/gpu/GrBackendTextureImageGenerator.cpp b/src/gpu/GrBackendTextureImageGenerator.cpp
index 291f013ac1..674ca05854 100644
--- a/src/gpu/GrBackendTextureImageGenerator.cpp
+++ b/src/gpu/GrBackendTextureImageGenerator.cpp
@@ -169,8 +169,8 @@ sk_sp<GrTextureProxy> GrBackendTextureImageGenerator::onGenerateTexture(
                     // ever see the original texture, so this should be safe.
                     // We make the texture uncacheable so that the release proc is called ASAP.
                     tex = resourceProvider->wrapBackendTexture(
-                            backendTexture, kBorrow_GrWrapOwnership, kRead_GrIOType,
-                            GrWrapCacheable::kNo);
+                            backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
+                            kRead_GrIOType);
                     if (!tex) {
                         return sk_sp<GrTexture>();
                     }
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index b0ff64b238..449fe606df 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -947,7 +947,7 @@ sk_sp<GrTextureContext> GrContextPriv::makeBackendTextureContext(const GrBackend
     ASSERT_SINGLE_OWNER_PRIV
 
     sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->wrapBackendTexture(
-            tex, origin, kBorrow_GrWrapOwnership, kRW_GrIOType);
+            tex, origin, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
     if (!proxy) {
         return nullptr;
     }
@@ -964,8 +964,8 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureRenderTargetContex
     ASSERT_SINGLE_OWNER_PRIV
     SkASSERT(sampleCnt > 0);
 
-    sk_sp<GrTextureProxy> proxy(
-            this->proxyProvider()->wrapRenderableBackendTexture(tex, origin, sampleCnt));
+    sk_sp<GrTextureProxy> proxy(this->proxyProvider()->wrapRenderableBackendTexture(
+            tex, origin, sampleCnt, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo));
     if (!proxy) {
         return nullptr;
     }
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index d291c04a43..260ba29ac2 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -164,7 +164,8 @@ sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
 }
 
 sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex,
-                                                     int sampleCnt, GrWrapOwnership ownership) {
+                                                     int sampleCnt, GrWrapOwnership ownership,
+                                                     GrWrapCacheable cacheable) {
     this->handleDirtyContext();
     if (sampleCnt < 1) {
         return nullptr;
@@ -178,7 +179,8 @@ sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& bac
         backendTex.height() > this->caps()->maxRenderTargetSize()) {
         return nullptr;
     }
-    sk_sp<GrTexture> tex = this->onWrapRenderableBackendTexture(backendTex, sampleCnt, ownership);
+    sk_sp<GrTexture> tex =
+            this->onWrapRenderableBackendTexture(backendTex, sampleCnt, ownership, cacheable);
     SkASSERT(!tex || tex->asRenderTarget());
     return tex;
 }
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 34e21c4cf9..04a34f728f 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -110,8 +110,8 @@ public:
     /**
      * Implements GrResourceProvider::wrapRenderableBackendTexture
      */
-    sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture&,
-                                                  int sampleCnt, GrWrapOwnership);
+    sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
+                                                  GrWrapOwnership, GrWrapCacheable);
 
     /**
      * Implements GrResourceProvider::wrapBackendRenderTarget
@@ -459,9 +459,8 @@ private:
 
     virtual sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership,
                                                   GrWrapCacheable, GrIOType) = 0;
-    virtual sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
-                                                            int sampleCnt,
-                                                            GrWrapOwnership) = 0;
+    virtual sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
+                                                            GrWrapOwnership, GrWrapCacheable) = 0;
     virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) = 0;
     virtual sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
                                                                      int sampleCnt) = 0;
diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp
index b3d3b1ddde..c9224be09c 100644
--- a/src/gpu/GrGpuResource.cpp
+++ b/src/gpu/GrGpuResource.cpp
@@ -26,15 +26,15 @@ GrGpuResource::GrGpuResource(GrGpu* gpu) : fGpu(gpu), fUniqueID(CreateUniqueID()
 }
 
 void GrGpuResource::registerWithCache(SkBudgeted budgeted) {
-    SkASSERT(fBudgetedType == GrBudgetedType::kUnbudgetedCacheable);
+    SkASSERT(fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable);
     fBudgetedType = budgeted == SkBudgeted::kYes ? GrBudgetedType::kBudgeted
-                                                 : GrBudgetedType::kUnbudgetedCacheable;
+                                                 : GrBudgetedType::kUnbudgetedUncacheable;
     this->computeScratchKey(&fScratchKey);
     get_resource_cache(fGpu)->resourceAccess().insertResource(this);
 }
 
 void GrGpuResource::registerWithCacheWrapped(GrWrapCacheable wrapType) {
-    SkASSERT(fBudgetedType == GrBudgetedType::kUnbudgetedCacheable);
+    SkASSERT(fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable);
     // Resources referencing wrapped objects are never budgeted. They may be cached or uncached.
     fBudgetedType = wrapType == GrWrapCacheable::kNo ? GrBudgetedType::kUnbudgetedUncacheable
                                                      : GrBudgetedType::kUnbudgetedCacheable;
@@ -188,9 +188,9 @@ void GrGpuResource::removeScratchKey() {
 void GrGpuResource::makeBudgeted() {
     // We should never make a wrapped resource budgeted.
     SkASSERT(!fRefsWrappedObjects);
-    // Only wrapped resources can be in the kUnbudgetedUncacheable state.
-    SkASSERT(fBudgetedType != GrBudgetedType::kUnbudgetedUncacheable);
-    if (!this->wasDestroyed() && fBudgetedType == GrBudgetedType::kUnbudgetedCacheable) {
+    // Only wrapped resources can be in the kUnbudgetedCacheable state.
+    SkASSERT(fBudgetedType != GrBudgetedType::kUnbudgetedCacheable);
+    if (!this->wasDestroyed() && fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable) {
         // Currently resources referencing wrapped objects are not budgeted.
         fBudgetedType = GrBudgetedType::kBudgeted;
         get_resource_cache(fGpu)->resourceAccess().didChangeBudgetStatus(this);
@@ -200,7 +200,7 @@ void GrGpuResource::makeBudgeted() {
 void GrGpuResource::makeUnbudgeted() {
     if (!this->wasDestroyed() && fBudgetedType == GrBudgetedType::kBudgeted &&
         !fUniqueKey.isValid()) {
-        fBudgetedType = GrBudgetedType::kUnbudgetedCacheable;
+        fBudgetedType = GrBudgetedType::kUnbudgetedUncacheable;
         get_resource_cache(fGpu)->resourceAccess().didChangeBudgetStatus(this);
     }
 }
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index 978da53caf..f13cf7c0ac 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -451,6 +451,7 @@ sk_sp<GrTextureProxy> GrProxyProvider::createProxy(sk_sp<SkData> data, const GrS
 sk_sp<GrTextureProxy> GrProxyProvider::wrapBackendTexture(const GrBackendTexture& backendTex,
                                                           GrSurfaceOrigin origin,
                                                           GrWrapOwnership ownership,
+                                                          GrWrapCacheable cacheable,
                                                           GrIOType ioType,
                                                           ReleaseProc releaseProc,
                                                           ReleaseContext releaseCtx) {
@@ -464,8 +465,8 @@ sk_sp<GrTextureProxy> GrProxyProvider::wrapBackendTexture(const GrBackendTexture
         return nullptr;
     }
 
-    sk_sp<GrTexture> tex = fResourceProvider->wrapBackendTexture(backendTex, ownership, ioType,
-                                                                 GrWrapCacheable::kYes);
+    sk_sp<GrTexture> tex =
+            fResourceProvider->wrapBackendTexture(backendTex, ownership, cacheable, ioType);
     if (!tex) {
         return nullptr;
     }
@@ -486,7 +487,7 @@ sk_sp<GrTextureProxy> GrProxyProvider::wrapBackendTexture(const GrBackendTexture
 
 sk_sp<GrTextureProxy> GrProxyProvider::wrapRenderableBackendTexture(
         const GrBackendTexture& backendTex, GrSurfaceOrigin origin, int sampleCnt,
-        GrWrapOwnership ownership) {
+        GrWrapOwnership ownership, GrWrapCacheable cacheable) {
     if (this->isAbandoned()) {
         return nullptr;
     }
@@ -501,8 +502,8 @@ sk_sp<GrTextureProxy> GrProxyProvider::wrapRenderableBackendTexture(
         return nullptr;
     }
 
-    sk_sp<GrTexture> tex =
-            fResourceProvider->wrapRenderableBackendTexture(backendTex, sampleCnt, ownership);
+    sk_sp<GrTexture> tex = fResourceProvider->wrapRenderableBackendTexture(backendTex, sampleCnt,
+                                                                           ownership, cacheable);
     if (!tex) {
         return nullptr;
     }
diff --git a/src/gpu/GrProxyProvider.h b/src/gpu/GrProxyProvider.h
index 1abb49fd3c..f84cdfc40b 100644
--- a/src/gpu/GrProxyProvider.h
+++ b/src/gpu/GrProxyProvider.h
@@ -113,16 +113,15 @@ public:
      * kRead or kRW.
      */
     sk_sp<GrTextureProxy> wrapBackendTexture(const GrBackendTexture&, GrSurfaceOrigin,
-                                             GrWrapOwnership, GrIOType, ReleaseProc = nullptr,
-                                             ReleaseContext = nullptr);
+                                             GrWrapOwnership, GrWrapCacheable, GrIOType,
+                                             ReleaseProc = nullptr, ReleaseContext = nullptr);
 
     /*
      * Create a texture proxy that wraps a backend texture and is both texture-able and renderable
      */
-    sk_sp<GrTextureProxy> wrapRenderableBackendTexture(const GrBackendTexture&,
-                                                       GrSurfaceOrigin,
-                                                       int sampleCnt,
-                                                       GrWrapOwnership = kBorrow_GrWrapOwnership);
+    sk_sp<GrTextureProxy> wrapRenderableBackendTexture(const GrBackendTexture&, GrSurfaceOrigin,
+                                                       int sampleCnt, GrWrapOwnership,
+                                                       GrWrapCacheable);
 
     /*
      * Create a render target proxy that wraps a backend render target
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index c996494f55..3e7d2c7142 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -235,8 +235,8 @@ sk_sp<GrTexture> GrResourceProvider::refScratchTexture(const GrSurfaceDesc& desc
 
 sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTexture& tex,
                                                         GrWrapOwnership ownership,
-                                                        GrIOType ioType,
-                                                        GrWrapCacheable cacheable) {
+                                                        GrWrapCacheable cacheable,
+                                                        GrIOType ioType) {
     ASSERT_SINGLE_OWNER
     if (this->isAbandoned()) {
         return nullptr;
@@ -246,12 +246,13 @@ sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTexture&
 
 sk_sp<GrTexture> GrResourceProvider::wrapRenderableBackendTexture(const GrBackendTexture& tex,
                                                                   int sampleCnt,
-                                                                  GrWrapOwnership ownership) {
+                                                                  GrWrapOwnership ownership,
+                                                                  GrWrapCacheable cacheable) {
     ASSERT_SINGLE_OWNER
     if (this->isAbandoned()) {
         return nullptr;
     }
-    return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, ownership);
+    return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, ownership, cacheable);
 }
 
 sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendRenderTarget(
diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h
index 83640496e7..37d094c9cf 100644
--- a/src/gpu/GrResourceProvider.h
+++ b/src/gpu/GrResourceProvider.h
@@ -106,10 +106,8 @@ public:
      *
      * @return GrTexture object or NULL on failure.
      */
-    sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture& tex,
-                                        GrWrapOwnership /* = kBorrow_GrWrapOwnership*/,
-                                        GrIOType,
-                                        GrWrapCacheable = GrWrapCacheable::kYes);
+    sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture& tex, GrWrapOwnership,
+                                        GrWrapCacheable, GrIOType);
 
     /**
      * This makes the backend texture be renderable. If sampleCnt is > 1 and the underlying API
@@ -118,14 +116,15 @@ public:
      */
     sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture& tex,
                                                   int sampleCnt,
-                                                  GrWrapOwnership = kBorrow_GrWrapOwnership);
+                                                  GrWrapOwnership,
+                                                  GrWrapCacheable);
 
     /**
      * Wraps an existing render target with a GrRenderTarget object. It is
      * similar to wrapBackendTexture but can be used to draw into surfaces
      * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
      * the client will resolve to a texture). Currently wrapped render targets
-     * always use the kBorrow_GrWrapOwnership semantics.
+     * always use the kBorrow_GrWrapOwnership and GrWrapCacheable::kNo semantics.
      *
      * @return GrRenderTarget object or NULL on failure.
      */
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 5cca23a248..34b27d2136 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -687,7 +687,8 @@ sk_sp<GrTexture> GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTe
 
 sk_sp<GrTexture> GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
                                                          int sampleCnt,
-                                                         GrWrapOwnership ownership) {
+                                                         GrWrapOwnership ownership,
+                                                         GrWrapCacheable cacheable) {
     GrGLTexture::IDDesc idDesc;
     if (!check_backend_texture(backendTex, this->glCaps(), &idDesc)) {
         return nullptr;
@@ -725,8 +726,8 @@ sk_sp<GrTexture> GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture&
     GrMipMapsStatus mipMapsStatus = backendTex.hasMipMaps() ? GrMipMapsStatus::kDirty
                                                             : GrMipMapsStatus::kNotAllocated;
 
-    sk_sp<GrGLTextureRenderTarget> texRT(
-            GrGLTextureRenderTarget::MakeWrapped(this, surfDesc, idDesc, rtIDDesc, mipMapsStatus));
+    sk_sp<GrGLTextureRenderTarget> texRT(GrGLTextureRenderTarget::MakeWrapped(
+            this, surfDesc, idDesc, rtIDDesc, cacheable, mipMapsStatus));
     texRT->baseLevelWasBoundToFBO();
     // We don't know what parameters are already set on wrapped textures.
     texRT->textureParamsModified();
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 1987a28445..e9c840d3e3 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -191,9 +191,8 @@ private:
 
     sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership, GrWrapCacheable,
                                           GrIOType) override;
-    sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
-                                                    int sampleCnt,
-                                                    GrWrapOwnership) override;
+    sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
+                                                    GrWrapOwnership, GrWrapCacheable) override;
     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
     sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
                                                              int sampleCnt) override;
diff --git a/src/gpu/gl/GrGLRenderTarget.cpp b/src/gpu/gl/GrGLRenderTarget.cpp
index 5e0a2fbd5f..f2913f3b18 100644
--- a/src/gpu/gl/GrGLRenderTarget.cpp
+++ b/src/gpu/gl/GrGLRenderTarget.cpp
@@ -28,7 +28,7 @@ GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu,
     , INHERITED(gpu, desc, stencil) {
     this->setFlags(gpu->glCaps(), idDesc);
     this->init(desc, format, idDesc);
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
 GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu, const GrSurfaceDesc& desc, GrGLenum format,
diff --git a/src/gpu/gl/GrGLSemaphore.cpp b/src/gpu/gl/GrGLSemaphore.cpp
index b557efb127..d594dc8df6 100644
--- a/src/gpu/gl/GrGLSemaphore.cpp
+++ b/src/gpu/gl/GrGLSemaphore.cpp
@@ -11,7 +11,8 @@
 
 GrGLSemaphore::GrGLSemaphore(GrGLGpu* gpu, bool isOwned)
         : INHERITED(gpu), fSync(0), fIsOwned(isOwned) {
-    isOwned ? this->registerWithCache(SkBudgeted::kNo) : this->registerWithCacheWrapped();
+    isOwned ? this->registerWithCache(SkBudgeted::kNo)
+            : this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
 void GrGLSemaphore::onRelease() {
diff --git a/src/gpu/gl/GrGLTextureRenderTarget.cpp b/src/gpu/gl/GrGLTextureRenderTarget.cpp
index 04f8ffc1f1..17dc56220b 100644
--- a/src/gpu/gl/GrGLTextureRenderTarget.cpp
+++ b/src/gpu/gl/GrGLTextureRenderTarget.cpp
@@ -28,11 +28,12 @@ GrGLTextureRenderTarget::GrGLTextureRenderTarget(GrGLGpu* gpu,
                                                  const GrSurfaceDesc& desc,
                                                  const GrGLTexture::IDDesc& texIDDesc,
                                                  const GrGLRenderTarget::IDDesc& rtIDDesc,
+                                                 GrWrapCacheable cacheable,
                                                  GrMipMapsStatus mipMapsStatus)
         : GrSurface(gpu, desc)
         , GrGLTexture(gpu, desc, texIDDesc, mipMapsStatus)
         , GrGLRenderTarget(gpu, desc, texIDDesc.fInfo.fFormat, rtIDDesc) {
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(cacheable);
 }
 
 void GrGLTextureRenderTarget::dumpMemoryStatistics(
@@ -56,11 +57,11 @@ bool GrGLTextureRenderTarget::canAttemptStencilAttachment() const {
 }
 
 sk_sp<GrGLTextureRenderTarget> GrGLTextureRenderTarget::MakeWrapped(
-    GrGLGpu* gpu, const GrSurfaceDesc& desc, const GrGLTexture::IDDesc& texIDDesc,
-    const GrGLRenderTarget::IDDesc& rtIDDesc, GrMipMapsStatus mipMapsStatus)
-{
+        GrGLGpu* gpu, const GrSurfaceDesc& desc, const GrGLTexture::IDDesc& texIDDesc,
+        const GrGLRenderTarget::IDDesc& rtIDDesc, GrWrapCacheable cacheable,
+        GrMipMapsStatus mipMapsStatus) {
     return sk_sp<GrGLTextureRenderTarget>(
-        new GrGLTextureRenderTarget(gpu, desc, texIDDesc, rtIDDesc, mipMapsStatus));
+            new GrGLTextureRenderTarget(gpu, desc, texIDDesc, rtIDDesc, cacheable, mipMapsStatus));
 }
 
 size_t GrGLTextureRenderTarget::onGpuMemorySize() const {
diff --git a/src/gpu/gl/GrGLTextureRenderTarget.h b/src/gpu/gl/GrGLTextureRenderTarget.h
index f33ff2838a..ffb5643449 100644
--- a/src/gpu/gl/GrGLTextureRenderTarget.h
+++ b/src/gpu/gl/GrGLTextureRenderTarget.h
@@ -38,7 +38,7 @@ public:
     static sk_sp<GrGLTextureRenderTarget> MakeWrapped(GrGLGpu* gpu, const GrSurfaceDesc& desc,
                                                       const GrGLTexture::IDDesc& texIDDesc,
                                                       const GrGLRenderTarget::IDDesc& rtIDDesc,
-                                                      GrMipMapsStatus);
+                                                      GrWrapCacheable cacheble, GrMipMapsStatus);
 
     GrBackendFormat backendFormat() const override {
         // It doesn't matter if we take the texture or render target path, so just pick texture.
@@ -62,6 +62,7 @@ private:
                             const GrSurfaceDesc& desc,
                             const GrGLTexture::IDDesc& texIDDesc,
                             const GrGLRenderTarget::IDDesc& rtIDDesc,
+                            GrWrapCacheable,
                             GrMipMapsStatus);
 
     size_t onGpuMemorySize() const override;
diff --git a/src/gpu/mock/GrMockGpu.cpp b/src/gpu/mock/GrMockGpu.cpp
index a2955f5181..8ac7684657 100644
--- a/src/gpu/mock/GrMockGpu.cpp
+++ b/src/gpu/mock/GrMockGpu.cpp
@@ -125,7 +125,8 @@ sk_sp<GrTexture> GrMockGpu::onWrapBackendTexture(const GrBackendTexture& tex,
 
 sk_sp<GrTexture> GrMockGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
                                                            int sampleCnt,
-                                                           GrWrapOwnership ownership) {
+                                                           GrWrapOwnership ownership,
+                                                           GrWrapCacheable cacheable) {
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = tex.width();
@@ -144,7 +145,7 @@ sk_sp<GrTexture> GrMockGpu::onWrapRenderableBackendTexture(const GrBackendTextur
     rtInfo.fID = NextInternalRenderTargetID();
 
     return sk_sp<GrTexture>(
-            new GrMockTextureRenderTarget(this, desc, mipMapsStatus, texInfo, rtInfo));
+            new GrMockTextureRenderTarget(this, desc, mipMapsStatus, texInfo, rtInfo, cacheable));
 }
 
 sk_sp<GrRenderTarget> GrMockGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt) {
diff --git a/src/gpu/mock/GrMockGpu.h b/src/gpu/mock/GrMockGpu.h
index 77090ea5a0..2a79eb05a3 100644
--- a/src/gpu/mock/GrMockGpu.h
+++ b/src/gpu/mock/GrMockGpu.h
@@ -64,7 +64,8 @@ private:
 
     sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
                                                     int sampleCnt,
-                                                    GrWrapOwnership) override;
+                                                    GrWrapOwnership,
+                                                    GrWrapCacheable) override;
 
     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
 
diff --git a/src/gpu/mock/GrMockTexture.h b/src/gpu/mock/GrMockTexture.h
index e9e35af660..26741be1d9 100644
--- a/src/gpu/mock/GrMockTexture.h
+++ b/src/gpu/mock/GrMockTexture.h
@@ -112,7 +112,7 @@ public:
     GrMockRenderTarget(GrMockGpu* gpu, Wrapped, const GrSurfaceDesc& desc,
                        const GrMockRenderTargetInfo& info)
             : GrSurface(gpu, desc), INHERITED(gpu, desc), fInfo(info) {
-        this->registerWithCacheWrapped();
+        this->registerWithCacheWrapped(GrWrapCacheable::kNo);
     }
 
     ResolveType getResolveType() const override { return kCanResolve_ResolveType; }
@@ -168,11 +168,11 @@ public:
     // Renderable wrapped backend texture.
     GrMockTextureRenderTarget(GrMockGpu* gpu, const GrSurfaceDesc& desc,
                               GrMipMapsStatus mipMapsStatus, const GrMockTextureInfo& texInfo,
-                              const GrMockRenderTargetInfo& rtInfo)
+                              const GrMockRenderTargetInfo& rtInfo, GrWrapCacheable cacheble)
             : GrSurface(gpu, desc)
             , GrMockTexture(gpu, desc, mipMapsStatus, texInfo)
             , GrMockRenderTarget(gpu, desc, rtInfo) {
-        this->registerWithCacheWrapped();
+        this->registerWithCacheWrapped(cacheble);
     }
 
     GrTexture* asTexture() override { return this; }
diff --git a/src/gpu/mtl/GrMtlGpu.h b/src/gpu/mtl/GrMtlGpu.h
index bab666c41a..8ab60b7c19 100644
--- a/src/gpu/mtl/GrMtlGpu.h
+++ b/src/gpu/mtl/GrMtlGpu.h
@@ -135,9 +135,8 @@ private:
     sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership, GrWrapCacheable,
                                           GrIOType) override;
 
-    sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
-                                                    int sampleCnt,
-                                                    GrWrapOwnership) override;
+    sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
+                                                    GrWrapOwnership, GrWrapCacheable) override;
 
     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
 
diff --git a/src/gpu/mtl/GrMtlGpu.mm b/src/gpu/mtl/GrMtlGpu.mm
index a74ac52908..c0273e4ef1 100644
--- a/src/gpu/mtl/GrMtlGpu.mm
+++ b/src/gpu/mtl/GrMtlGpu.mm
@@ -357,7 +357,8 @@ sk_sp<GrTexture> GrMtlGpu::onWrapBackendTexture(const GrBackendTexture& backendT
 
 sk_sp<GrTexture> GrMtlGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
                                                           int sampleCnt,
-                                                          GrWrapOwnership ownership) {
+                                                          GrWrapOwnership ownership,
+                                                          GrWrapCacheable cacheable) {
     id<MTLTexture> mtlTexture = get_texture_from_backend(backendTex, ownership);
     if (!mtlTexture) {
         return nullptr;
@@ -370,7 +371,8 @@ sk_sp<GrTexture> GrMtlGpu::onWrapRenderableBackendTexture(const GrBackendTexture
         return nullptr;
     }
 
-    return GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, mtlTexture);
+    return GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, mtlTexture,
+                                                                    cacheable);
 }
 
 sk_sp<GrRenderTarget> GrMtlGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
diff --git a/src/gpu/mtl/GrMtlRenderTarget.h b/src/gpu/mtl/GrMtlRenderTarget.h
index 98fa8e086d..199532c007 100644
--- a/src/gpu/mtl/GrMtlRenderTarget.h
+++ b/src/gpu/mtl/GrMtlRenderTarget.h
@@ -48,11 +48,6 @@ public:
 protected:
     GrMtlRenderTarget(GrMtlGpu* gpu,
                       const GrSurfaceDesc& desc,
-                      id<MTLTexture> renderTexture,
-                      id<MTLTexture> resolveTexture);
-
-    GrMtlRenderTarget(GrMtlGpu* gpu,
-                      const GrSurfaceDesc& desc,
                       id<MTLTexture> renderTexture);
 
     GrMtlGpu* getMtlGpu() const;
@@ -77,22 +72,12 @@ protected:
     id<MTLTexture> fResolveTexture;
 
 private:
+    // Extra param to disambiguate from constructor used by subclasses.
+    enum Wrapped { kWrapped };
     GrMtlRenderTarget(GrMtlGpu* gpu,
-                      SkBudgeted,
                       const GrSurfaceDesc& desc,
                       id<MTLTexture> renderTexture,
-                      id<MTLTexture> resolveTexture);
-
-    GrMtlRenderTarget(GrMtlGpu* gpu,
-                      SkBudgeted,
-                      const GrSurfaceDesc& desc,
-                      id<MTLTexture> renderTexture);
-
-    static sk_sp<GrMtlRenderTarget> Make(GrMtlGpu*,
-                                         SkBudgeted,
-                                         const GrSurfaceDesc&,
-                                         id<MTLTexture> renderTexture,
-                                         bool isWrapped);
+                      Wrapped);
 
     bool completeStencilAttachment() override;
 };
diff --git a/src/gpu/mtl/GrMtlRenderTarget.mm b/src/gpu/mtl/GrMtlRenderTarget.mm
index 59fd4798cd..07e5639294 100644
--- a/src/gpu/mtl/GrMtlRenderTarget.mm
+++ b/src/gpu/mtl/GrMtlRenderTarget.mm
@@ -10,18 +10,20 @@
 #include "GrMtlGpu.h"
 #include "GrMtlUtil.h"
 
+// Called for wrapped non-texture render targets.
 GrMtlRenderTarget::GrMtlRenderTarget(GrMtlGpu* gpu,
-                                     SkBudgeted budgeted,
                                      const GrSurfaceDesc& desc,
-                                     id<MTLTexture> renderTexture)
+                                     id<MTLTexture> renderTexture,
+                                     Wrapped)
         : GrSurface(gpu, desc)
         , GrRenderTarget(gpu, desc)
         , fRenderTexture(renderTexture)
         , fResolveTexture(nil) {
     SkASSERT(1 == desc.fSampleCnt);
-    this->registerWithCache(budgeted);
+    this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
+// Called by subclass constructors.
 GrMtlRenderTarget::GrMtlRenderTarget(GrMtlGpu* gpu,
                                      const GrSurfaceDesc& desc,
                                      id<MTLTexture> renderTexture)
@@ -38,8 +40,7 @@ GrMtlRenderTarget::MakeWrappedRenderTarget(GrMtlGpu* gpu, const GrSurfaceDesc& d
     SkASSERT(nil != renderTexture);
     SkASSERT(1 == renderTexture.mipmapLevelCount);
     SkASSERT(MTLTextureUsageRenderTarget & renderTexture.usage);
-    return sk_sp<GrMtlRenderTarget>(new GrMtlRenderTarget(gpu, SkBudgeted::kNo,
-                                                          desc, renderTexture));
+    return sk_sp<GrMtlRenderTarget>(new GrMtlRenderTarget(gpu, desc, renderTexture, kWrapped));
 }
 
 GrMtlRenderTarget::~GrMtlRenderTarget() {
@@ -47,7 +48,6 @@ GrMtlRenderTarget::~GrMtlRenderTarget() {
     SkASSERT(nil == fResolveTexture);
 }
 
-
 GrBackendRenderTarget GrMtlRenderTarget::getBackendRenderTarget() const {
     GrMtlTextureInfo info;
     info.fTexture = GrGetPtrFromId(fRenderTexture);
diff --git a/src/gpu/mtl/GrMtlTextureRenderTarget.h b/src/gpu/mtl/GrMtlTextureRenderTarget.h
index 412af7bf2e..50a4e8e1b2 100644
--- a/src/gpu/mtl/GrMtlTextureRenderTarget.h
+++ b/src/gpu/mtl/GrMtlTextureRenderTarget.h
@@ -21,7 +21,8 @@ public:
 
     static sk_sp<GrMtlTextureRenderTarget> MakeWrappedTextureRenderTarget(GrMtlGpu*,
                                                                           const GrSurfaceDesc&,
-                                                                          id<MTLTexture>);
+                                                                          id<MTLTexture>,
+                                                                          GrWrapCacheable);
     GrBackendFormat backendFormat() const override {
         return GrMtlTexture::backendFormat();
     }
@@ -60,14 +61,8 @@ private:
     GrMtlTextureRenderTarget(GrMtlGpu* gpu,
                              const GrSurfaceDesc& desc,
                              id<MTLTexture> renderTexture,
-                             GrMipMapsStatus);
-
-    static sk_sp<GrMtlTextureRenderTarget> Make(GrMtlGpu*,
-                                                const GrSurfaceDesc&,
-                                                id<MTLTexture> resolveTexture,
-                                                GrMipMapsStatus,
-                                                SkBudgeted budgeted,
-                                                bool isWrapped);
+                             GrMipMapsStatus,
+                             GrWrapCacheable cacheable);
 
     size_t onGpuMemorySize() const override {
         // TODO: When used as render targets certain formats may actually have a larger size than
diff --git a/src/gpu/mtl/GrMtlTextureRenderTarget.mm b/src/gpu/mtl/GrMtlTextureRenderTarget.mm
index 62fd2abf12..7bd53e1a7f 100644
--- a/src/gpu/mtl/GrMtlTextureRenderTarget.mm
+++ b/src/gpu/mtl/GrMtlTextureRenderTarget.mm
@@ -23,58 +23,43 @@ GrMtlTextureRenderTarget::GrMtlTextureRenderTarget(GrMtlGpu* gpu,
 GrMtlTextureRenderTarget::GrMtlTextureRenderTarget(GrMtlGpu* gpu,
                                                    const GrSurfaceDesc& desc,
                                                    id<MTLTexture> renderTexture,
-                                                   GrMipMapsStatus mipMapsStatus)
+                                                   GrMipMapsStatus mipMapsStatus,
+                                                   GrWrapCacheable cacheable)
         : GrSurface(gpu, desc)
         , GrMtlTexture(gpu, desc, renderTexture, mipMapsStatus)
         , GrMtlRenderTarget(gpu, desc, renderTexture) {
-    this->registerWithCacheWrapped();
-}
-
-sk_sp<GrMtlTextureRenderTarget>
-GrMtlTextureRenderTarget::Make(GrMtlGpu* gpu,
-                               const GrSurfaceDesc& desc,
-                               id<MTLTexture> renderTexture,
-                               GrMipMapsStatus mipMapsStatus,
-                               SkBudgeted budgeted,
-                               bool isWrapped) {
-    SkASSERT(nil != renderTexture);
-    if (desc.fSampleCnt > 1) {
-        return nullptr;
-    }
-    SkASSERT((MTLTextureUsageShaderRead | MTLTextureUsageRenderTarget) & renderTexture.usage);
-    if (!isWrapped) {
-        return sk_sp<GrMtlTextureRenderTarget>(new GrMtlTextureRenderTarget(gpu,
-                                                                            budgeted,
-                                                                            desc,
-                                                                            renderTexture,
-                                                                            mipMapsStatus));
-    } else {
-        return sk_sp<GrMtlTextureRenderTarget>(new GrMtlTextureRenderTarget(gpu,
-                                                                            desc,
-                                                                            renderTexture,
-                                                                            mipMapsStatus));
-    }
+    this->registerWithCacheWrapped(cacheable);
 }
 
-
 sk_sp<GrMtlTextureRenderTarget>
 GrMtlTextureRenderTarget::CreateNewTextureRenderTarget(GrMtlGpu* gpu,
                                                        SkBudgeted budgeted,
                                                        const GrSurfaceDesc& desc,
                                                        MTLTextureDescriptor* texDesc,
                                                        GrMipMapsStatus mipMapsStatus) {
-    id<MTLTexture> texture = [gpu->device() newTextureWithDescriptor:texDesc];
-    return Make(gpu, desc, texture, mipMapsStatus, budgeted, false);
+    id<MTLTexture> renderTexture = [gpu->device() newTextureWithDescriptor:texDesc];
+    SkASSERT(nil != renderTexture);
+    if (desc.fSampleCnt > 1) {
+        return nullptr;
+    }
+    SkASSERT((MTLTextureUsageShaderRead | MTLTextureUsageRenderTarget) & renderTexture.usage);
+    return sk_sp<GrMtlTextureRenderTarget>(
+            new GrMtlTextureRenderTarget(gpu, budgeted, desc, renderTexture, mipMapsStatus));
 }
 
-sk_sp<GrMtlTextureRenderTarget>
-GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(GrMtlGpu* gpu,
-                                                         const GrSurfaceDesc& desc,
-                                                         id<MTLTexture> texture) {
-
-    SkASSERT(nil != texture);
-    GrMipMapsStatus mipMapsStatus = texture.mipmapLevelCount > 1 ? GrMipMapsStatus::kDirty
-                                                                 : GrMipMapsStatus::kNotAllocated;
-    return Make(gpu, desc, texture, mipMapsStatus, SkBudgeted::kNo, true);
+sk_sp<GrMtlTextureRenderTarget> GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(
+        GrMtlGpu* gpu,
+        const GrSurfaceDesc& desc,
+        id<MTLTexture> renderTexture,
+        GrWrapCacheable cacheable) {
+    SkASSERT(nil != renderTexture);
+    GrMipMapsStatus mipMapsStatus = renderTexture.mipmapLevelCount > 1
+                                            ? GrMipMapsStatus::kDirty
+                                            : GrMipMapsStatus::kNotAllocated;
+    if (desc.fSampleCnt > 1) {
+        return nullptr;
+    }
+    SkASSERT((MTLTextureUsageShaderRead | MTLTextureUsageRenderTarget) & renderTexture.usage);
+    return sk_sp<GrMtlTextureRenderTarget>(
+            new GrMtlTextureRenderTarget(gpu, desc, renderTexture, mipMapsStatus, cacheable));
 }
-
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index b85d6030e8..142c1c77a2 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -1048,7 +1048,8 @@ sk_sp<GrTexture> GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTe
 
 sk_sp<GrTexture> GrVkGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
                                                          int sampleCnt,
-                                                         GrWrapOwnership ownership) {
+                                                         GrWrapOwnership ownership,
+                                                         GrWrapCacheable cacheable) {
     GrVkImageInfo imageInfo;
     if (!backendTex.getVkImageInfo(&imageInfo)) {
         return nullptr;
@@ -1068,8 +1069,8 @@ sk_sp<GrTexture> GrVkGpu::onWrapRenderableBackendTexture(const GrBackendTexture&
     sk_sp<GrVkImageLayout> layout = backendTex.getGrVkImageLayout();
     SkASSERT(layout);
 
-    return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, ownership,
-                                                                   imageInfo, std::move(layout));
+    return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(
+            this, surfDesc, ownership, cacheable, imageInfo, std::move(layout));
 }
 
 sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT){
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 8200b6fd5c..671549e4d4 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -188,7 +188,8 @@ private:
                                           GrIOType) override;
     sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
                                                     int sampleCnt,
-                                                    GrWrapOwnership) override;
+                                                    GrWrapOwnership,
+                                                    GrWrapCacheable) override;
     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
 
     sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
diff --git a/src/gpu/vk/GrVkRenderTarget.cpp b/src/gpu/vk/GrVkRenderTarget.cpp
index 36dcb60b3b..ab611509bc 100644
--- a/src/gpu/vk/GrVkRenderTarget.cpp
+++ b/src/gpu/vk/GrVkRenderTarget.cpp
@@ -42,7 +42,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
         , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(desc.fSampleCnt > 1);
     this->createFramebuffer(gpu);
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
@@ -87,7 +87,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
         , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(1 == desc.fSampleCnt);
     this->createFramebuffer(gpu);
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
@@ -125,7 +125,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
         , fFramebuffer(nullptr)
         , fCachedSimpleRenderPass(renderPass)
         , fSecondaryCommandBuffer(secondaryCommandBuffer) {
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
 sk_sp<GrVkRenderTarget> GrVkRenderTarget::MakeWrappedRenderTarget(
diff --git a/src/gpu/vk/GrVkSemaphore.cpp b/src/gpu/vk/GrVkSemaphore.cpp
index 8491782641..dde435fca6 100644
--- a/src/gpu/vk/GrVkSemaphore.cpp
+++ b/src/gpu/vk/GrVkSemaphore.cpp
@@ -46,7 +46,8 @@ GrVkSemaphore::GrVkSemaphore(GrVkGpu* gpu, VkSemaphore semaphore, bool prohibitS
                              bool prohibitWait, bool isOwned)
         : INHERITED(gpu) {
     fResource = new Resource(semaphore, prohibitSignal, prohibitWait, isOwned);
-    isOwned ? this->registerWithCache(SkBudgeted::kNo) : this->registerWithCacheWrapped();
+    isOwned ? this->registerWithCache(SkBudgeted::kNo)
+            : this->registerWithCacheWrapped(GrWrapCacheable::kNo);
 }
 
 void GrVkSemaphore::onRelease() {
diff --git a/src/gpu/vk/GrVkTextureRenderTarget.cpp b/src/gpu/vk/GrVkTextureRenderTarget.cpp
index 3656c82d11..234c4d1f3e 100644
--- a/src/gpu/vk/GrVkTextureRenderTarget.cpp
+++ b/src/gpu/vk/GrVkTextureRenderTarget.cpp
@@ -28,11 +28,11 @@ GrVkTextureRenderTarget::GrVkTextureRenderTarget(GrVkGpu* gpu,
                                                  sk_sp<GrVkImageLayout> msaaLayout,
                                                  const GrVkImageView* colorAttachmentView,
                                                  const GrVkImageView* resolveAttachmentView,
-                                                 GrMipMapsStatus mipMapsStatus,
-                                                 GrBackendObjectOwnership ownership)
+                                                 GrMipMapsStatus mipMapsStatus)
         : GrSurface(gpu, desc)
-        , GrVkImage(info, layout, ownership)
-        , GrVkTexture(gpu, desc, info, layout, texView, mipMapsStatus, ownership)
+        , GrVkImage(info, layout, GrBackendObjectOwnership::kOwned)
+        , GrVkTexture(gpu, desc, info, layout, texView, mipMapsStatus,
+                      GrBackendObjectOwnership::kOwned)
         , GrVkRenderTarget(gpu, desc, info, layout, msaaInfo, std::move(msaaLayout),
                            colorAttachmentView, resolveAttachmentView,
                            GrBackendObjectOwnership::kOwned) {
@@ -46,11 +46,11 @@ GrVkTextureRenderTarget::GrVkTextureRenderTarget(GrVkGpu* gpu,
                                                  sk_sp<GrVkImageLayout> layout,
                                                  const GrVkImageView* texView,
                                                  const GrVkImageView* colorAttachmentView,
-                                                 GrMipMapsStatus mipMapsStatus,
-                                                 GrBackendObjectOwnership ownership)
+                                                 GrMipMapsStatus mipMapsStatus)
         : GrSurface(gpu, desc)
-        , GrVkImage(info, layout, ownership)
-        , GrVkTexture(gpu, desc, info, layout, texView, mipMapsStatus, ownership)
+        , GrVkImage(info, layout, GrBackendObjectOwnership::kOwned)
+        , GrVkTexture(gpu, desc, info, layout, texView, mipMapsStatus,
+                      GrBackendObjectOwnership::kOwned)
         , GrVkRenderTarget(gpu, desc, info, layout, colorAttachmentView,
                            GrBackendObjectOwnership::kOwned) {
     this->registerWithCache(budgeted);
@@ -66,13 +66,14 @@ GrVkTextureRenderTarget::GrVkTextureRenderTarget(GrVkGpu* gpu,
                                                  const GrVkImageView* colorAttachmentView,
                                                  const GrVkImageView* resolveAttachmentView,
                                                  GrMipMapsStatus mipMapsStatus,
-                                                 GrBackendObjectOwnership ownership)
+                                                 GrBackendObjectOwnership ownership,
+                                                 GrWrapCacheable cacheable)
         : GrSurface(gpu, desc)
         , GrVkImage(info, layout, ownership)
         , GrVkTexture(gpu, desc, info, layout, texView, mipMapsStatus, ownership)
         , GrVkRenderTarget(gpu, desc, info, layout, msaaInfo, std::move(msaaLayout),
                            colorAttachmentView, resolveAttachmentView, ownership) {
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(cacheable);
 }
 
 GrVkTextureRenderTarget::GrVkTextureRenderTarget(GrVkGpu* gpu,
@@ -82,29 +83,33 @@ GrVkTextureRenderTarget::GrVkTextureRenderTarget(GrVkGpu* gpu,
                                                  const GrVkImageView* texView,
                                                  const GrVkImageView* colorAttachmentView,
                                                  GrMipMapsStatus mipMapsStatus,
-                                                 GrBackendObjectOwnership ownership)
+                                                 GrBackendObjectOwnership ownership,
+                                                 GrWrapCacheable cacheable)
         : GrSurface(gpu, desc)
         , GrVkImage(info, layout, ownership)
         , GrVkTexture(gpu, desc, info, layout, texView, mipMapsStatus, ownership)
         , GrVkRenderTarget(gpu, desc, info, layout, colorAttachmentView, ownership) {
-    this->registerWithCacheWrapped();
+    this->registerWithCacheWrapped(cacheable);
 }
 
-sk_sp<GrVkTextureRenderTarget> GrVkTextureRenderTarget::Make(GrVkGpu* gpu,
-                                                             const GrSurfaceDesc& desc,
-                                                             const GrVkImageInfo& info,
-                                                             sk_sp<GrVkImageLayout> layout,
-                                                             GrMipMapsStatus mipMapsStatus,
-                                                             SkBudgeted budgeted,
-                                                             GrBackendObjectOwnership ownership,
-                                                             bool isWrapped) {
+namespace {
+struct Views {
+    const GrVkImageView* imageView = nullptr;
+    const GrVkImageView* colorAttachmentView = nullptr;
+    const GrVkImageView* resolveAttachmentView = nullptr;
+    GrVkImageInfo msInfo;
+    sk_sp<GrVkImageLayout> msLayout;
+};
+}  // anonymous namespace
+
+static Views create_views(GrVkGpu* gpu, const GrSurfaceDesc& desc, const GrVkImageInfo& info) {
     VkImage image = info.fImage;
     // Create the texture ImageView
-    const GrVkImageView* imageView = GrVkImageView::Create(
-            gpu, image, info.fFormat, GrVkImageView::kColor_Type, info.fLevelCount,
-            info.fYcbcrConversionInfo);
-    if (!imageView) {
-        return nullptr;
+    Views views;
+    views.imageView = GrVkImageView::Create(gpu, image, info.fFormat, GrVkImageView::kColor_Type,
+                                            info.fLevelCount, info.fYcbcrConversionInfo);
+    if (!views.imageView) {
+        return {};
     }
 
     VkFormat pixelFormat;
@@ -113,9 +118,6 @@ sk_sp<GrVkTextureRenderTarget> GrVkTextureRenderTarget::Make(GrVkGpu* gpu,
     VkImage colorImage;
 
     // create msaa surface if necessary
-    GrVkImageInfo msInfo;
-    sk_sp<GrVkImageLayout> msLayout;
-    const GrVkImageView* resolveAttachmentView = nullptr;
     if (desc.fSampleCnt > 1) {
         GrVkImage::ImageDesc msImageDesc;
         msImageDesc.fImageType = VK_IMAGE_TYPE_2D;
@@ -130,74 +132,40 @@ sk_sp<GrVkTextureRenderTarget> GrVkTextureRenderTarget::Make(GrVkGpu* gpu,
                                   VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
         msImageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
-        if (!GrVkImage::InitImageInfo(gpu, msImageDesc, &msInfo)) {
-            imageView->unref(gpu);
-            return nullptr;
+        if (!GrVkImage::InitImageInfo(gpu, msImageDesc, &views.msInfo)) {
+            views.imageView->unref(gpu);
+            return {};
         }
 
         // Set color attachment image
-        colorImage = msInfo.fImage;
+        colorImage = views.msInfo.fImage;
 
         // Create resolve attachment view.
-        resolveAttachmentView = GrVkImageView::Create(gpu, image, pixelFormat,
-                                                      GrVkImageView::kColor_Type,
-                                                      info.fLevelCount, GrVkYcbcrConversionInfo());
-        if (!resolveAttachmentView) {
-            GrVkImage::DestroyImageInfo(gpu, &msInfo);
-            imageView->unref(gpu);
-            return nullptr;
+        views.resolveAttachmentView =
+                GrVkImageView::Create(gpu, image, pixelFormat, GrVkImageView::kColor_Type,
+                                      info.fLevelCount, GrVkYcbcrConversionInfo());
+        if (!views.resolveAttachmentView) {
+            GrVkImage::DestroyImageInfo(gpu, &views.msInfo);
+            views.imageView->unref(gpu);
+            return {};
         }
-        msLayout.reset(new GrVkImageLayout(msInfo.fImageLayout));
+        views.msLayout.reset(new GrVkImageLayout(views.msInfo.fImageLayout));
     } else {
         // Set color attachment image
         colorImage = info.fImage;
     }
 
-    const GrVkImageView* colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat,
-                                                                     GrVkImageView::kColor_Type, 1,
-                                                                     GrVkYcbcrConversionInfo());
-    if (!colorAttachmentView) {
+    views.colorAttachmentView = GrVkImageView::Create(
+            gpu, colorImage, pixelFormat, GrVkImageView::kColor_Type, 1, GrVkYcbcrConversionInfo());
+    if (!views.colorAttachmentView) {
         if (desc.fSampleCnt > 1) {
-            resolveAttachmentView->unref(gpu);
-            GrVkImage::DestroyImageInfo(gpu, &msInfo);
+            views.resolveAttachmentView->unref(gpu);
+            GrVkImage::DestroyImageInfo(gpu, &views.msInfo);
         }
-        imageView->unref(gpu);
-        return nullptr;
+        views.imageView->unref(gpu);
+        return {};
     }
-
-    sk_sp<GrVkTextureRenderTarget> texRT;
-    if (desc.fSampleCnt > 1) {
-        if (!isWrapped) {
-            texRT = sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
-                                                      gpu, budgeted, desc,
-                                                      info, std::move(layout), imageView, msInfo,
-                                                      std::move(msLayout), colorAttachmentView,
-                                                      resolveAttachmentView, mipMapsStatus,
-                                                      ownership));
-        } else {
-            texRT = sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
-                                                        gpu, desc,
-                                                        info, std::move(layout), imageView, msInfo,
-                                                        std::move(msLayout), colorAttachmentView,
-                                                        resolveAttachmentView, mipMapsStatus,
-                                                        ownership));
-        }
-    } else {
-        if (!isWrapped) {
-            texRT = sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
-                                                        gpu, budgeted, desc,
-                                                        info, std::move(layout), imageView,
-                                                        colorAttachmentView, mipMapsStatus,
-                                                        ownership));
-        } else {
-            texRT = sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
-                                                        gpu, desc,
-                                                        info, std::move(layout), imageView,
-                                                        colorAttachmentView, mipMapsStatus,
-                                                        ownership));
-        }
-    }
-    return texRT;
+    return views;
 }
 
 sk_sp<GrVkTextureRenderTarget>
@@ -215,21 +183,30 @@ GrVkTextureRenderTarget::MakeNewTextureRenderTarget(GrVkGpu* gpu,
     }
     sk_sp<GrVkImageLayout> layout(new GrVkImageLayout(info.fImageLayout));
 
-    sk_sp<GrVkTextureRenderTarget> trt = Make(gpu, desc, info, std::move(layout), mipMapsStatus,
-                                              budgeted, GrBackendObjectOwnership::kOwned, false);
-    if (!trt) {
+    Views views = create_views(gpu, desc, info);
+    if (!views.colorAttachmentView) {
         GrVkImage::DestroyImageInfo(gpu, &info);
+        return nullptr;
+    }
+    if (desc.fSampleCnt > 1) {
+        return sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
+                gpu, budgeted, desc, info, std::move(layout), views.imageView, views.msInfo,
+                std::move(views.msLayout), views.colorAttachmentView, views.resolveAttachmentView,
+                mipMapsStatus));
+    } else {
+        return sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
+                gpu, budgeted, desc, info, std::move(layout), views.imageView,
+                views.colorAttachmentView, mipMapsStatus));
     }
-
-    return trt;
 }
 
-sk_sp<GrVkTextureRenderTarget>
-GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(GrVkGpu* gpu,
-                                                        const GrSurfaceDesc& desc,
-                                                        GrWrapOwnership wrapOwnership,
-                                                        const GrVkImageInfo& info,
-                                                        sk_sp<GrVkImageLayout> layout) {
+sk_sp<GrVkTextureRenderTarget> GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(
+        GrVkGpu* gpu,
+        const GrSurfaceDesc& desc,
+        GrWrapOwnership wrapOwnership,
+        GrWrapCacheable cacheable,
+        const GrVkImageInfo& info,
+        sk_sp<GrVkImageLayout> layout) {
     // Wrapped textures require both image and allocation (because they can be mapped)
     SkASSERT(VK_NULL_HANDLE != info.fImage && VK_NULL_HANDLE != info.fAlloc.fMemory);
 
@@ -238,43 +215,20 @@ GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(GrVkGpu* gpu,
 
     GrBackendObjectOwnership ownership = kBorrow_GrWrapOwnership == wrapOwnership
             ? GrBackendObjectOwnership::kBorrowed : GrBackendObjectOwnership::kOwned;
-
-    return Make(gpu, desc, info, std::move(layout), mipMapsStatus, SkBudgeted::kNo, ownership,
-                true);
-}
-
-bool GrVkTextureRenderTarget::updateForMipmap(GrVkGpu* gpu, const GrVkImageInfo& newInfo) {
-    VkFormat pixelFormat;
-    GrPixelConfigToVkFormat(this->config(), &pixelFormat);
-    if (this->numStencilSamples() > 1) {
-        const GrVkImageView* resolveAttachmentView =
-                GrVkImageView::Create(gpu,
-                                      newInfo.fImage,
-                                      pixelFormat,
-                                      GrVkImageView::kColor_Type,
-                                      newInfo.fLevelCount,
-                                      GrVkYcbcrConversionInfo());
-        if (!resolveAttachmentView) {
-            return false;
-        }
-        fResolveAttachmentView->unref(gpu);
-        fResolveAttachmentView = resolveAttachmentView;
+    Views views = create_views(gpu, desc, info);
+    if (!views.colorAttachmentView) {
+        return nullptr;
+    }
+    if (desc.fSampleCnt > 1) {
+        return sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
+                gpu, desc, info, std::move(layout), views.imageView, views.msInfo,
+                std::move(views.msLayout), views.colorAttachmentView, views.resolveAttachmentView,
+                mipMapsStatus, ownership, cacheable));
     } else {
-        const GrVkImageView* colorAttachmentView = GrVkImageView::Create(gpu,
-                                                                         newInfo.fImage,
-                                                                         pixelFormat,
-                                                                         GrVkImageView::kColor_Type,
-                                                                         1,
-                                                                         GrVkYcbcrConversionInfo());
-        if (!colorAttachmentView) {
-            return false;
-        }
-        fColorAttachmentView->unref(gpu);
-        fColorAttachmentView = colorAttachmentView;
+        return sk_sp<GrVkTextureRenderTarget>(new GrVkTextureRenderTarget(
+                gpu, desc, info, std::move(layout), views.imageView, views.colorAttachmentView,
+                mipMapsStatus, ownership, cacheable));
     }
-
-    this->createFramebuffer(gpu);
-    return true;
 }
 
 size_t GrVkTextureRenderTarget::onGpuMemorySize() const {
diff --git a/src/gpu/vk/GrVkTextureRenderTarget.h b/src/gpu/vk/GrVkTextureRenderTarget.h
index 5026213afa..1538287883 100644
--- a/src/gpu/vk/GrVkTextureRenderTarget.h
+++ b/src/gpu/vk/GrVkTextureRenderTarget.h
@@ -34,11 +34,10 @@ public:
     static sk_sp<GrVkTextureRenderTarget> MakeWrappedTextureRenderTarget(GrVkGpu*,
                                                                          const GrSurfaceDesc&,
                                                                          GrWrapOwnership,
+                                                                         GrWrapCacheable,
                                                                          const GrVkImageInfo&,
                                                                          sk_sp<GrVkImageLayout>);
 
-    bool updateForMipmap(GrVkGpu* gpu, const GrVkImageInfo& newInfo);
-
     GrBackendFormat backendFormat() const override { return this->getBackendFormat(); }
 
 protected:
@@ -53,6 +52,7 @@ protected:
     }
 
 private:
+    // MSAA, not-wrapped
     GrVkTextureRenderTarget(GrVkGpu* gpu,
                             SkBudgeted budgeted,
                             const GrSurfaceDesc& desc,
@@ -63,9 +63,9 @@ private:
                             sk_sp<GrVkImageLayout> msaaLayout,
                             const GrVkImageView* colorAttachmentView,
                             const GrVkImageView* resolveAttachmentView,
-                            GrMipMapsStatus,
-                            GrBackendObjectOwnership);
+                            GrMipMapsStatus);
 
+    // non-MSAA, not-wrapped
     GrVkTextureRenderTarget(GrVkGpu* gpu,
                             SkBudgeted budgeted,
                             const GrSurfaceDesc& desc,
@@ -73,9 +73,9 @@ private:
                             sk_sp<GrVkImageLayout> layout,
                             const GrVkImageView* texView,
                             const GrVkImageView* colorAttachmentView,
-                            GrMipMapsStatus,
-                            GrBackendObjectOwnership);
+                            GrMipMapsStatus);
 
+    // MSAA, wrapped
     GrVkTextureRenderTarget(GrVkGpu* gpu,
                             const GrSurfaceDesc& desc,
                             const GrVkImageInfo& info,
@@ -86,8 +86,10 @@ private:
                             const GrVkImageView* colorAttachmentView,
                             const GrVkImageView* resolveAttachmentView,
                             GrMipMapsStatus,
-                            GrBackendObjectOwnership);
+                            GrBackendObjectOwnership,
+                            GrWrapCacheable);
 
+    // non-MSAA, wrapped
     GrVkTextureRenderTarget(GrVkGpu* gpu,
                             const GrSurfaceDesc& desc,
                             const GrVkImageInfo& info,
@@ -95,16 +97,8 @@ private:
                             const GrVkImageView* texView,
                             const GrVkImageView* colorAttachmentView,
                             GrMipMapsStatus,
-                            GrBackendObjectOwnership);
-
-    static sk_sp<GrVkTextureRenderTarget> Make(GrVkGpu*,
-                                               const GrSurfaceDesc&,
-                                               const GrVkImageInfo&,
-                                               sk_sp<GrVkImageLayout>,
-                                               GrMipMapsStatus,
-                                               SkBudgeted budgeted,
-                                               GrBackendObjectOwnership,
-                                               bool isWrapped);
+                            GrBackendObjectOwnership,
+                            GrWrapCacheable);
 
     // GrGLRenderTarget accounts for the texture's memory and any MSAA renderbuffer's memory.
     size_t onGpuMemorySize() const override;
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index a2a203ef6d..96dd8415b9 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -113,8 +113,9 @@ static sk_sp<SkImage> new_wrapped_texture_common(GrContext* ctx,
     }
 
     GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
-    sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
-            backendTex, origin, ownership, kRead_GrIOType, releaseProc, releaseCtx);
+    sk_sp<GrTextureProxy> proxy =
+            proxyProvider->wrapBackendTexture(backendTex, origin, ownership, GrWrapCacheable::kNo,
+                                              kRead_GrIOType, releaseProc, releaseCtx);
     if (!proxy) {
         return nullptr;
     }
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index 0e74923f2e..330808222b 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -292,9 +292,9 @@ bool SkImage_GpuBase::MakeTempTextureProxies(GrContext* ctx, const GrBackendText
         }
         SkASSERT(yuvaTexturesCopy[textureIndex].isValid());
 
-        tempTextureProxies[textureIndex] =
-                proxyProvider->wrapBackendTexture(yuvaTexturesCopy[textureIndex], imageOrigin,
-                                                  kBorrow_GrWrapOwnership, kRead_GrIOType);
+        tempTextureProxies[textureIndex] = proxyProvider->wrapBackendTexture(
+                yuvaTexturesCopy[textureIndex], imageOrigin, kBorrow_GrWrapOwnership,
+                GrWrapCacheable::kNo, kRead_GrIOType);
         if (!tempTextureProxies[textureIndex]) {
             return false;
         }
@@ -460,7 +460,7 @@ sk_sp<GrTextureProxy> SkImage_GpuBase::MakePromiseImageLazyProxy(
             }
 
             auto tex = resourceProvider->wrapBackendTexture(backendTexture, kBorrow_GrWrapOwnership,
-                                                            kRead_GrIOType);
+                                                            GrWrapCacheable::kYes, kRead_GrIOType);
             if (!tex) {
                 // Even though we failed to wrap the backend texture, we must call the release
                 // proc to keep our contract of always calling Fulfill and Release in pairs.