commit e80b809e8a793492ad9c9edfcc732185586540e9
author Brian Salomon <bsalomon@google.com> Fri Mar 08 13:25:19 2019 -0500
committer Skia Commit-Bot <skia-commit-bot@chromium.org> Fri Mar 15 16:24:28 2019 +0000
tree dee2783ec8c30558f3df067bf7784695a474efae
parent aea65338f35801b79a536b457e338a53d48fa0b0

Revert "Revert "Distinguish between "flushed" and "finished" idle state callbacks on GrTexture.""

This reverts commit 88b8d1124b7280d379f7545eda4b9097a4d8a292.

Bug: skia:8800
Change-Id: I27f5da73b651b91af0c5440557f5986e493a1559
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/199080
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

src/image/SkImage_GpuBase.cpp

diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index 908be47..6e29471 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -426,10 +426,8 @@
                                        PromiseImageTextureDoneProc doneProc,
                                        PromiseImageTextureContext context,
                                        GrPixelConfig config)
-                : fFulfillProc(fulfillProc), fConfig(config) {
-            auto doneHelper = sk_make_sp<GrRefCntedCallback>(doneProc, context);
-            fIdleCallback = sk_make_sp<GrRefCntedCallback>(releaseProc, context);
-            fIdleCallback->addChild(std::move(doneHelper));
+                : fFulfillProc(fulfillProc), fReleaseProc(releaseProc), fConfig(config) {
+            fDoneCallback = sk_make_sp<GrRefCntedCallback>(doneProc, context);
         }
         PromiseLazyInstantiateCallback(PromiseLazyInstantiateCallback&&) = default;
         PromiseLazyInstantiateCallback(const PromiseLazyInstantiateCallback&) {
@@ -444,14 +442,8 @@
         }
 
         ~PromiseLazyInstantiateCallback() {
-            if (fIdleCallback) {
-                SkASSERT(!fTexture);
-                // We were never fulfilled. Pass false so done proc is still called.
-                fIdleCallback->abandon();
-            }
             // Our destructor can run on any thread. We trigger the unref of fTexture by message.
             if (fTexture) {
-                SkASSERT(!fIdleCallback);
                 SkMessageBus<GrGpuResourceFreedMessage>::Post({fTexture, fTextureContextID});
             }
         }
@@ -462,22 +454,19 @@
             if (fTexture) {
                 return sk_ref_sp(fTexture);
             }
-            SkASSERT(fIdleCallback);
-            PromiseImageTextureContext textureContext = fIdleCallback->context();
+            SkASSERT(fDoneCallback);
+            PromiseImageTextureContext textureContext = fDoneCallback->context();
             sk_sp<SkPromiseImageTexture> promiseTexture = fFulfillProc(textureContext);
             // From here on out our contract is that the release proc must be called, even if
             // the return from fulfill was invalid or we fail for some other reason.
+            auto releaseCallback = sk_make_sp<GrRefCntedCallback>(fReleaseProc, textureContext);
             if (!promiseTexture) {
-                // Make sure we explicitly reset this because our destructor assumes a non-null
-                // fIdleCallback means fulfill was never called.
-                fIdleCallback.reset();
                 return sk_sp<GrTexture>();
             }
 
             auto backendTexture = promiseTexture->backendTexture();
             backendTexture.fConfig = fConfig;
             if (!backendTexture.isValid()) {
-                fIdleCallback.reset();
                 return sk_sp<GrTexture>();
             }
 
@@ -500,11 +489,11 @@
                              kRead_GrIOType))) {
                     tex->resourcePriv().setUniqueKey(key);
                 } else {
-                    fIdleCallback.reset();
                     return sk_sp<GrTexture>();
                 }
             }
-            tex->addIdleProc(std::move(fIdleCallback));
+            tex->addIdleProc(std::move(releaseCallback), GrTexture::IdleState::kFinished);
+            tex->addIdleProc(std::move(fDoneCallback), GrTexture::IdleState::kFinished);
             promiseTexture->addKeyToInvalidate(tex->getContext()->priv().contextID(), key);
             fTexture = tex.get();
             // We need to hold on to the GrTexture in case our proxy gets reinstantiated. However,
@@ -518,10 +507,11 @@
         }
 
     private:
+        PromiseImageTextureFulfillProc fFulfillProc;
+        PromiseImageTextureReleaseProc fReleaseProc;
+        sk_sp<GrRefCntedCallback> fDoneCallback;
         GrTexture* fTexture = nullptr;
         uint32_t fTextureContextID = SK_InvalidUniqueID;
-        sk_sp<GrRefCntedCallback> fIdleCallback;
-        PromiseImageTextureFulfillProc fFulfillProc;
         GrPixelConfig fConfig;
     } callback(fulfillProc, releaseProc, doneProc, textureContext, config);