diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h
index 9ee7c78..a9f2a0b 100644
--- a/include/gpu/GrGpuResource.h
+++ b/include/gpu/GrGpuResource.h
@@ -33,12 +33,14 @@
  *
  * The latter two ref types are private and intended only for Gr core code.
  *
- * When all the ref/io counts reach zero DERIVED::notifyAllCntsAreZero() will be called (static poly
- * morphism using CRTP). Similarly when the ref (but not necessarily pending read/write) count
- * reaches 0 DERIVED::notifyRefCountIsZero() will be called. In the case when an unref() causes both
+ * PRIOR to the last ref/IO count being removed DERIVED::notifyAllCntsWillBeZero() will be called
+ * (static poly morphism using CRTP). It is legal for additional ref's or pending IOs to be added
+ * during this time. AFTER all the ref/io counts reach zero DERIVED::notifyAllCntsAreZero() will be
+ * called. Similarly when the ref (but not necessarily pending read/write) count reaches 0
+ * DERIVED::notifyRefCountIsZero() will be called. In the case when an unref() causes both
  * the ref cnt to reach zero and the other counts are zero, notifyRefCountIsZero() will be called
  * before notifyAllCntsAreZero(). Moreover, if notifyRefCountIsZero() returns false then
- * notifyAllRefCntsAreZero() won't be called at all. notifyRefCountIsZero() must return false if the
+ * notifyAllCntsAreZero() won't be called at all. notifyRefCountIsZero() must return false if the
  * object may be deleted after notifyRefCntIsZero() returns.
  *
  * GrIORef and GrGpuResource are separate classes for organizational reasons and to be
