Make GrSurfaceProxy constructors take arg that determines participation in
GrResourceAllocator.
Removes LazyInstantiationType. All callbacks can be invoked one time (if successful).
Lazy callbacks indicate whether their lifetime should be extended, which is used by
promise image proxy callbacks.
Promise image proxies are no longer deinstantiated at the end of flush and
GrDeinstantiateProxyTracker is removed. They will be instantiated the first time
they are encountered in GrResourceAllocator::addInterval (without actually adding
an interval) and then remain instantiated.
Also removes some "helper" versions of proxy factory functions that took fewer
params. They weren't much used outside of test code and as the total number of params
has grown their relative utility has diminished. We could consider a params struct
or radically simpler helpers that take only a few params if desired.
Change-Id: Ic6b09e7b807b66cb9fcbb7a67ae0f9faf345485f
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/238216
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index a47d3d2..4c3761a 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -398,16 +398,21 @@
}
}
- GrSurfaceProxy::LazyInstantiationResult operator()(GrResourceProvider* resourceProvider) {
+ GrSurfaceProxy::LazyCallbackResult operator()(GrResourceProvider* resourceProvider) {
// We use the unique key in a way that is unrelated to the SkImage-based key that the
// proxy may receive, hence kUnsynced.
static constexpr auto kKeySyncMode =
GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced;
+ // In order to make the SkImage "thread safe" we rely on holding an extra ref to the
+ // texture in the callback and signalling the unref via a message to the resource cache.
+ // We need to extend the callback's lifetime to that of the proxy.
+ static constexpr auto kReleaseCallbackOnInstantiation = false;
+
// Our proxy is getting instantiated for the second+ time. We are only allowed to call
// Fulfill once. So return our cached result.
if (fTexture) {
- return {sk_ref_sp(fTexture), kKeySyncMode};
+ return {sk_ref_sp(fTexture), kReleaseCallbackOnInstantiation, kKeySyncMode};
} else if (fColorType == GrColorType::kUnknown) {
// We've already called fulfill and it failed. Our contract says that we should only
// call each callback once.
@@ -466,7 +471,7 @@
GrContext* context = fTexture->getContext();
context->priv().getResourceCache()->insertDelayedResourceUnref(fTexture);
fTextureContextID = context->priv().contextID();
- return {std::move(tex), kKeySyncMode};
+ return {std::move(tex), kReleaseCallbackOnInstantiation, kKeySyncMode};
}
private:
@@ -500,5 +505,5 @@
return proxyProvider->createLazyProxy(
std::move(callback), backendFormat, desc, GrRenderable::kNo, 1, origin, mipMapped,
mipMapsStatus, GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact, SkBudgeted::kNo,
- GrProtected::kNo, GrSurfaceProxy::LazyInstantiationType::kDeinstantiate);
+ GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
}