diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp
index 9267608..716dfa8 100644
--- a/src/gpu/GrGpuResource.cpp
+++ b/src/gpu/GrGpuResource.cpp
@@ -158,11 +158,6 @@
     get_resource_cache(fGpu)->resourceAccess().changeUniqueKey(this, key);
 }
 
-void GrGpuResource::notifyRefCntWillBeZero() const {
-    GrGpuResource* mutableThis = const_cast<GrGpuResource*>(this);
-    mutableThis->willRemoveLastRef();
-}
-
 void GrGpuResource::notifyARefCntIsZero(LastRemovedRef removedRef) const {
     if (this->wasDestroyed()) {
         // We've already been removed from the cache. Goodbye cruel world!
diff --git a/src/gpu/GrGpuResource.h b/src/gpu/GrGpuResource.h
index ee61bbe..015f036 100644
--- a/src/gpu/GrGpuResource.h
+++ b/src/gpu/GrGpuResource.h
@@ -83,22 +83,7 @@
 
 private:
     void notifyWillBeZero(LastRemovedRef removedRef) const {
-        if (0 == this->getRefCnt() && this->hasNoCommandBufferUsages()) {
-            // At this point we better be the only thread accessing this resource.
-            // Trick out the notifyRefCntWillBeZero() call by adding back one more ref.
-            fRefCnt.fetch_add(+1, std::memory_order_relaxed);
-            static_cast<const DERIVED*>(this)->notifyRefCntWillBeZero();
-            // notifyRefCntWillBeZero() could have done anything, including re-refing this and
-            // passing on to another thread. Take away the ref-count we re-added above and see
-            // if we're back to zero.
-            // TODO: Consider making it so that refs can't be added and merge
-            //  notifyRefCntWillBeZero()/willRemoveLastRef() with notifyARefCntIsZero().
-            if (1 == fRefCnt.fetch_add(-1, std::memory_order_acq_rel)) {
-                static_cast<const DERIVED*>(this)->notifyARefCntIsZero(removedRef);
-            }
-        } else {
-            static_cast<const DERIVED*>(this)->notifyARefCntIsZero(removedRef);
-        }
+        static_cast<const DERIVED*>(this)->notifyARefCntIsZero(removedRef);
     }
 
     int32_t getRefCnt() const { return fRefCnt.load(std::memory_order_relaxed); }
@@ -294,15 +279,9 @@
 
     virtual size_t onGpuMemorySize() const = 0;
 
-    /**
-     * Called by GrIORef when a resource is about to lose its last ref
-     */
-    virtual void willRemoveLastRef() {}
-
     // See comments in CacheAccess and ResourcePriv.
     void setUniqueKey(const GrUniqueKey&);
     void removeUniqueKey();
-    void notifyRefCntWillBeZero() const;
     void notifyARefCntIsZero(LastRemovedRef removedRef) const;
     void removeScratchKey();
     void makeBudgeted();
diff --git a/src/gpu/GrManagedResource.cpp b/src/gpu/GrManagedResource.cpp
index 4620de5..c88728b 100644
--- a/src/gpu/GrManagedResource.cpp
+++ b/src/gpu/GrManagedResource.cpp
@@ -14,36 +14,3 @@
 #ifdef SK_TRACE_MANAGED_RESOURCES
 std::atomic<uint32_t> GrManagedResource::fKeyCounter{0};
 #endif
-
-void GrTextureResource::addIdleProc(GrTexture* owningTexture,
-                                    sk_sp<GrRefCntedCallback> idleProc) const {
-    SkASSERT(!fOwningTexture || fOwningTexture == owningTexture);
-    fOwningTexture = owningTexture;
-    fIdleProcs.push_back(std::move(idleProc));
-}
-
-int GrTextureResource::idleProcCnt() const { return fIdleProcs.count(); }
-
-sk_sp<GrRefCntedCallback> GrTextureResource::idleProc(int i) const { return fIdleProcs[i]; }
-
-void GrTextureResource::resetIdleProcs() const { fIdleProcs.reset(); }
-
-void GrTextureResource::removeOwningTexture() const { fOwningTexture = nullptr; }
-
-void GrTextureResource::notifyQueuedForWorkOnGpu() const { ++fNumOwners; }
-
-void GrTextureResource::notifyFinishedWithWorkOnGpu() const {
-    SkASSERT(fNumOwners);
-    if (--fNumOwners || !fIdleProcs.count()) {
-        return;
-    }
-    if (fOwningTexture) {
-        if (fOwningTexture->resourcePriv().hasRefOrCommandBufferUsage()) {
-            // Wait for the texture to become idle in the cache to call the procs.
-            return;
-        }
-        fOwningTexture->callIdleProcsOnBehalfOfResource();
-    } else {
-        fIdleProcs.reset();
-    }
-}
diff --git a/src/gpu/GrManagedResource.h b/src/gpu/GrManagedResource.h
index d80a7f9..fd0aa40 100644
--- a/src/gpu/GrManagedResource.h
+++ b/src/gpu/GrManagedResource.h
@@ -217,7 +217,7 @@
 /** \class GrTextureResource
 
   GrTextureResource is the base class for managed texture resources, and implements the
-  basic idleProc and releaseProc functionality for them.
+  basic releaseProc functionality for them.
 
 */
 class GrTextureResource : public GrManagedResource {
@@ -232,30 +232,8 @@
         fReleaseHelper = std::move(releaseHelper);
     }
 
-    /**
-     * These are used to coordinate calling the "finished" idle procs between the GrTexture
-     * and the GrTextureResource. If the GrTexture becomes purgeable and if there are no command
-     * buffers referring to the GrTextureResource then it calls the procs. Otherwise, the
-     * GrTextureResource calls them when the last command buffer reference goes away and the
-     * GrTexture is purgeable.
-     */
-    void addIdleProc(GrTexture*, sk_sp<GrRefCntedCallback>) const;
-    int idleProcCnt() const;
-    sk_sp<GrRefCntedCallback> idleProc(int) const;
-    void resetIdleProcs() const;
-    void removeOwningTexture() const;
-
-    /**
-     * We track how many outstanding references this GrTextureResource has in command buffers and
-     * when the count reaches zero we call the idle proc.
-     */
-    void notifyQueuedForWorkOnGpu() const override;
-    void notifyFinishedWithWorkOnGpu() const override;
-    bool isQueuedForWorkOnGpu() const { return fNumOwners > 0; }
-
 protected:
     mutable sk_sp<GrRefCntedCallback> fReleaseHelper;
-    mutable GrTexture* fOwningTexture = nullptr;
 
     void invokeReleaseProc() const {
         if (fReleaseHelper) {
@@ -266,9 +244,6 @@
     }
 
 private:
-    mutable int fNumOwners = 0;
-    mutable SkTArray<sk_sp<GrRefCntedCallback>> fIdleProcs;
-
     using INHERITED = GrManagedResource;
 };
 
diff --git a/src/gpu/GrTexture.h b/src/gpu/GrTexture.h
index 60dd828..f703b1e 100644
--- a/src/gpu/GrTexture.h
+++ b/src/gpu/GrTexture.h
@@ -40,23 +40,6 @@
                                     GrBackendTexture*,
                                     SkImage::BackendTextureReleaseProc*);
 
-    /**
-     * Installs a proc on this texture. It will be called when the texture becomes "idle". "Idle"
-     * means, accounting only for Skia's use of the texture, it is safe to delete in the underlying
-     * API. This is used to implement release procs for promise image textures because we cache
-     * the GrTexture object and thus can't rely on it's destructor to trigger a normal release proc.
-     */
-    virtual void addIdleProc(sk_sp<GrRefCntedCallback> idleProc) {
-        // This is the default implementation for the managed case where the IdleState can be
-        // ignored. Unmanaged backends, e.g. Vulkan, must override this to detect when the GPU
-        // is finished accessing the texture.
-        fIdleProcs.push_back(std::move(idleProc));
-    }
-    /** Helper version of addIdleProc that creates the ref-counted wrapper. */
-    void addIdleProc(GrRefCntedCallback::Callback callback, GrRefCntedCallback::Context context) {
-        this->addIdleProc(GrRefCntedCallback::Make(callback, context));
-    }
-
     GrTextureType textureType() const { return fTextureType; }
     bool hasRestrictedSampling() const {
         return GrTextureTypeHasRestrictedSampling(this->textureType());
@@ -85,13 +68,6 @@
 
     virtual bool onStealBackendTexture(GrBackendTexture*, SkImage::BackendTextureReleaseProc*) = 0;
 
-    SkTArray<sk_sp<GrRefCntedCallback>> fIdleProcs;
-
-    void willRemoveLastRef() override {
-        // We're about to be idle in the resource cache. Do our part to trigger the idle callbacks.
-        fIdleProcs.reset();
-    }
-    virtual void callIdleProcsOnBehalfOfResource() {}
     void computeScratchKey(GrScratchKey*) const override;
 
 private:
diff --git a/src/gpu/d3d/GrD3DTexture.cpp b/src/gpu/d3d/GrD3DTexture.cpp
index 230c4c9..2107343 100644
--- a/src/gpu/d3d/GrD3DTexture.cpp
+++ b/src/gpu/d3d/GrD3DTexture.cpp
@@ -109,14 +109,6 @@
 }
 
 void GrD3DTexture::onRelease() {
-    // We're about to be severed from our GrManagedResource. If there are "finish" idle procs we
-    // have to decide who will handle them. If the resource is still tied to a command buffer we let
-    // it handle them. Otherwise, we handle them.
-    SkASSERT(this->resource());
-    if (this->resource()->isQueuedForWorkOnGpu()) {
-        this->removeFinishIdleProcs();
-    }
-
     GrD3DGpu* gpu = this->getD3DGpu();
     gpu->resourceProvider().recycleConstantOrShaderView(fShaderResourceView);
     this->releaseResource(gpu);
@@ -125,14 +117,6 @@
 }
 
 void GrD3DTexture::onAbandon() {
-    // We're about to be severed from our GrManagedResource. If there are "finish" idle procs we
-    // have to decide who will handle them. If the resource is still tied to a command buffer we let
-    // it handle them. Otherwise, we handle them.
-    SkASSERT(this->resource());
-    if (this->resource()->isQueuedForWorkOnGpu()) {
-        this->removeFinishIdleProcs();
-    }
-
     GrD3DGpu* gpu = this->getD3DGpu();
     gpu->resourceProvider().recycleConstantOrShaderView(fShaderResourceView);
     this->releaseResource(gpu);
@@ -147,61 +131,3 @@
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrD3DGpu*>(this->getGpu());
 }
-
-void GrD3DTexture::addIdleProc(sk_sp<GrRefCntedCallback> idleProc) {
-    INHERITED::addIdleProc(idleProc);
-    this->addResourceIdleProc(this, std::move(idleProc));
-}
-
-void GrD3DTexture::callIdleProcsOnBehalfOfResource() {
-    // If we got here then the resource is being removed from its last command buffer and the
-    // texture is idle in the cache. Any kFlush idle procs should already have been called. So
-    // the texture and resource should have the same set of procs.
-    SkASSERT(this->resourceIdleProcCnt() == fIdleProcs.count());
-#ifdef SK_DEBUG
-    for (int i = 0; i < fIdleProcs.count(); ++i) {
-        SkASSERT(fIdleProcs[i] == this->resourceIdleProc(i));
-    }
-#endif
-    fIdleProcs.reset();
-    this->resetResourceIdleProcs();
-}
-
-void GrD3DTexture::willRemoveLastRef() {
-    if (!fIdleProcs.count()) {
-        return;
-    }
-    // This is called when the GrTexture is purgeable. However, we need to check whether the
-    // Resource is still owned by any command buffers. If it is then it will call the proc.
-    if (!this->resourceIsQueuedForWorkOnGpu()) {
-        // Everything must go!
-        fIdleProcs.reset();
-        this->resetResourceIdleProcs();
-    } else {
-        // The procs that should be called on flush but not finish are those that are owned
-        // by the GrD3DTexture and not the Resource. We do this by copying the resource's array
-        // and thereby dropping refs to procs we own but the resource does not.
-        fIdleProcs.reset(this->resourceIdleProcCnt());
-        for (int i = 0; i < fIdleProcs.count(); ++i) {
-            fIdleProcs[i] = this->resourceIdleProc(i);
-        }
-    }
-}
-
-void GrD3DTexture::removeFinishIdleProcs() {
-    // This should only be called by onRelease/onAbandon when we have already checked for a
-    // resource.
-    SkSTArray<4, sk_sp<GrRefCntedCallback>> procsToKeep;
-    int resourceIdx = 0;
-    // The idle procs that are common between the GrD3DTexture and its Resource should be found in
-    // the same order.
-    for (int i = 0; i < fIdleProcs.count(); ++i) {
-        if (fIdleProcs[i] == this->resourceIdleProc(resourceIdx)) {
-            ++resourceIdx;
-        } else {
-            procsToKeep.push_back(fIdleProcs[i]);
-        }
-    }
-    SkASSERT(resourceIdx == this->resourceIdleProcCnt());
-    fIdleProcs = procsToKeep;
-}
diff --git a/src/gpu/d3d/GrD3DTexture.h b/src/gpu/d3d/GrD3DTexture.h
index 8787e47..e57dd29 100644
--- a/src/gpu/d3d/GrD3DTexture.h
+++ b/src/gpu/d3d/GrD3DTexture.h
@@ -39,9 +39,6 @@
 
     void textureParamsModified() override {}
 
-    void addIdleProc(sk_sp<GrRefCntedCallback>) override;
-    void callIdleProcsOnBehalfOfResource() override;
-
 protected:
     GrD3DTexture(GrD3DGpu*,
                  SkISize dimensions,
@@ -59,8 +56,6 @@
         return false;
     }
 
-    void willRemoveLastRef() override;
-
 private:
     GrD3DTexture(GrD3DGpu*, SkBudgeted, SkISize dimensions, const GrD3DTextureResourceInfo&,
                  sk_sp<GrD3DResourceState>,
@@ -78,8 +73,6 @@
         this->setResourceRelease(std::move(releaseHelper));
     }
 
-    void removeFinishIdleProcs();
-
     struct SamplerHash {
         uint32_t operator()(GrSamplerState state) const { return state.asIndex(); }
     };
diff --git a/src/gpu/d3d/GrD3DTextureResource.cpp b/src/gpu/d3d/GrD3DTextureResource.cpp
index 916c359..3f3439b 100644
--- a/src/gpu/d3d/GrD3DTextureResource.cpp
+++ b/src/gpu/d3d/GrD3DTextureResource.cpp
@@ -110,7 +110,6 @@
 void GrD3DTextureResource::releaseResource(GrD3DGpu* gpu) {
     // TODO: do we need to migrate resource state if we change queues?
     if (fResource) {
-        fResource->removeOwningTexture();
         fResource.reset();
     }
     fInfo.fResource.reset();
diff --git a/src/gpu/d3d/GrD3DTextureResource.h b/src/gpu/d3d/GrD3DTextureResource.h
index 2d0bc30..37ee930 100644
--- a/src/gpu/d3d/GrD3DTextureResource.h
+++ b/src/gpu/d3d/GrD3DTextureResource.h
@@ -77,28 +77,6 @@
 protected:
     void releaseResource(GrD3DGpu* gpu);
 
-    void addResourceIdleProc(GrTexture* owningTexture, sk_sp<GrRefCntedCallback> idleProc) {
-        if (fResource) {
-            fResource->addIdleProc(owningTexture, std::move(idleProc));
-        }
-    }
-    void resetResourceIdleProcs() {
-        SkASSERT(fResource);
-        fResource->resetIdleProcs();
-    }
-    bool resourceIsQueuedForWorkOnGpu() const {
-        SkASSERT(fResource);
-        return fResource->isQueuedForWorkOnGpu();
-    }
-    int resourceIdleProcCnt() const {
-        SkASSERT(fResource);
-        return fResource->idleProcCnt();
-    }
-    sk_sp<GrRefCntedCallback> resourceIdleProc(int i) const {
-        SkASSERT(fResource);
-        return fResource->idleProc(i);
-    }
-
     GrD3DTextureResourceInfo fInfo;
     sk_sp<GrD3DResourceState> fState;
 
diff --git a/src/gpu/mock/GrMockTexture.h b/src/gpu/mock/GrMockTexture.h
index 2ebdb8f..41ad564 100644
--- a/src/gpu/mock/GrMockTexture.h
+++ b/src/gpu/mock/GrMockTexture.h
@@ -183,10 +183,6 @@
         return GrMockTexture::backendFormat();
     }
 
-protected:
-    // This avoids an inherits via dominance warning on MSVC.
-    void willRemoveLastRef() override { GrTexture::willRemoveLastRef(); }
-
 private:
     void onAbandon() override {
         GrRenderTarget::onAbandon();
diff --git a/src/gpu/vk/GrVkImage.cpp b/src/gpu/vk/GrVkImage.cpp
index 52efe8a..6759481 100644
--- a/src/gpu/vk/GrVkImage.cpp
+++ b/src/gpu/vk/GrVkImage.cpp
@@ -308,7 +308,6 @@
 
 void GrVkImage::releaseImage() {
     if (fResource) {
-        fResource->removeOwningTexture();
         fResource->unref();
         fResource = nullptr;
     }
diff --git a/src/gpu/vk/GrVkTexture.cpp b/src/gpu/vk/GrVkTexture.cpp
index 9d0f400..6feb677 100644
--- a/src/gpu/vk/GrVkTexture.cpp
+++ b/src/gpu/vk/GrVkTexture.cpp
@@ -138,13 +138,6 @@
 }
 
 void GrVkTexture::onRelease() {
-    // We're about to be severed from our GrManagedResource. If there are "finish" idle procs we
-    // have to decide who will handle them. If the resource is still tied to a command buffer we let
-    // it handle them. Otherwise, we handle them.
-    if (this->hasResource() && this->resource()->isQueuedForWorkOnGpu()) {
-        this->removeFinishIdleProcs();
-    }
-
     // we create this and don't hand it off, so we should always destroy it
     if (fTextureView) {
         fTextureView.reset();
@@ -171,13 +164,6 @@
 };
 
 void GrVkTexture::onAbandon() {
-    // We're about to be severed from our GrManagedResource. If there are "finish" idle procs we
-    // have to decide who will handle them. If the resource is still tied to a command buffer we let
-    // it handle them. Otherwise, we handle them.
-    if (this->hasResource() && this->resource()->isQueuedForWorkOnGpu()) {
-        this->removeFinishIdleProcs();
-    }
-
     // we create this and don't hand it off, so we should always destroy it
     if (fTextureView) {
         fTextureView.reset();
@@ -202,74 +188,6 @@
     return fTextureView.get();
 }
 
-void GrVkTexture::addIdleProc(sk_sp<GrRefCntedCallback> idleProc) {
-    INHERITED::addIdleProc(idleProc);
-    if (auto* resource = this->resource()) {
-        resource->addIdleProc(this, std::move(idleProc));
-    }
-}
-
-void GrVkTexture::callIdleProcsOnBehalfOfResource() {
-    // If we got here then the resource is being removed from its last command buffer and the
-    // texture is idle in the cache. Any kFlush idle procs should already have been called. So
-    // the texture and resource should have the same set of procs.
-    SkASSERT(this->resource());
-    SkASSERT(this->resource()->idleProcCnt() == fIdleProcs.count());
-#ifdef SK_DEBUG
-    for (int i = 0; i < fIdleProcs.count(); ++i) {
-        SkASSERT(fIdleProcs[i] == this->resource()->idleProc(i));
-    }
-#endif
-    fIdleProcs.reset();
-    this->resource()->resetIdleProcs();
-}
-
-void GrVkTexture::willRemoveLastRef() {
-    if (!fIdleProcs.count()) {
-        return;
-    }
-    // This is called when the GrTexture is purgeable. However, we need to check whether the
-    // Resource is still owned by any command buffers. If it is then it will call the proc.
-    auto* resource = this->hasResource() ? this->resource() : nullptr;
-    bool callFinishProcs = !resource || !resource->isQueuedForWorkOnGpu();
-    if (callFinishProcs) {
-        // Everything must go!
-        fIdleProcs.reset();
-        if (resource) {
-            resource->resetIdleProcs();
-        }
-    } else {
-        // The procs that should be called on flush but not finish are those that are owned
-        // by the GrVkTexture and not the Resource. We do this by copying the resource's array
-        // and thereby dropping refs to procs we own but the resource does not.
-        SkASSERT(resource);
-        fIdleProcs.reset(resource->idleProcCnt());
-        for (int i = 0; i < fIdleProcs.count(); ++i) {
-            fIdleProcs[i] = resource->idleProc(i);
-        }
-    }
-}
-
-void GrVkTexture::removeFinishIdleProcs() {
-    // This should only be called by onRelease/onAbandon when we have already checked for a
-    // resource.
-    const auto* resource = this->resource();
-    SkASSERT(resource);
-    SkSTArray<4, sk_sp<GrRefCntedCallback>> procsToKeep;
-    int resourceIdx = 0;
-    // The idle procs that are common between the GrVkTexture and its Resource should be found in
-    // the same order.
-    for (int i = 0; i < fIdleProcs.count(); ++i) {
-        if (fIdleProcs[i] == resource->idleProc(resourceIdx)) {
-            ++resourceIdx;
-        } else {
-            procsToKeep.push_back(fIdleProcs[i]);
-        }
-    }
-    SkASSERT(resourceIdx == resource->idleProcCnt());
-    fIdleProcs = procsToKeep;
-}
-
 const GrVkDescriptorSet* GrVkTexture::cachedSingleDescSet(GrSamplerState state) {
     if (std::unique_ptr<DescriptorCacheEntry>* e = fDescSetCache.find(state)) {
         return (*e)->fDescriptorSet;
diff --git a/src/gpu/vk/GrVkTexture.h b/src/gpu/vk/GrVkTexture.h
index 2f22f97..23950a7 100644
--- a/src/gpu/vk/GrVkTexture.h
+++ b/src/gpu/vk/GrVkTexture.h
@@ -45,9 +45,6 @@
 
     const GrVkImageView* textureView();
 
-    void addIdleProc(sk_sp<GrRefCntedCallback>) override;
-    void callIdleProcsOnBehalfOfResource() override;
-
     // For each GrVkTexture, there is a cache of GrVkDescriptorSets which only contain a single
     // texture/sampler descriptor. If there is a cached descriptor set that matches the passed in
     // GrSamplerState, then a pointer to it is returned. The ref count is not incremented on the
@@ -75,8 +72,6 @@
         return false;
     }
 
-    void willRemoveLastRef() override;
-
 private:
     GrVkTexture(GrVkGpu*, SkBudgeted, SkISize, const GrVkImageInfo&,
                 sk_sp<GrBackendSurfaceMutableStateImpl>, sk_sp<const GrVkImageView> imageView,
@@ -92,8 +87,6 @@
         this->setResourceRelease(std::move(releaseHelper));
     }
 
-    void removeFinishIdleProcs();
-
     sk_sp<const GrVkImageView> fTextureView;
 
     struct SamplerHash {
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index ac863b1..c0ee92d 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -432,395 +432,3 @@
         }
     }
 }
-
-static const int kSurfSize = 10;
-
-static sk_sp<GrTexture> make_wrapped_texture(GrDirectContext* dContext, GrRenderable renderable) {
-    auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(
-            dContext, kSurfSize, kSurfSize, kRGBA_8888_SkColorType, GrMipmapped::kNo, renderable);
-    SkASSERT(mbet);
-    sk_sp<GrTextureProxy> proxy;
-    if (renderable == GrRenderable::kYes) {
-        proxy = dContext->priv().proxyProvider()->wrapRenderableBackendTexture(
-                mbet->texture(), 1, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
-                mbet->refCountedCallback());
-    } else {
-        proxy = dContext->priv().proxyProvider()->wrapBackendTexture(
-                mbet->texture(), kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType,
-                mbet->refCountedCallback());
-    }
-    if (!proxy) {
-        return nullptr;
-    }
-    return sk_ref_sp(proxy->peekTexture());
-}
-
-static sk_sp<GrTexture> make_normal_texture(GrDirectContext* dContext, GrRenderable renderable) {
-    SkISize desc;
-    desc.fWidth = desc.fHeight = kSurfSize;
-    auto format = dContext->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
-                                                                   renderable);
-    return dContext->priv().resourceProvider()->createTexture(
-            desc, format, renderable, 1, GrMipmapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
-}
-
-DEF_GPUTEST(TextureIdleProcTest, reporter, options) {
-    // Various ways of making textures.
-    auto makeWrapped = [](GrDirectContext* dContext) {
-        return make_wrapped_texture(dContext, GrRenderable::kNo);
-    };
-    auto makeWrappedRenderable = [](GrDirectContext* dContext) {
-        return make_wrapped_texture(dContext, GrRenderable::kYes);
-    };
-    auto makeNormal = [](GrDirectContext* dContext) {
-        return make_normal_texture(dContext, GrRenderable::kNo);
-    };
-    auto makeRenderable = [](GrDirectContext* dContext) {
-        return make_normal_texture(dContext, GrRenderable::kYes);
-    };
-
-    std::function<sk_sp<GrTexture>(GrDirectContext*)> makers[] = {
-        makeWrapped,
-        makeWrappedRenderable,
-        makeNormal,
-        makeRenderable
-    };
-
-    // Add a unique key, or not.
-    auto addKey = [](GrTexture* texture) {
-        static uint32_t gN = 0;
-        static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-        GrUniqueKey key;
-        GrUniqueKey::Builder builder(&key, kDomain, 1);
-        builder[0] = gN++;
-        builder.finish();
-        texture->resourcePriv().setUniqueKey(key);
-    };
-    auto dontAddKey = [](GrTexture* texture) {};
-    std::function<void(GrTexture*)> keyAdders[] = {addKey, dontAddKey};
-
-    for (const auto& m : makers) {
-        for (const auto& keyAdder : keyAdders) {
-            for (int type = 0; type < sk_gpu_test::GrContextFactory::kContextTypeCnt; ++type) {
-                sk_gpu_test::GrContextFactory factory;
-                auto contextType = static_cast<sk_gpu_test::GrContextFactory::ContextType>(type);
-                auto dContext = factory.get(contextType);
-                if (!dContext) {
-                    continue;
-                }
-
-                // The callback we add simply adds an integer to a set.
-                std::set<int> idleIDs;
-                struct Context {
-                    std::set<int>* fIdleIDs;
-                    int fNum;
-                };
-                auto proc = [](void* context) {
-                    static_cast<Context*>(context)->fIdleIDs->insert(
-                            static_cast<Context*>(context)->fNum);
-                    delete static_cast<Context*>(context);
-                };
-
-                // Makes a texture, possibly adds a key, and sets the callback.
-                auto make = [&m, &keyAdder, &proc, &idleIDs](GrDirectContext* dContext, int num) {
-                    sk_sp<GrTexture> texture = m(dContext);
-                    texture->addIdleProc(proc, new Context{&idleIDs, num});
-                    keyAdder(texture.get());
-                    return texture;
-                };
-
-                auto texture = make(dContext, 1);
-                REPORTER_ASSERT(reporter, idleIDs.find(1) == idleIDs.end());
-                auto renderable = GrRenderable(SkToBool(texture->asRenderTarget()));
-                auto backendFormat = texture->backendFormat();
-                texture.reset();
-                REPORTER_ASSERT(reporter, idleIDs.find(1) != idleIDs.end());
-
-                texture = make(dContext, 2);
-                int w = texture->width();
-                int h = texture->height();
-                SkImageInfo info =
-                        SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
-                auto rt = SkSurface::MakeRenderTarget(dContext, SkBudgeted::kNo, info, 0, nullptr);
-                auto sdc = SkCanvasPriv::TopDeviceSurfaceDrawContext(rt->getCanvas());
-                auto singleUseLazyCB = [&texture](GrResourceProvider*,
-                                                  const GrSurfaceProxy::LazySurfaceDesc&) {
-                    auto mode = GrSurfaceProxy::LazyInstantiationKeyMode::kSynced;
-                    if (texture->getUniqueKey().isValid()) {
-                        mode = GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced;
-                    }
-                    return GrSurfaceProxy::LazyCallbackResult{std::move(texture), true, mode};
-                };
-                SkISize desc;
-                desc.fWidth = w;
-                desc.fHeight = h;
-                SkBudgeted budgeted;
-                if (texture->resourcePriv().budgetedType() == GrBudgetedType::kBudgeted) {
-                    budgeted = SkBudgeted::kYes;
-                } else {
-                    budgeted = SkBudgeted::kNo;
-                }
-                sk_sp<GrSurfaceProxy> proxy;
-                if (renderable == GrRenderable::kYes) {
-                    static const GrProxyProvider::TextureInfo kTexInfo = {GrMipMapped::kNo,
-                                                                          GrTextureType::k2D};
-                    proxy = dContext->priv().proxyProvider()->createLazyRenderTargetProxy(
-                            singleUseLazyCB, backendFormat, desc, 1,
-                            dContext->priv().caps()->getExtraSurfaceFlagsForDeferredRT(),
-                            &kTexInfo,
-                            GrMipmapStatus::kNotAllocated,
-                            SkBackingFit::kExact, budgeted, GrProtected::kNo, false,
-                            GrSurfaceProxy::UseAllocator::kYes);
-                } else {
-                    proxy = dContext->priv().proxyProvider()->createLazyProxy(
-                            singleUseLazyCB, backendFormat, desc, GrMipmapped::kNo,
-                            GrMipmapStatus::kNotAllocated, GrInternalSurfaceFlags ::kNone,
-                            SkBackingFit::kExact, budgeted, GrProtected::kNo,
-                            GrSurfaceProxy::UseAllocator::kYes);
-                }
-                GrSwizzle readSwizzle = dContext->priv().caps()->getReadSwizzle(
-                        backendFormat, GrColorType::kRGBA_8888);
-                GrSurfaceProxyView view(std::move(proxy), kTopLeft_GrSurfaceOrigin, readSwizzle);
-                sdc->drawTexture(nullptr,
-                                 view,
-                                 kPremul_SkAlphaType,
-                                 GrSamplerState::Filter::kNearest,
-                                 GrSamplerState::MipmapMode::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.
-                REPORTER_ASSERT(reporter, idleIDs.find(2) == idleIDs.end());
-                dContext->flushAndSubmit();
-                REPORTER_ASSERT(reporter, idleIDs.find(2) == idleIDs.end());
-                dContext->submit(true);
-                REPORTER_ASSERT(reporter, idleIDs.find(2) == idleIDs.end());
-
-                // This time we move the proxy into the draw.
-                sdc->drawTexture(nullptr,
-                                 std::move(view),
-                                 kPremul_SkAlphaType,
-                                 GrSamplerState::Filter::kNearest,
-                                 GrSamplerState::MipmapMode::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());
-                dContext->flushAndSubmit(true);
-                // Now that the draw is fully consumed by the GPU, the texture should be idle.
-                REPORTER_ASSERT(reporter, idleIDs.find(2) != idleIDs.end());
-
-                // Make sure we make the call during various shutdown scenarios where the texture
-                // might persist after context is destroyed, abandoned, etc. We test three
-                // variations of each scenario. One where the texture is just created. Another,
-                // where the texture has been used in a draw and then the context is flushed. And
-                // one where the the texture was drawn but the context is not flushed.
-                // In each scenario we test holding a ref beyond the context shutdown and not.
-
-                // These tests are difficult to get working with Vulkan, Direct3D, and Dawn.
-                // See http://skbug.com/8705, http://skbug.com/8277, and http://skbug.com/10326
-                GrBackendApi api = sk_gpu_test::GrContextFactory::ContextTypeBackend(contextType);
-                if (api == GrBackendApi::kVulkan || api == GrBackendApi::kDirect3D ||
-                    api == GrBackendApi::kDawn) {
-                    continue;
-                }
-                int id = 3;
-                enum class DrawType {
-                    kNoDraw,
-                    kDraw,
-                    kDrawAndFlush,
-                };
-                for (auto drawType :
-                     {DrawType::kNoDraw, DrawType::kDraw, DrawType::kDrawAndFlush}) {
-                    for (bool unrefFirst : {false, true}) {
-                        auto possiblyDrawAndFlush = [&dContext, &texture, drawType, unrefFirst, w,
-                                                     h] {
-                            if (drawType == DrawType::kNoDraw) {
-                                return;
-                            }
-                            SkImageInfo info = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
-                                                                 kPremul_SkAlphaType);
-                            auto rt = SkSurface::MakeRenderTarget(dContext, SkBudgeted::kNo, info, 0,
-                                                                  nullptr);
-                            auto sdc = SkCanvasPriv::TopDeviceSurfaceDrawContext(rt->getCanvas());
-                            auto proxy = dContext->priv().proxyProvider()->testingOnly_createWrapped(
-                                    texture);
-                            GrSwizzle swizzle = dContext->priv().caps()->getReadSwizzle(
-                                    proxy->backendFormat(), GrColorType::kRGBA_8888);
-                            GrSurfaceProxyView view(std::move(proxy), kTopLeft_GrSurfaceOrigin,
-                                                    swizzle);
-                            sdc->drawTexture(nullptr,
-                                             std::move(view),
-                                             kPremul_SkAlphaType,
-                                             GrSamplerState::Filter::kNearest,
-                                             GrSamplerState::MipmapMode::kNone,
-                                             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) {
-                                dContext->flushAndSubmit();
-                            }
-                            if (unrefFirst) {
-                                texture.reset();
-                            }
-                        };
-                        texture = make(dContext, id);
-                        possiblyDrawAndFlush();
-                        dContext->abandonContext();
-                        texture.reset();
-                        REPORTER_ASSERT(reporter, idleIDs.find(id) != idleIDs.end());
-                        factory.destroyContexts();
-                        dContext = factory.get(contextType);
-                        ++id;
-
-                        // Similar to previous, but reset the texture after the context was
-                        // abandoned and then destroyed.
-                        texture = make(dContext, id);
-                        possiblyDrawAndFlush();
-                        dContext->abandonContext();
-                        factory.destroyContexts();
-                        texture.reset();
-                        REPORTER_ASSERT(reporter, idleIDs.find(id) != idleIDs.end());
-                        dContext = factory.get(contextType);
-                        id++;
-
-                        texture = make(dContext, id);
-                        possiblyDrawAndFlush();
-                        factory.destroyContexts();
-                        texture.reset();
-                        REPORTER_ASSERT(reporter, idleIDs.find(id) != idleIDs.end());
-                        dContext = factory.get(contextType);
-                        id++;
-
-                        texture = make(dContext, id);
-                        possiblyDrawAndFlush();
-                        factory.releaseResourcesAndAbandonContexts();
-                        texture.reset();
-                        REPORTER_ASSERT(reporter, idleIDs.find(id) != idleIDs.end());
-                        dContext = factory.get(contextType);
-                        id++;
-                    }
-                }
-            }
-        }
-    }
-}
-
-// Tests an idle proc that unrefs another resource down to zero.
-DEF_GPUTEST_FOR_ALL_CONTEXTS(TextureIdleProcCacheManipulationTest, reporter, contextInfo) {
-    auto context = contextInfo.directContext();
-
-    // 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, GrRenderable::kNo);
-            auto otherTexture = otherMaker(context, GrRenderable::kNo);
-            otherTexture->ref();
-            idleTexture->addIdleProc(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) {
-    auto dContext = contextInfo.directContext();
-
-    // idle proc that flushes the context.
-    auto idleProc = [](void* context) {
-        reinterpret_cast<GrDirectContext*>(context)->flushAndSubmit();
-    };
-
-    for (const auto& idleMaker : {make_wrapped_texture, make_normal_texture}) {
-        auto idleTexture = idleMaker(dContext, GrRenderable::kNo);
-        idleTexture->addIdleProc(idleProc, dContext);
-        auto info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
-        auto surf = SkSurface::MakeRenderTarget(dContext, 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 img2 = sk_gpu_test::MakeBackendTextureImage(dContext, info, SkColors::kBlack);
-        REPORTER_ASSERT(reporter, img1 && img2);
-        surf->getCanvas()->drawImage(std::move(img1), 0, 0);
-        surf->getCanvas()->drawImage(std::move(img2), 1, 1);
-        idleTexture.reset();
-    }
-}
-
-DEF_GPUTEST_FOR_ALL_CONTEXTS(TextureIdleProcRerefTest, reporter, contextInfo) {
-    auto context = contextInfo.directContext();
-    // 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, GrRenderable::kNo);
-    // This test assumes the texture won't be cached (or else the release proc doesn't get
-    // called).
-    idleTexture->resourcePriv().removeScratchKey();
-    context->flushAndSubmit();
-    idleTexture->addIdleProc(idleProc, idleTexture.get());
-    idleTexture->setRelease(releaseProc, &isReleased);
-    auto* raw = idleTexture.get();
-    idleTexture.reset();
-    REPORTER_ASSERT(reporter, !isReleased);
-    raw->unref();
-    REPORTER_ASSERT(reporter, isReleased);
-}
-
-DEF_GPUTEST_FOR_ALL_CONTEXTS(TextureIdleStateTest, reporter, contextInfo) {
-    auto context = contextInfo.directContext();
-    for (const auto& idleMaker : {make_wrapped_texture, make_normal_texture}) {
-        auto idleTexture = idleMaker(context, GrRenderable::kNo);
-
-        bool called = false;
-        auto finishProc = [](void* called) { *static_cast<bool*>(called) = true; };
-        idleTexture->addIdleProc(finishProc, &called);
-
-        // Insert a copy from idleTexture to another texture so that we have some queued IO on
-        // idleTexture.
-        SkImageInfo info = SkImageInfo::Make(kSurfSize, kSurfSize, kRGBA_8888_SkColorType,
-                                             kPremul_SkAlphaType);
-        auto rt = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
-        auto sdc = SkCanvasPriv::TopDeviceSurfaceDrawContext(rt->getCanvas());
-        auto proxy =
-                context->priv().proxyProvider()->testingOnly_createWrapped(std::move(idleTexture));
-        context->flushAndSubmit();
-        SkAssertResult(sdc->testCopy(std::move(proxy)));
-        REPORTER_ASSERT(reporter, !called);
-
-        // After a flush we expect idleTexture to have reached the kFlushed state on all backends.
-        // On "managed" backends we expect it to reach kFinished as well. On Vulkan, the only
-        // current "unmanaged" backend, we *may* need a sync to reach kFinished.
-        context->flushAndSubmit();
-        if (contextInfo.backend() != kVulkan_GrBackend) {
-            REPORTER_ASSERT(reporter, called);
-        }
-        context->submit(true);
-        REPORTER_ASSERT(reporter, called);
-    }
-}
diff --git a/tools/run-wasm-gm-tests/run-wasm-gm-tests.html b/tools/run-wasm-gm-tests/run-wasm-gm-tests.html
index 1fbda89..5a59696 100644
--- a/tools/run-wasm-gm-tests/run-wasm-gm-tests.html
+++ b/tools/run-wasm-gm-tests/run-wasm-gm-tests.html
@@ -183,7 +183,6 @@
     'InitialTextureClear',
     'PinnedImageTest',
     'PromiseImageTextureShutdown',
-    'TextureIdleProcTest',
 
     // These tests time out
     'SkTraceMemoryDump_ownedGLRenderTarget',