@@ -58,7 +60,13 @@
     void unref() const {
         this->validate();
 
-        if (!(--fRefCnt)) {
+        if (fRefCnt == 1) {
+            if (!this->internalHasPendingIO()) {
+                static_cast<const DERIVED*>(this)->notifyAllCntsWillBeZero();
+            }
+            SkASSERT(fRefCnt > 0);
+        }
+        if (--fRefCnt == 0) {
             if (!static_cast<const DERIVED*>(this)->notifyRefCountIsZero()) {
                 return;
             }
@@ -104,6 +112,9 @@
 
     void completedRead() const {
         this->validate();
+        if (fPendingReads == 1 && !fPendingWrites && !fRefCnt) {
+            static_cast<const DERIVED*>(this)->notifyAllCntsWillBeZero();
+        }
         --fPendingReads;
         this->didRemoveRefOrPendingIO(kPendingRead_CntType);
     }
@@ -115,6 +126,9 @@
 
     void completedWrite() const {
         this->validate();
+        if (fPendingWrites == 1 && !fPendingReads && !fRefCnt) {
+            static_cast<const DERIVED*>(this)->notifyAllCntsWillBeZero();
+        }
         --fPendingWrites;
         this->didRemoveRefOrPendingIO(kPendingWrite_CntType);
     }
@@ -306,11 +320,12 @@
     /**
      * Called by GrResourceCache when a resource loses its last ref or pending IO.
      */
-    virtual void removedLastRefOrPendingIO() {}
+    virtual void willRemoveLastRefOrPendingIO() {}
 
     // See comments in CacheAccess and ResourcePriv.
     void setUniqueKey(const GrUniqueKey&);
     void removeUniqueKey();
+    void notifyAllCntsWillBeZero() const;
     void notifyAllCntsAreZero(CntType) const;
     bool notifyRefCountIsZero() const;
     void removeScratchKey();
diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp
index 0c7c3a1..6dc0dfa 100644
--- a/src/gpu/GrGpuResource.cpp
+++ b/src/gpu/GrGpuResource.cpp
@@ -155,9 +155,12 @@
     get_resource_cache(fGpu)->resourceAccess().changeUniqueKey(this, key);
 }
 
-void GrGpuResource::notifyAllCntsAreZero(CntType lastCntTypeToReachZero) const {
+void GrGpuResource::notifyAllCntsWillBeZero() const {
     GrGpuResource* mutableThis = const_cast<GrGpuResource*>(this);
-    mutableThis->removedLastRefOrPendingIO();
+    mutableThis->willRemoveLastRefOrPendingIO();
+}
+
+void GrGpuResource::notifyAllCntsAreZero(CntType lastCntTypeToReachZero) const {
     if (this->wasDestroyed()) {
         // We've already been removed from the cache. Goodbye cruel world!
         delete this;
@@ -169,6 +172,7 @@
 
     static const uint32_t kFlag =
         GrResourceCache::ResourceAccess::kAllCntsReachedZero_RefNotificationFlag;
+    GrGpuResource* mutableThis = const_cast<GrGpuResource*>(this);
     get_resource_cache(fGpu)->resourceAccess().notifyCntReachedZero(mutableThis, kFlag);
 }
 
@@ -182,7 +186,6 @@
     uint32_t flags = GrResourceCache::ResourceAccess::kRefCntReachedZero_RefNotificationFlag;
     if (!this->internalHasPendingIO()) {
         flags |= GrResourceCache::ResourceAccess::kAllCntsReachedZero_RefNotificationFlag;
-        mutableThis->removedLastRefOrPendingIO();
     }
     get_resource_cache(fGpu)->resourceAccess().notifyCntReachedZero(mutableThis, flags);
 
diff --git a/src/gpu/gl/GrGLTexture.h b/src/gpu/gl/GrGLTexture.h
index 2449fc0..6c22b4d 100644
--- a/src/gpu/gl/GrGLTexture.h
+++ b/src/gpu/gl/GrGLTexture.h
@@ -126,7 +126,7 @@
 private:
     void onSetRelease(sk_sp<GrReleaseProcHelper> releaseHelper) override {}
 
-    void removedLastRefOrPendingIO() override {
+    void willRemoveLastRefOrPendingIO() override {
         if (fIdleProc) {
             fIdleProc(fIdleProcContext);
             fIdleProc = nullptr;
diff --git a/src/gpu/mock/GrMockTexture.h b/src/gpu/mock/GrMockTexture.h
index ac846f5..f1d977c 100644
--- a/src/gpu/mock/GrMockTexture.h
+++ b/src/gpu/mock/GrMockTexture.h
@@ -72,7 +72,7 @@
 
     // protected so that GrMockTextureRenderTarget can call this to avoid "inheritance via
     // dominance" warning.
-    void removedLastRefOrPendingIO() override {
+    void willRemoveLastRefOrPendingIO() override {
         if (fIdleProc) {
             fIdleProc(fIdleProcContext);
             fIdleProc = nullptr;
@@ -191,7 +191,7 @@
     }
 
     // We implement this to avoid the inheritance via dominance warning.
-    void removedLastRefOrPendingIO() override { GrMockTexture::removedLastRefOrPendingIO(); }
+    void willRemoveLastRefOrPendingIO() override { GrMockTexture::willRemoveLastRefOrPendingIO(); }
 
     size_t onGpuMemorySize() const override {
         int numColorSamples = this->numColorSamples();
diff --git a/src/gpu/mtl/GrMtlTexture.h b/src/gpu/mtl/GrMtlTexture.h
index 13555e4..ae283bd 100644
--- a/src/gpu/mtl/GrMtlTexture.h
+++ b/src/gpu/mtl/GrMtlTexture.h
@@ -68,7 +68,7 @@
     // the GPU. Thus we do nothing special here with the releaseHelper.
     void onSetRelease(sk_sp<GrReleaseProcHelper> releaseHelper) override {}
 
-    void removedLastRefOrPendingIO() override {
+    void willRemoveLastRefOrPendingIO() override {
         if (fIdleProc) {
             fIdleProc(fIdleProcContext);
             fIdleProc = nullptr;
diff --git a/src/gpu/vk/GrVkImage.cpp b/src/gpu/vk/GrVkImage.cpp
index 6ce5d02..f1446ac 100644
--- a/src/gpu/vk/GrVkImage.cpp
+++ b/src/gpu/vk/GrVkImage.cpp
@@ -246,7 +246,7 @@
 }
 
 void GrVkImage::Resource::freeGPUData(GrVkGpu* gpu) const {
-    SkASSERT(!fReleaseHelper);
+    this->invokeReleaseProc();
     VK_CALL(gpu, DestroyImage(gpu->device(), fImage, nullptr));
     bool isLinear = (VK_IMAGE_TILING_LINEAR == fImageTiling);
     GrVkMemory::FreeImageMemory(gpu, isLinear, fAlloc);
diff --git a/src/gpu/vk/GrVkImage.h b/src/gpu/vk/GrVkImage.h
index c19621b..e5b4ce1 100644
--- a/src/gpu/vk/GrVkImage.h
+++ b/src/gpu/vk/GrVkImage.h
@@ -198,9 +198,18 @@
     protected:
         mutable sk_sp<GrReleaseProcHelper> fReleaseHelper;
 
+        void invokeReleaseProc() const {
+            if (fReleaseHelper) {
+                // Depending on the ref count of fReleaseHelper this may or may not actually trigger
+                // the ReleaseProc to be called.
+                fReleaseHelper.reset();
+            }
+        }
+
     private:
         void freeGPUData(GrVkGpu* gpu) const override;
         void abandonGPUData() const override {
+            this->invokeReleaseProc();
             SkASSERT(!fReleaseHelper);
         }
 
@@ -222,14 +231,6 @@
             : Resource(image, alloc, tiling) {
         }
     private:
-        void invokeReleaseProc() const {
-            if (fReleaseHelper) {
-                // Depending on the ref count of fReleaseHelper this may or may not actually trigger
-                // the ReleaseProc to be called.
-                fReleaseHelper.reset();
-            }
-        }
-
         void freeGPUData(GrVkGpu* gpu) const override;
         void abandonGPUData() const override;
     };
diff --git a/src/gpu/vk/GrVkTexture.cpp b/src/gpu/vk/GrVkTexture.cpp
index 6e8fe67..cdb9351 100644
--- a/src/gpu/vk/GrVkTexture.cpp
+++ b/src/gpu/vk/GrVkTexture.cpp
@@ -179,7 +179,7 @@
     }
 }
 
-void GrVkTexture::removedLastRefOrPendingIO() {
+void GrVkTexture::willRemoveLastRefOrPendingIO() {
     if (!fIdleProc) {
         return;
     }
diff --git a/src/gpu/vk/GrVkTexture.h b/src/gpu/vk/GrVkTexture.h
index be84229..0cfce86 100644
--- a/src/gpu/vk/GrVkTexture.h
+++ b/src/gpu/vk/GrVkTexture.h
@@ -69,7 +69,7 @@
         this->setResourceRelease(std::move(releaseHelper));
     }
 
-    void removedLastRefOrPendingIO() override;
+    void willRemoveLastRefOrPendingIO() override;
 
     const GrVkImageView* fTextureView;
     GrTexture::IdleProc* fIdleProc = nullptr;
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 4c747f0..dae3941 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -336,63 +336,52 @@
     }
 }
 
-DEF_GPUTEST(TextureIdleProcTest, reporter, options) {
-    static const int kS = 10;
-
-    // Helper to delete a backend texture in a GrTexture's release proc.
-    static const auto installBackendTextureReleaseProc = [](GrTexture* texture) {
-        auto backendTexture = texture->getBackendTexture();
-        auto context = texture->getContext();
-        struct ReleaseContext {
-            GrContext* fContext;
-            GrBackendTexture fBackendTexture;
-        };
-        auto release = [](void* rc) {
-            auto releaseContext = static_cast<ReleaseContext*>(rc);
-            if (!releaseContext->fContext->abandoned()) {
-                if (auto gpu = releaseContext->fContext->priv().getGpu()) {
-                    gpu->deleteTestingOnlyBackendTexture(releaseContext->fBackendTexture);
-                }
-            }
-            delete releaseContext;
-        };
-        texture->setRelease(sk_make_sp<GrReleaseProcHelper>(
-                release, new ReleaseContext{context, backendTexture}));
-    };
-
-    // Various ways of making textures.
-    auto makeWrapped = [](GrContext* context) {
-        auto backendTexture = context->priv().getGpu()->createTestingOnlyBackendTexture(
-                nullptr, kS, kS, GrColorType::kRGBA_8888, false, GrMipMapped::kNo);
-        auto texture = context->priv().resourceProvider()->wrapBackendTexture(
-                backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
-        installBackendTextureReleaseProc(texture.get());
-        return texture;
-    };
-
-    auto makeWrappedRenderable = [](GrContext* context) {
-        auto backendTexture = context->priv().getGpu()->createTestingOnlyBackendTexture(
-                nullptr, kS, kS, GrColorType::kRGBA_8888, true, GrMipMapped::kNo);
-        auto texture = context->priv().resourceProvider()->wrapRenderableBackendTexture(
+static sk_sp<GrTexture> make_wrapped_texture(GrContext* context, bool renderable) {
+    auto backendTexture = context->priv().getGpu()->createTestingOnlyBackendTexture(
+            nullptr, 10, 10, GrColorType::kRGBA_8888, renderable, GrMipMapped::kNo);
+    sk_sp<GrTexture> texture;
+    if (renderable) {
+        texture = context->priv().resourceProvider()->wrapRenderableBackendTexture(
                 backendTexture, 1, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
-        installBackendTextureReleaseProc(texture.get());
-        return texture;
+    } else {
+        texture = context->priv().resourceProvider()->wrapBackendTexture(
+                backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
+    }
+    // Add a release proc that deletes the GrBackendTexture.
+    struct ReleaseContext {
+        GrContext* fContext;
+        GrBackendTexture fBackendTexture;
     };
+    auto release = [](void* rc) {
+        auto releaseContext = static_cast<ReleaseContext*>(rc);
+        if (!releaseContext->fContext->abandoned()) {
+            if (auto gpu = releaseContext->fContext->priv().getGpu()) {
+                gpu->deleteTestingOnlyBackendTexture(releaseContext->fBackendTexture);
+            }
+        }
+        delete releaseContext;
+    };
+    texture->setRelease(
+            sk_make_sp<GrReleaseProcHelper>(release, new ReleaseContext{context, backendTexture}));
+    return texture;
+}
 
-    auto makeNormal = [](GrContext* context) {
-        GrSurfaceDesc desc;
-        desc.fConfig = kRGBA_8888_GrPixelConfig;
-        desc.fWidth = desc.fHeight = kS;
-        return context->priv().resourceProvider()->createTexture(desc, SkBudgeted::kNo);
-    };
+static sk_sp<GrTexture> make_normal_texture(GrContext* context, bool renderable) {
+    GrSurfaceDesc desc;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+    desc.fWidth = desc.fHeight = 10;
+    desc.fFlags = renderable ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
+    return context->priv().resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+}
 
-    auto makeRenderable = [](GrContext* context) {
-        GrSurfaceDesc desc;
-        desc.fFlags = kRenderTarget_GrSurfaceFlag;
-        desc.fConfig = kRGBA_8888_GrPixelConfig;
-        desc.fWidth = desc.fHeight = kS;
-        return context->priv().resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+DEF_GPUTEST(TextureIdleProcTest, reporter, options) {
+    // Various ways of making textures.
+    auto makeWrapped = [](GrContext* context) { return make_wrapped_texture(context, false); };
+    auto makeWrappedRenderable = [](GrContext* context) {
+        return make_wrapped_texture(context, true);
     };
+    auto makeNormal = [](GrContext* context) { return make_normal_texture(context, false); };
+    auto makeRenderable = [](GrContext* context) { return make_normal_texture(context, true); };
 
     std::function<sk_sp<GrTexture>(GrContext*)> makers[] = {makeWrapped, makeWrappedRenderable,
                                                             makeNormal, makeRenderable};
@@ -448,15 +437,18 @@
                 REPORTER_ASSERT(reporter, idleIDs.find(1) != idleIDs.end());
 
                 texture = make(context, 2);
+                int w = texture->width();
+                int h = texture->height();
                 SkImageInfo info =
-                        SkImageInfo::Make(kS, kS, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+                        SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
                 auto rt = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
                 auto rtc = rt->getCanvas()->internal_private_accessTopLayerRenderTargetContext();
                 auto singleUseLazyCB = [&texture](GrResourceProvider* rp) {
                     return std::move(texture);
                 };
                 GrSurfaceDesc desc;
-                desc.fWidth = desc.fHeight = kS;
+                desc.fWidth = w;
+                desc.fHeight = h;
                 desc.fConfig = kRGBA_8888_GrPixelConfig;
                 if (isRT) {
                     desc.fFlags = kRenderTarget_GrSurfaceFlag;
@@ -473,8 +465,8 @@
                         GrInternalSurfaceFlags ::kNone, SkBackingFit::kExact, budgeted,
                         GrSurfaceProxy::LazyInstantiationType::kSingleUse);
                 rtc->drawTexture(GrNoClip(), proxy, GrSamplerState::Filter::kNearest,
-                                 SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(kS, kS),
-                                 SkRect::MakeWH(kS, kS), GrAA::kNo, GrQuadAAFlags::kNone,
+                                 SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(w, h),
+                                 SkRect::MakeWH(w, h), GrAA::kNo, GrQuadAAFlags::kNone,
                                  SkCanvas::kFast_SrcRectConstraint, SkMatrix::I(), nullptr);
                 // We still have the proxy, which should remain instantiated, thereby keeping the
                 // texture not purgeable.
@@ -486,8 +478,8 @@
 
                 // This time we move the proxy into the draw.
                 rtc->drawTexture(GrNoClip(), std::move(proxy), GrSamplerState::Filter::kNearest,
-                                 SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(kS, kS),
-                                 SkRect::MakeWH(kS, kS), GrAA::kNo, GrQuadAAFlags::kNone,
+                                 SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(w, h),
+                                 SkRect::MakeWH(w, h), GrAA::kNo, GrQuadAAFlags::kNone,
                                  SkCanvas::kFast_SrcRectConstraint, SkMatrix::I(), nullptr);
                 REPORTER_ASSERT(reporter, idleIDs.find(2) == idleIDs.end());
                 context->flush();
@@ -505,8 +497,8 @@
                         GrInternalSurfaceFlags ::kNone, SkBackingFit::kExact, budgeted,
                         GrSurfaceProxy::LazyInstantiationType::kDeinstantiate);
                 rtc->drawTexture(GrNoClip(), std::move(proxy), GrSamplerState::Filter::kNearest,
-                                 SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(kS, kS),
-                                 SkRect::MakeWH(kS, kS), GrAA::kNo, GrQuadAAFlags::kNone,
+                                 SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(w, h),
+                                 SkRect::MakeWH(w, h), GrAA::kNo, GrQuadAAFlags::kNone,
                                  SkCanvas::kFast_SrcRectConstraint, SkMatrix::I(), nullptr);
                 // At this point the proxy shouldn't even be instantiated, there is no texture with
                 // id 3.
@@ -539,11 +531,12 @@
                 for (auto drawType :
                      {DrawType::kNoDraw, DrawType::kDraw, DrawType::kDrawAndFlush}) {
                     for (bool unrefFirst : {false, true}) {
-                        auto possiblyDrawAndFlush = [&context, &texture, drawType, unrefFirst] {
+                        auto possiblyDrawAndFlush = [&context, &texture, drawType, unrefFirst, w,
+                                                     h] {
                             if (drawType == DrawType::kNoDraw) {
                                 return;
                             }
-                            SkImageInfo info = SkImageInfo::Make(kS, kS, kRGBA_8888_SkColorType,
+                            SkImageInfo info = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
                                                                  kPremul_SkAlphaType);
                             auto rt = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0,
                                                                   nullptr);
@@ -551,12 +544,11 @@
                                             ->internal_private_accessTopLayerRenderTargetContext();
                             auto proxy = context->priv().proxyProvider()->testingOnly_createWrapped(
                                                          texture, kTopLeft_GrSurfaceOrigin);
-                            rtc->drawTexture(GrNoClip(), proxy, GrSamplerState::Filter::kNearest,
-                                             SkBlendMode::kSrcOver, SkPMColor4f(),
-                                             SkRect::MakeWH(kS, kS), SkRect::MakeWH(kS, kS),
-                                             GrAA::kNo, GrQuadAAFlags::kNone,
-                                             SkCanvas::kFast_SrcRectConstraint, SkMatrix::I(),
-                                             nullptr);
+                            rtc->drawTexture(
+                                    GrNoClip(), proxy, GrSamplerState::Filter::kNearest,
+                                    SkBlendMode::kSrcOver, SkPMColor4f(), SkRect::MakeWH(w, h),
+                                    SkRect::MakeWH(w, h), GrAA::kNo, GrQuadAAFlags::kNone,
+                                    SkCanvas::kFast_SrcRectConstraint, SkMatrix::I(), nullptr);
                             if (drawType == DrawType::kDrawAndFlush) {
                                 context->flush();
                             }
@@ -605,3 +597,74 @@
         }
     }
 }
+
+// Tests an idle proc that unrefs another resource down to zero.
+DEF_GPUTEST_FOR_ALL_CONTEXTS(TextureIdleProcCacheManipulationTest, reporter, contextInfo) {
+    GrContext* context = contextInfo.grContext();
+
+    // idle proc that releases another texture.
+    auto idleProc = [](void* texture) { reinterpret_cast<GrTexture*>(texture)->unref(); };
+
+    for (const auto& idleMaker : {make_wrapped_texture, make_normal_texture}) {
+        for (const auto& otherMaker : {make_wrapped_texture, make_normal_texture}) {
+            auto idleTexture = idleMaker(context, false);
+            auto otherTexture = otherMaker(context, false);
+            otherTexture->ref();
+            idleTexture->setIdleProc(idleProc, otherTexture.get());
+            otherTexture.reset();
+            idleTexture.reset();
+        }
+    }
+}
+
+// Similar to above but more complicated. This flushes the context from the idle proc.
+// crbug.com/933526.
+DEF_GPUTEST_FOR_ALL_CONTEXTS(TextureIdleProcFlushTest, reporter, contextInfo) {
+    GrContext* context = contextInfo.grContext();
+
+    // idle proc that flushes the context.
+    auto idleProc = [](void* context) { reinterpret_cast<GrContext*>(context)->flush(); };
+
+    for (const auto& idleMaker : {make_wrapped_texture, make_normal_texture}) {
+        auto idleTexture = idleMaker(context, false);
+        idleTexture->setIdleProc(idleProc, context);
+        auto info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+        auto surf = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 1, nullptr);
+        // We'll draw two images to the canvas. One is a normal texture-backed image. The other is
+        // a wrapped-texture backed image.
+        surf->getCanvas()->clear(SK_ColorWHITE);
+        auto img1 = surf->makeImageSnapshot();
+        auto gpu = context->priv().getGpu();
+        std::unique_ptr<uint32_t[]> pixels(new uint32_t[info.width() * info.height()]);
+        auto backendTexture = gpu->createTestingOnlyBackendTexture(
+                pixels.get(), info.width(), info.height(), kRGBA_8888_SkColorType, false,
+                GrMipMapped::kNo);
+        auto img2 = SkImage::MakeFromTexture(context, backendTexture, kTopLeft_GrSurfaceOrigin,
+                                             info.colorType(), info.alphaType(), nullptr);
+        surf->getCanvas()->drawImage(std::move(img1), 0, 0);
+        surf->getCanvas()->drawImage(std::move(img2), 1, 1);
+        idleTexture.reset();
+        gpu->deleteTestingOnlyBackendTexture(backendTexture);
+    }
+}
+
+DEF_GPUTEST_FOR_ALL_CONTEXTS(TextureIdleProcRerefTest, reporter, contextInfo) {
+    GrContext* context = contextInfo.grContext();
+    // idle proc that refs the texture
+    auto idleProc = [](void* texture) { reinterpret_cast<GrTexture*>(texture)->ref(); };
+    // release proc to check whether the texture was released or not.
+    auto releaseProc = [](void* isReleased) { *reinterpret_cast<bool*>(isReleased) = true; };
+    bool isReleased = false;
+    auto idleTexture = make_normal_texture(context, false);
+    // This test assumes the texture won't be cached (or else the release proc doesn't get
+    // called).
+    idleTexture->resourcePriv().removeScratchKey();
+    context->flush();
+    idleTexture->setIdleProc(idleProc, idleTexture.get());
+    idleTexture->setRelease(releaseProc, &isReleased);
+    auto* raw = idleTexture.get();
+    idleTexture.reset();
+    REPORTER_ASSERT(reporter, !isReleased);
+    raw->unref();
+    REPORTER_ASSERT(reporter, isReleased);
+}