Don't require color type to wrap a texture/RT.
Change-Id: Ic6c0de262e13c3c3ea9e7777ccdd04f22ff6ae0a
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/280345
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
Reviewed-by: Jim Van Verth <jvanverth@google.com>
diff --git a/src/gpu/GrAHardwareBufferImageGenerator.cpp b/src/gpu/GrAHardwareBufferImageGenerator.cpp
index 77c406e..22b2840 100644
--- a/src/gpu/GrAHardwareBufferImageGenerator.cpp
+++ b/src/gpu/GrAHardwareBufferImageGenerator.cpp
@@ -141,7 +141,7 @@
sk_sp<GrTextureProxy> texProxy = proxyProvider->createLazyProxy(
[direct, buffer = AutoAHBRelease(hardwareBuffer), width, height, isProtectedContent,
- backendFormat, grColorType](
+ backendFormat](
GrResourceProvider* resourceProvider) -> GrSurfaceProxy::LazyCallbackResult {
GrAHardwareBufferUtils::DeleteImageProc deleteImageProc = nullptr;
GrAHardwareBufferUtils::UpdateImageProc updateImageProc = nullptr;
@@ -165,8 +165,7 @@
// 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, grColorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kYes,
- kRead_GrIOType);
+ backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kYes, kRead_GrIOType);
if (!tex) {
deleteImageProc(texImageCtx);
return {};
diff --git a/src/gpu/GrBackendTextureImageGenerator.cpp b/src/gpu/GrBackendTextureImageGenerator.cpp
index caee941..6f7bae4 100644
--- a/src/gpu/GrBackendTextureImageGenerator.cpp
+++ b/src/gpu/GrBackendTextureImageGenerator.cpp
@@ -159,55 +159,50 @@
// Must make copies of member variables to capture in the lambda since this image generator may
// be deleted before we actually execute the lambda.
- sk_sp<GrTextureProxy> proxy =
- proxyProvider->createLazyProxy(
- [refHelper = fRefHelper, releaseProcHelper, backendTexture = fBackendTexture,
- grColorType](GrResourceProvider* resourceProvider)
- -> GrSurfaceProxy::LazyCallbackResult {
- if (refHelper->fSemaphore) {
- resourceProvider->priv().gpu()->waitSemaphore(
- refHelper->fSemaphore.get());
- }
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
+ [refHelper = fRefHelper, releaseProcHelper, backendTexture = fBackendTexture](
+ GrResourceProvider* resourceProvider) -> GrSurfaceProxy::LazyCallbackResult {
+ if (refHelper->fSemaphore) {
+ resourceProvider->priv().gpu()->waitSemaphore(refHelper->fSemaphore.get());
+ }
- // If a client re-draws the same image multiple times, the texture we return
- // will be cached and re-used. If they draw a subset, though, we may be
- // re-called. In that case, we want to re-use the borrowed texture we've
- // previously created.
- sk_sp<GrTexture> tex;
- SkASSERT(refHelper->fBorrowedTextureKey.isValid());
- auto surf = resourceProvider->findByUniqueKey<GrSurface>(
- refHelper->fBorrowedTextureKey);
- if (surf) {
- SkASSERT(surf->asTexture());
- tex = sk_ref_sp(surf->asTexture());
- } else {
- // We just gained access to the texture. If we're on the original
- // context, we could use the original texture, but we'd have no way of
- // detecting that it's no longer in-use. So we always make a wrapped
- // copy, where the release proc informs us that the context is done with
- // it. This is unfortunate - we'll have two texture objects referencing
- // the same GPU object. However, no client can 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, grColorType, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, kRead_GrIOType);
- if (!tex) {
- return {};
- }
- tex->setRelease(releaseProcHelper);
- tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
- }
- // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture.
- // This is unrelated to the whatever SkImage key may be assigned to the
- // proxy.
- return {std::move(tex), true,
- GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
- },
- backendFormat, fBackendTexture.dimensions(), GrRenderable::kNo, 1,
- textureIsMipMapped, mipMapsStatus, GrInternalSurfaceFlags::kReadOnly,
- SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
- GrSurfaceProxy::UseAllocator::kYes);
+ // If a client re-draws the same image multiple times, the texture we return
+ // will be cached and re-used. If they draw a subset, though, we may be
+ // re-called. In that case, we want to re-use the borrowed texture we've
+ // previously created.
+ sk_sp<GrTexture> tex;
+ SkASSERT(refHelper->fBorrowedTextureKey.isValid());
+ auto surf = resourceProvider->findByUniqueKey<GrSurface>(
+ refHelper->fBorrowedTextureKey);
+ if (surf) {
+ SkASSERT(surf->asTexture());
+ tex = sk_ref_sp(surf->asTexture());
+ } else {
+ // We just gained access to the texture. If we're on the original
+ // context, we could use the original texture, but we'd have no way of
+ // detecting that it's no longer in-use. So we always make a wrapped
+ // copy, where the release proc informs us that the context is done with
+ // it. This is unfortunate - we'll have two texture objects referencing
+ // the same GPU object. However, no client can 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, GrWrapCacheable::kNo,
+ kRead_GrIOType);
+ if (!tex) {
+ return {};
+ }
+ tex->setRelease(releaseProcHelper);
+ tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
+ }
+ // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture.
+ // This is unrelated to the whatever SkImage key may be assigned to the
+ // proxy.
+ return {std::move(tex), true, GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
+ },
+ backendFormat, fBackendTexture.dimensions(), GrRenderable::kNo, 1, textureIsMipMapped,
+ mipMapsStatus, GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact, SkBudgeted::kNo,
+ GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
if (!proxy) {
return {};
}
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index afef05a4..6b8e47e 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -260,8 +260,8 @@
}
sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
- GrColorType colorType,
- GrWrapOwnership ownership, GrWrapCacheable cacheable,
+ GrWrapOwnership ownership,
+ GrWrapCacheable cacheable,
GrIOType ioType) {
SkASSERT(ioType != kWrite_GrIOType);
this->handleDirtyContext();
@@ -277,7 +277,7 @@
return nullptr;
}
- return this->onWrapBackendTexture(backendTex, colorType, ownership, cacheable, ioType);
+ return this->onWrapBackendTexture(backendTex, ownership, cacheable, ioType);
}
sk_sp<GrTexture> GrGpu::wrapCompressedBackendTexture(const GrBackendTexture& backendTex,
@@ -299,9 +299,8 @@
return this->onWrapCompressedBackendTexture(backendTex, ownership, cacheable);
}
-
sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex,
- int sampleCnt, GrColorType colorType,
+ int sampleCnt,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
this->handleDirtyContext();
@@ -320,8 +319,8 @@
backendTex.height() > caps->maxRenderTargetSize()) {
return nullptr;
}
- sk_sp<GrTexture> tex = this->onWrapRenderableBackendTexture(backendTex, sampleCnt, colorType,
- ownership, cacheable);
+ sk_sp<GrTexture> tex =
+ this->onWrapRenderableBackendTexture(backendTex, sampleCnt, ownership, cacheable);
SkASSERT(!tex || tex->asRenderTarget());
if (tex && sampleCnt > 1 && !caps->msaaResolvesAutomatically()) {
tex->asRenderTarget()->setRequiresManualMSAAResolve();
@@ -329,8 +328,7 @@
return tex;
}
-sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
- GrColorType colorType) {
+sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
this->handleDirtyContext();
const GrCaps* caps = this->caps();
@@ -339,7 +337,7 @@
return nullptr;
}
- sk_sp<GrRenderTarget> rt = this->onWrapBackendRenderTarget(backendRT, colorType);
+ sk_sp<GrRenderTarget> rt = this->onWrapBackendRenderTarget(backendRT);
if (backendRT.isFramebufferOnly()) {
rt->setFramebufferOnly();
}
@@ -347,8 +345,7 @@
}
sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& backendTex,
- int sampleCnt,
- GrColorType colorType) {
+ int sampleCnt) {
this->handleDirtyContext();
const GrCaps* caps = this->caps();
@@ -362,7 +359,7 @@
return nullptr;
}
- auto rt = this->onWrapBackendTextureAsRenderTarget(backendTex, sampleCnt, colorType);
+ auto rt = this->onWrapBackendTextureAsRenderTarget(backendTex, sampleCnt);
if (rt && sampleCnt > 1 && !this->caps()->msaaResolvesAutomatically()) {
rt->setRequiresManualMSAAResolve();
}
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 3df4f65..e8765d2 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -142,31 +142,32 @@
/**
* Implements GrResourceProvider::wrapBackendTexture
*/
- sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture&, GrColorType,
- GrWrapOwnership, GrWrapCacheable, GrIOType);
+ sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType);
sk_sp<GrTexture> wrapCompressedBackendTexture(const GrBackendTexture&,
- GrWrapOwnership, GrWrapCacheable);
-
+ GrWrapOwnership,
+ GrWrapCacheable);
/**
* Implements GrResourceProvider::wrapRenderableBackendTexture
*/
- sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
- GrColorType, GrWrapOwnership, GrWrapCacheable);
+ sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture&,
+ int sampleCnt,
+ GrWrapOwnership,
+ GrWrapCacheable);
/**
* Implements GrResourceProvider::wrapBackendRenderTarget
*/
- sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType colorType);
+ sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&);
/**
* Implements GrResourceProvider::wrapBackendTextureAsRenderTarget
*/
- sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt,
- GrColorType colorType);
+ sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&, int sampleCnt);
/**
* Implements GrResourceProvider::wrapVulkanSecondaryCBAsRenderTarget
@@ -730,21 +731,22 @@
GrMipMapped,
GrProtected,
const void* data, size_t dataSize) = 0;
- virtual sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType,
- GrWrapOwnership, GrWrapCacheable, GrIOType) = 0;
+ virtual sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) = 0;
virtual sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
GrWrapOwnership,
GrWrapCacheable) = 0;
- virtual sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
- GrColorType, GrWrapOwnership,
+ virtual sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
+ int sampleCnt,
+ GrWrapOwnership,
GrWrapCacheable) = 0;
- virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) = 0;
+ virtual sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) = 0;
virtual sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt,
- GrColorType) = 0;
+ int sampleCnt) = 0;
virtual sk_sp<GrRenderTarget> onWrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo&,
const GrVkDrawableInfo&);
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index 9255d9d..1fa39c4 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -482,7 +482,6 @@
}
sk_sp<GrTextureProxy> GrProxyProvider::wrapBackendTexture(const GrBackendTexture& backendTex,
- GrColorType grColorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable,
GrIOType ioType,
@@ -502,8 +501,7 @@
GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
sk_sp<GrTexture> tex =
- resourceProvider->wrapBackendTexture(backendTex, grColorType,
- ownership, cacheable, ioType);
+ resourceProvider->wrapBackendTexture(backendTex, ownership, cacheable, ioType);
if (!tex) {
return nullptr;
}
@@ -554,8 +552,11 @@
}
sk_sp<GrTextureProxy> GrProxyProvider::wrapRenderableBackendTexture(
- const GrBackendTexture& backendTex, int sampleCnt, GrColorType colorType,
- GrWrapOwnership ownership, GrWrapCacheable cacheable, ReleaseProc releaseProc,
+ const GrBackendTexture& backendTex,
+ int sampleCnt,
+ GrWrapOwnership ownership,
+ GrWrapCacheable cacheable,
+ ReleaseProc releaseProc,
ReleaseContext releaseCtx) {
if (this->isAbandoned()) {
return nullptr;
@@ -571,17 +572,11 @@
GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
- // TODO: This should have been checked and validated before getting into GrProxyProvider.
- if (!caps->isFormatAsColorTypeRenderable(colorType, backendTex.getBackendFormat(), sampleCnt)) {
- return nullptr;
- }
-
sampleCnt = caps->getRenderTargetSampleCount(sampleCnt, backendTex.getBackendFormat());
SkASSERT(sampleCnt);
- sk_sp<GrTexture> tex = resourceProvider->wrapRenderableBackendTexture(backendTex, sampleCnt,
- colorType, ownership,
- cacheable);
+ sk_sp<GrTexture> tex = resourceProvider->wrapRenderableBackendTexture(
+ backendTex, sampleCnt, ownership, cacheable);
if (!tex) {
return nullptr;
}
@@ -598,7 +593,8 @@
}
sk_sp<GrSurfaceProxy> GrProxyProvider::wrapBackendRenderTarget(
- const GrBackendRenderTarget& backendRT, GrColorType grColorType, ReleaseProc releaseProc,
+ const GrBackendRenderTarget& backendRT,
+ ReleaseProc releaseProc,
ReleaseContext releaseCtx) {
if (this->isAbandoned()) {
return nullptr;
@@ -612,7 +608,7 @@
GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
- sk_sp<GrRenderTarget> rt = resourceProvider->wrapBackendRenderTarget(backendRT, grColorType);
+ sk_sp<GrRenderTarget> rt = resourceProvider->wrapBackendRenderTarget(backendRT);
if (!rt) {
return nullptr;
}
@@ -630,7 +626,7 @@
}
sk_sp<GrSurfaceProxy> GrProxyProvider::wrapBackendTextureAsRenderTarget(
- const GrBackendTexture& backendTex, GrColorType grColorType, int sampleCnt) {
+ const GrBackendTexture& backendTex, int sampleCnt) {
if (this->isAbandoned()) {
return nullptr;
}
@@ -644,7 +640,7 @@
GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
sk_sp<GrRenderTarget> rt =
- resourceProvider->wrapBackendTextureAsRenderTarget(backendTex, sampleCnt, grColorType);
+ resourceProvider->wrapBackendTextureAsRenderTarget(backendTex, sampleCnt);
if (!rt) {
return nullptr;
}
diff --git a/src/gpu/GrProxyProvider.h b/src/gpu/GrProxyProvider.h
index 52f6d44..4fbceb6 100644
--- a/src/gpu/GrProxyProvider.h
+++ b/src/gpu/GrProxyProvider.h
@@ -110,8 +110,11 @@
* Create a texture proxy that wraps a (non-renderable) backend texture. GrIOType must be
* kRead or kRW.
*/
- sk_sp<GrTextureProxy> wrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType, ReleaseProc = nullptr,
+ sk_sp<GrTextureProxy> wrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType,
+ ReleaseProc = nullptr,
ReleaseContext = nullptr);
sk_sp<GrTextureProxy> wrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
@@ -121,23 +124,24 @@
/*
* Create a texture proxy that wraps a backend texture and is both texture-able and renderable
*/
- sk_sp<GrTextureProxy> wrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
- GrColorType, GrWrapOwnership,
- GrWrapCacheable, ReleaseProc = nullptr,
+ sk_sp<GrTextureProxy> wrapRenderableBackendTexture(const GrBackendTexture&,
+ int sampleCnt,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ ReleaseProc = nullptr,
ReleaseContext = nullptr);
/*
* Create a render target proxy that wraps a backend render target
*/
- sk_sp<GrSurfaceProxy> wrapBackendRenderTarget(const GrBackendRenderTarget&, GrColorType,
- ReleaseProc = nullptr, ReleaseContext = nullptr);
+ sk_sp<GrSurfaceProxy> wrapBackendRenderTarget(const GrBackendRenderTarget&,
+ ReleaseProc = nullptr,
+ ReleaseContext = nullptr);
/*
* Create a render target proxy that wraps a backend texture
*/
- sk_sp<GrSurfaceProxy> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- GrColorType,
- int sampleCnt);
+ sk_sp<GrSurfaceProxy> wrapBackendTextureAsRenderTarget(const GrBackendTexture&, int sampleCnt);
sk_sp<GrRenderTargetProxy> wrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo&,
const GrVkDrawableInfo&);
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index d075092..fe3ef5d 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -287,7 +287,7 @@
ReleaseContext releaseCtx) {
SkASSERT(sampleCnt > 0);
sk_sp<GrTextureProxy> proxy(context->priv().proxyProvider()->wrapRenderableBackendTexture(
- tex, sampleCnt, colorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, releaseProc,
+ tex, sampleCnt, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, releaseProc,
releaseCtx));
if (!proxy) {
return nullptr;
@@ -306,8 +306,8 @@
GrSurfaceOrigin origin,
const SkSurfaceProps* surfaceProps) {
SkASSERT(sampleCnt > 0);
- sk_sp<GrSurfaceProxy> proxy(context->priv().proxyProvider()->wrapBackendTextureAsRenderTarget(
- tex, colorType, sampleCnt));
+ sk_sp<GrSurfaceProxy> proxy(
+ context->priv().proxyProvider()->wrapBackendTextureAsRenderTarget(tex, sampleCnt));
if (!proxy) {
return nullptr;
}
@@ -325,8 +325,8 @@
const SkSurfaceProps* surfaceProps,
ReleaseProc releaseProc,
ReleaseContext releaseCtx) {
- sk_sp<GrSurfaceProxy> proxy(context->priv().proxyProvider()->wrapBackendRenderTarget(
- rt, colorType, releaseProc, releaseCtx));
+ sk_sp<GrSurfaceProxy> proxy(
+ context->priv().proxyProvider()->wrapBackendRenderTarget(rt, releaseProc, releaseCtx));
if (!proxy) {
return nullptr;
}
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index f239f0a..498c171 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -279,7 +279,6 @@
}
sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTexture& tex,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable,
GrIOType ioType) {
@@ -287,7 +286,7 @@
if (this->isAbandoned()) {
return nullptr;
}
- return fGpu->wrapBackendTexture(tex, colorType, ownership, cacheable, ioType);
+ return fGpu->wrapBackendTexture(tex, ownership, cacheable, ioType);
}
sk_sp<GrTexture> GrResourceProvider::wrapCompressedBackendTexture(const GrBackendTexture& tex,
@@ -304,21 +303,19 @@
sk_sp<GrTexture> GrResourceProvider::wrapRenderableBackendTexture(const GrBackendTexture& tex,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
- return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, colorType, ownership, cacheable);
+ return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, ownership, cacheable);
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendRenderTarget(
- const GrBackendRenderTarget& backendRT, GrColorType colorType)
-{
+ const GrBackendRenderTarget& backendRT) {
ASSERT_SINGLE_OWNER
- return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT, colorType);
+ return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT);
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapVulkanSecondaryCBAsRenderTarget(
@@ -530,12 +527,11 @@
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendTextureAsRenderTarget(
- const GrBackendTexture& tex, int sampleCnt, GrColorType colorType)
-{
+ const GrBackendTexture& tex, int sampleCnt) {
if (this->isAbandoned()) {
return nullptr;
}
- return fGpu->wrapBackendTextureAsRenderTarget(tex, sampleCnt, colorType);
+ return fGpu->wrapBackendTextureAsRenderTarget(tex, sampleCnt);
}
std::unique_ptr<GrSemaphore> SK_WARN_UNUSED_RESULT GrResourceProvider::makeSemaphore(
diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h
index 5aa14e9..4a5269b 100644
--- a/src/gpu/GrResourceProvider.h
+++ b/src/gpu/GrResourceProvider.h
@@ -129,8 +129,10 @@
*
* @return GrTexture object or NULL on failure.
*/
- sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture& tex, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType);
+ sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture& tex,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType);
sk_sp<GrTexture> wrapCompressedBackendTexture(const GrBackendTexture& tex,
GrWrapOwnership,
@@ -143,7 +145,6 @@
*/
sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture& tex,
int sampleCnt,
- GrColorType,
GrWrapOwnership,
GrWrapCacheable);
@@ -156,8 +157,7 @@
*
* @return GrRenderTarget object or NULL on failure.
*/
- sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType colorType);
+ sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&);
sk_sp<GrRenderTarget> wrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo&,
const GrVkDrawableInfo&);
@@ -272,9 +272,7 @@
*
* @return GrRenderTarget object or NULL on failure.
*/
- sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt,
- GrColorType);
+ sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&, int sampleCnt);
/**
* Assigns a unique key to a resource. If the key is associated with another resource that
diff --git a/src/gpu/d3d/GrD3DGpu.cpp b/src/gpu/d3d/GrD3DGpu.cpp
index 3943fce..52bb060 100644
--- a/src/gpu/d3d/GrD3DGpu.cpp
+++ b/src/gpu/d3d/GrD3DGpu.cpp
@@ -217,18 +217,10 @@
return nullptr;
}
-static bool check_resource_info(const GrD3DCaps& caps,
- const GrD3DTextureResourceInfo& info,
- GrColorType colorType) {
+static bool check_resource_info(const GrD3DTextureResourceInfo& info) {
if (!info.fResource) {
return false;
}
-
- SkASSERTF(colorType == GrColorType::kUnknown ||
- caps.areColorTypeAndFormatCompatible(colorType,
- GrBackendFormat::MakeDxgi(info.fFormat)),
- "Direct3D format/colorType mismatch - format %d colorType %d\n",
- info.fFormat, colorType);
return true;
}
@@ -247,15 +239,16 @@
return true;
}
-sk_sp<GrTexture> GrD3DGpu::onWrapBackendTexture(const GrBackendTexture& tex, GrColorType colorType,
- GrWrapOwnership, GrWrapCacheable wrapType,
+sk_sp<GrTexture> GrD3DGpu::onWrapBackendTexture(const GrBackendTexture& tex,
+ GrWrapOwnership,
+ GrWrapCacheable wrapType,
GrIOType ioType) {
GrD3DTextureResourceInfo textureInfo;
if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
return nullptr;
}
- if (!check_resource_info(this->d3dCaps(), textureInfo, colorType)) {
+ if (!check_resource_info(textureInfo)) {
return nullptr;
}
@@ -282,7 +275,7 @@
return nullptr;
}
- if (!check_resource_info(this->d3dCaps(), textureInfo, GrColorType::kUnknown)) {
+ if (!check_resource_info(textureInfo)) {
return nullptr;
}
@@ -303,7 +296,6 @@
sk_sp<GrTexture> GrD3DGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
GrD3DTextureResourceInfo textureInfo;
@@ -311,7 +303,7 @@
return nullptr;
}
- if (!check_resource_info(this->d3dCaps(), textureInfo, colorType)) {
+ if (!check_resource_info(textureInfo)) {
return nullptr;
}
@@ -337,8 +329,7 @@
textureInfo, std::move(state));
}
-sk_sp<GrRenderTarget> GrD3DGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt,
- GrColorType colorType) {
+sk_sp<GrRenderTarget> GrD3DGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt) {
// Currently the Direct3D backend does not support wrapping of msaa render targets directly. In
// general this is not an issue since swapchain images in D3D are never multisampled. Thus if
// you want a multisampled RT it is best to wrap the swapchain images and then let Skia handle
@@ -352,7 +343,7 @@
return nullptr;
}
- if (!check_resource_info(this->d3dCaps(), info, colorType)) {
+ if (!check_resource_info(info)) {
return nullptr;
}
@@ -380,14 +371,13 @@
}
sk_sp<GrRenderTarget> GrD3DGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
- int sampleCnt,
- GrColorType colorType) {
+ int sampleCnt) {
GrD3DTextureResourceInfo textureInfo;
if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
return nullptr;
}
- if (!check_resource_info(this->d3dCaps(), textureInfo, colorType)) {
+ if (!check_resource_info(textureInfo)) {
return nullptr;
}
diff --git a/src/gpu/d3d/GrD3DGpu.h b/src/gpu/d3d/GrD3DGpu.h
index 6c981f0..8379839 100644
--- a/src/gpu/d3d/GrD3DGpu.h
+++ b/src/gpu/d3d/GrD3DGpu.h
@@ -105,22 +105,23 @@
GrProtected,
const void* data, size_t dataSize) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType) override;
- sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) override;
+ sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
GrWrapCacheable) override;
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
int sampleCnt,
- GrColorType,
GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt, GrColorType) override;
+ int sampleCnt) override;
sk_sp<GrGpuBuffer> onCreateBuffer(size_t sizeInBytes, GrGpuBufferType, GrAccessPattern,
const void*) override;
diff --git a/src/gpu/dawn/GrDawnGpu.cpp b/src/gpu/dawn/GrDawnGpu.cpp
index 619c71f..b3c05f0 100644
--- a/src/gpu/dawn/GrDawnGpu.cpp
+++ b/src/gpu/dawn/GrDawnGpu.cpp
@@ -176,7 +176,6 @@
}
sk_sp<GrTexture> GrDawnGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable,
GrIOType ioType) {
@@ -197,9 +196,8 @@
return nullptr;
}
-
sk_sp<GrTexture> GrDawnGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
- int sampleCnt, GrColorType colorType,
+ int sampleCnt,
GrWrapOwnership,
GrWrapCacheable cacheable) {
GrDawnTextureInfo info;
@@ -218,8 +216,7 @@
cacheable, kRW_GrIOType, info);
}
-sk_sp<GrRenderTarget> GrDawnGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt,
- GrColorType colorType) {
+sk_sp<GrRenderTarget> GrDawnGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt) {
GrDawnRenderTargetInfo info;
if (!rt.getDawnRenderTargetInfo(&info) || !info.fTextureView) {
return nullptr;
@@ -231,8 +228,7 @@
}
sk_sp<GrRenderTarget> GrDawnGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
- int sampleCnt,
- GrColorType colorType) {
+ int sampleCnt) {
GrDawnTextureInfo textureInfo;
if (!tex.getDawnTextureInfo(&textureInfo) || !textureInfo.fTexture) {
return nullptr;
diff --git a/src/gpu/dawn/GrDawnGpu.h b/src/gpu/dawn/GrDawnGpu.h
index d655215..8afd08a 100644
--- a/src/gpu/dawn/GrDawnGpu.h
+++ b/src/gpu/dawn/GrDawnGpu.h
@@ -130,18 +130,21 @@
GrProtected,
const void* data, size_t dataSize) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType) override;
- sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) override;
+ sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
- GrColorType, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
+ int sampleCnt,
+ GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
- sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&, int sampleCnt,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
+ int sampleCnt) override;
sk_sp<GrGpuBuffer> onCreateBuffer(size_t size, GrGpuBufferType type, GrAccessPattern,
const void* data) override;
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 3e3648f..77c763f 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -611,8 +611,9 @@
++fResetTimestampForTextureParameters;
}
-static bool check_backend_texture(const GrBackendTexture& backendTex, const GrColorType colorType,
- const GrGLCaps& caps, GrGLTexture::Desc* desc,
+static bool check_backend_texture(const GrBackendTexture& backendTex,
+ const GrGLCaps& caps,
+ GrGLTexture::Desc* desc,
bool skipRectTexSupportCheck = false) {
GrGLTextureInfo info;
if (!backendTex.getGLTextureInfo(&info) || !info.fID || !info.fFormat) {
@@ -647,10 +648,11 @@
}
sk_sp<GrTexture> GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
- GrColorType colorType, GrWrapOwnership ownership,
- GrWrapCacheable cacheable, GrIOType ioType) {
+ GrWrapOwnership ownership,
+ GrWrapCacheable cacheable,
+ GrIOType ioType) {
GrGLTexture::Desc desc;
- if (!check_backend_texture(backendTex, colorType, this->glCaps(), &desc)) {
+ if (!check_backend_texture(backendTex, this->glCaps(), &desc)) {
return nullptr;
}
@@ -725,13 +727,12 @@
sk_sp<GrTexture> GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
const GrGLCaps& caps = this->glCaps();
GrGLTexture::Desc desc;
- if (!check_backend_texture(backendTex, colorType, this->glCaps(), &desc)) {
+ if (!check_backend_texture(backendTex, this->glCaps(), &desc)) {
return nullptr;
}
SkASSERT(caps.isFormatRenderable(desc.fFormat, sampleCnt));
@@ -769,8 +770,7 @@
return std::move(texRT);
}
-sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
- GrColorType grColorType) {
+sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
GrGLFramebufferInfo info;
if (!backendRT.getGLFramebufferInfo(&info)) {
return nullptr;
@@ -799,12 +799,11 @@
}
sk_sp<GrRenderTarget> GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
- int sampleCnt,
- GrColorType colorType) {
+ int sampleCnt) {
GrGLTexture::Desc desc;
// We do not check whether texture rectangle is supported by Skia - if the caller provided us
// with a texture rectangle,we assume the necessary support exists.
- if (!check_backend_texture(tex, colorType, this->glCaps(), &desc, true)) {
+ if (!check_backend_texture(tex, this->glCaps(), &desc, true)) {
return nullptr;
}
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 33fc73a..7fdcdf1 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -242,17 +242,20 @@
sk_sp<GrGpuBuffer> onCreateBuffer(size_t size, GrGpuBufferType intendedType, GrAccessPattern,
const void* data) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType) override;
- sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) override;
+ sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
- GrColorType, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
+ int sampleCnt,
+ GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt, GrColorType) override;
+ int sampleCnt) override;
// Given a GL format return the index into the stencil format array on GrGLCaps to a
// compatible stencil format, or negative if there is no compatible stencil format.
diff --git a/src/gpu/mock/GrMockGpu.cpp b/src/gpu/mock/GrMockGpu.cpp
index ba2d7fb..14968be 100644
--- a/src/gpu/mock/GrMockGpu.cpp
+++ b/src/gpu/mock/GrMockGpu.cpp
@@ -190,9 +190,10 @@
new GrMockTexture(this, budgeted, dimensions, isProtected, mipMapsStatus, texInfo));
}
-sk_sp<GrTexture> GrMockGpu::onWrapBackendTexture(const GrBackendTexture& tex, GrColorType colorType,
+sk_sp<GrTexture> GrMockGpu::onWrapBackendTexture(const GrBackendTexture& tex,
GrWrapOwnership ownership,
- GrWrapCacheable wrapType, GrIOType ioType) {
+ GrWrapCacheable wrapType,
+ GrIOType ioType) {
GrMockTextureInfo texInfo;
SkAssertResult(tex.getMockTextureInfo(&texInfo));
@@ -201,8 +202,6 @@
return nullptr;
}
- SkASSERT(colorType == texInfo.colorType());
-
GrMipMapsStatus mipMapsStatus = tex.hasMipMaps() ? GrMipMapsStatus::kValid
: GrMipMapsStatus::kNotAllocated;
auto isProtected = GrProtected(tex.isProtected());
@@ -218,15 +217,12 @@
sk_sp<GrTexture> GrMockGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
GrMockTextureInfo texInfo;
SkAssertResult(tex.getMockTextureInfo(&texInfo));
SkASSERT(texInfo.compressionType() == SkImage::CompressionType::kNone);
- SkASSERT(colorType == texInfo.colorType());
-
GrMipMapsStatus mipMapsStatus =
tex.hasMipMaps() ? GrMipMapsStatus::kValid : GrMipMapsStatus::kNotAllocated;
@@ -239,13 +235,10 @@
rtInfo, cacheable));
}
-sk_sp<GrRenderTarget> GrMockGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt,
- GrColorType colorType) {
+sk_sp<GrRenderTarget> GrMockGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt) {
GrMockRenderTargetInfo info;
SkAssertResult(rt.getMockRenderTargetInfo(&info));
- SkASSERT(colorType == info.colorType());
-
auto isProtected = GrProtected(rt.isProtected());
return sk_sp<GrRenderTarget>(new GrMockRenderTarget(this, GrMockRenderTarget::kWrapped,
rt.dimensions(), rt.sampleCnt(),
@@ -253,14 +246,11 @@
}
sk_sp<GrRenderTarget> GrMockGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
- int sampleCnt,
- GrColorType colorType) {
+ int sampleCnt) {
GrMockTextureInfo texInfo;
SkAssertResult(tex.getMockTextureInfo(&texInfo));
SkASSERT(texInfo.compressionType() == SkImage::CompressionType::kNone);
- SkASSERT(colorType == texInfo.colorType());
-
// The client gave us the texture ID but we supply the render target ID.
GrMockRenderTargetInfo rtInfo(texInfo.colorType(), NextInternalRenderTargetID());
diff --git a/src/gpu/mock/GrMockGpu.h b/src/gpu/mock/GrMockGpu.h
index 915a805..d71339c 100644
--- a/src/gpu/mock/GrMockGpu.h
+++ b/src/gpu/mock/GrMockGpu.h
@@ -78,22 +78,23 @@
GrProtected,
const void* data, size_t dataSize) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType) override;
- sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) override;
+ sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
GrWrapCacheable) override;
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
int sampleCnt,
- GrColorType,
GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt, GrColorType) override;
+ int sampleCnt) override;
sk_sp<GrGpuBuffer> onCreateBuffer(size_t sizeInBytes, GrGpuBufferType, GrAccessPattern,
const void*) override;
diff --git a/src/gpu/mtl/GrMtlGpu.h b/src/gpu/mtl/GrMtlGpu.h
index 5f4e92e..c28b025 100644
--- a/src/gpu/mtl/GrMtlGpu.h
+++ b/src/gpu/mtl/GrMtlGpu.h
@@ -154,21 +154,24 @@
GrProtected,
const void* data, size_t dataSize) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType,
- GrWrapOwnership, GrWrapCacheable, GrIOType) override;
- sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) override;
+
+ sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
- GrColorType, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
+ int sampleCnt,
+ GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt,
- GrColorType) override;
+ int sampleCnt) override;
sk_sp<GrGpuBuffer> onCreateBuffer(size_t, GrGpuBufferType, GrAccessPattern,
const void*) override;
diff --git a/src/gpu/mtl/GrMtlGpu.mm b/src/gpu/mtl/GrMtlGpu.mm
index c7b5e5c..cc052d1 100644
--- a/src/gpu/mtl/GrMtlGpu.mm
+++ b/src/gpu/mtl/GrMtlGpu.mm
@@ -633,7 +633,6 @@
}
sk_sp<GrTexture> GrMtlGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
- GrColorType grColorType,
GrWrapOwnership,
GrWrapCacheable cacheable,
GrIOType ioType) {
@@ -660,7 +659,6 @@
sk_sp<GrTexture> GrMtlGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership,
GrWrapCacheable cacheable) {
id<MTLTexture> mtlTexture = get_texture_from_backend(backendTex);
@@ -686,8 +684,7 @@
this, backendTex.dimensions(), sampleCnt, mtlTexture, cacheable);
}
-sk_sp<GrRenderTarget> GrMtlGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
- GrColorType grColorType) {
+sk_sp<GrRenderTarget> GrMtlGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
// TODO: Revisit this when the Metal backend is completed. It may support MSAA render targets.
if (backendRT.sampleCnt() > 1) {
return nullptr;
@@ -706,7 +703,7 @@
}
sk_sp<GrRenderTarget> GrMtlGpu::onWrapBackendTextureAsRenderTarget(
- const GrBackendTexture& backendTex, int sampleCnt, GrColorType grColorType) {
+ const GrBackendTexture& backendTex, int sampleCnt) {
id<MTLTexture> mtlTexture = get_texture_from_backend(backendTex);
if (!mtlTexture) {
return nullptr;
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 4a4bf01..64f97b1 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -1157,7 +1157,6 @@
static bool check_image_info(const GrVkCaps& caps,
const GrVkImageInfo& info,
- GrColorType colorType,
bool needsAllocation) {
if (VK_NULL_HANDLE == info.fImage) {
return false;
@@ -1180,10 +1179,6 @@
}
}
- SkASSERTF(colorType == GrColorType::kUnknown ||
- GrVkFormatColorTypePairIsValid(info.fFormat, colorType),
- "Vulkan format/colorType mismatch - format %d colorType %d\n",
- info.fFormat, colorType);
return true;
}
@@ -1212,15 +1207,15 @@
}
sk_sp<GrTexture> GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
- GrColorType colorType, GrWrapOwnership ownership,
- GrWrapCacheable cacheable, GrIOType ioType) {
+ GrWrapOwnership ownership,
+ GrWrapCacheable cacheable,
+ GrIOType ioType) {
GrVkImageInfo imageInfo;
if (!backendTex.getVkImageInfo(&imageInfo)) {
return nullptr;
}
- if (!check_image_info(this->vkCaps(), imageInfo,
- colorType, kAdopt_GrWrapOwnership == ownership)) {
+ if (!check_image_info(this->vkCaps(), imageInfo, kAdopt_GrWrapOwnership == ownership)) {
return nullptr;
}
@@ -1246,8 +1241,7 @@
return nullptr;
}
- if (!check_image_info(this->vkCaps(), imageInfo,
- GrColorType::kUnknown, kAdopt_GrWrapOwnership == ownership)) {
+ if (!check_image_info(this->vkCaps(), imageInfo, kAdopt_GrWrapOwnership == ownership)) {
return nullptr;
}
@@ -1267,7 +1261,6 @@
sk_sp<GrTexture> GrVkGpu::onWrapRenderableBackendTexture(const GrBackendTexture& backendTex,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
GrVkImageInfo imageInfo;
@@ -1275,8 +1268,7 @@
return nullptr;
}
- if (!check_image_info(this->vkCaps(), imageInfo, colorType,
- kAdopt_GrWrapOwnership == ownership)) {
+ if (!check_image_info(this->vkCaps(), imageInfo, kAdopt_GrWrapOwnership == ownership)) {
return nullptr;
}
@@ -1301,8 +1293,7 @@
imageInfo, std::move(layout));
}
-sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
- GrColorType colorType) {
+sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
// Currently the Vulkan backend does not support wrapping of msaa render targets directly. In
// general this is not an issue since swapchain images in vulkan are never multisampled. Thus if
// you want a multisampled RT it is best to wrap the swapchain images and then let Skia handle
@@ -1316,7 +1307,7 @@
return nullptr;
}
- if (!check_image_info(this->vkCaps(), info, colorType, false)) {
+ if (!check_image_info(this->vkCaps(), info, false)) {
return nullptr;
}
@@ -1343,14 +1334,12 @@
}
sk_sp<GrRenderTarget> GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
- int sampleCnt,
- GrColorType grColorType) {
-
+ int sampleCnt) {
GrVkImageInfo imageInfo;
if (!tex.getVkImageInfo(&imageInfo)) {
return nullptr;
}
- if (!check_image_info(this->vkCaps(), imageInfo, grColorType, false)) {
+ if (!check_image_info(this->vkCaps(), imageInfo, false)) {
return nullptr;
}
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index dc62f77..141068f 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -203,20 +203,21 @@
GrProtected,
const void* data, size_t dataSize) override;
- sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
- GrWrapCacheable, GrIOType) override;
- sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+ sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
+ GrWrapCacheable,
+ GrIOType) override;
+ sk_sp<GrTexture> onWrapCompressedBackendTexture(const GrBackendTexture&,
+ GrWrapOwnership,
GrWrapCacheable) override;
sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
int sampleCnt,
- GrColorType colorType,
GrWrapOwnership,
GrWrapCacheable) override;
- sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&,
- GrColorType) override;
+ sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
- int sampleCnt, GrColorType) override;
+ int sampleCnt) override;
sk_sp<GrRenderTarget> onWrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo&,
const GrVkDrawableInfo&) override;
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index accda874..09abd64 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -132,8 +132,7 @@
GrProxyProvider* proxyProvider = ctx->priv().proxyProvider();
sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
- backendTex, colorType, ownership, GrWrapCacheable::kNo, kRead_GrIOType, releaseProc,
- releaseCtx);
+ backendTex, ownership, GrWrapCacheable::kNo, kRead_GrIOType, releaseProc, releaseCtx);
if (!proxy) {
return nullptr;
}
@@ -636,10 +635,9 @@
return nullptr;
}
- sk_sp<GrTextureProxy> proxy =
- proxyProvider->wrapBackendTexture(backendTexture, grColorType, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, kRW_GrIOType, deleteImageProc,
- deleteImageCtx);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
+ backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType,
+ deleteImageProc, deleteImageCtx);
if (!proxy) {
deleteImageProc(deleteImageCtx);
return nullptr;
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index 5447c3d..120aa78 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -285,7 +285,7 @@
SkASSERT(yuvaTextures[textureIndex].isValid());
- auto proxy = proxyProvider->wrapBackendTexture(yuvaTextures[textureIndex], grColorType,
+ auto proxy = proxyProvider->wrapBackendTexture(yuvaTextures[textureIndex],
kBorrow_GrWrapOwnership,
GrWrapCacheable::kNo, kRead_GrIOType);
if (!proxy) {
@@ -484,8 +484,8 @@
SkASSERT(tex);
} else {
if ((tex = resourceProvider->wrapBackendTexture(
- backendTexture, fColorType, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kYes, kRead_GrIOType))) {
+ backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kYes,
+ kRead_GrIOType))) {
tex->resourcePriv().setUniqueKey(key);
} else {
return {};
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index 7251f21..02864cf 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -161,7 +161,7 @@
// fails on the Nexus5. Why?
GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin;
sk_sp<GrSurfaceProxy> texProxy = context0->priv().proxyProvider()->wrapBackendTexture(
- backendTex, colorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
+ backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
if (!texProxy) {
ERRORF(reporter, "Error wrapping external texture in GrTextureProxy.");
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, &backendTexture1, image);
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index c3af99d..e653309 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -1004,8 +1004,7 @@
GrXferProcessor::DstProxyView fakeDstProxyView;
{
sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
- backendTex, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
- kRead_GrIOType);
+ backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType);
GrSwizzle swizzle = caps.getReadSwizzle(backendTex.getBackendFormat(),
GrColorType::kRGBA_8888);
fakeDstProxyView.setProxyView({std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle});
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 42abc42..5f58ca7 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -57,7 +57,7 @@
SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
sk_sp<GrSurface> texRT2 = resourceProvider->wrapRenderableBackendTexture(
- backendTex, 1, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
+ backendTex, 1, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asRenderTarget());
REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asTexture());
@@ -359,9 +359,8 @@
auto backendTex = context->createBackendTexture(&srcPixmap, 1,
GrRenderable::kYes, GrProtected::kNo);
- auto proxy = proxyProvider->wrapBackendTexture(backendTex, GrColorType::kRGBA_8888,
- kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, ioType);
+ auto proxy = proxyProvider->wrapBackendTexture(
+ backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, ioType);
GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(),
GrColorType::kRGBA_8888);
GrSurfaceProxyView view(proxy, kTopLeft_GrSurfaceOrigin, swizzle);
@@ -419,9 +418,8 @@
kSize, kSize, kRGBA_8888_SkColorType,
SkColors::kTransparent, GrMipMapped::kYes, GrRenderable::kYes,
GrProtected::kNo);
- proxy = proxyProvider->wrapBackendTexture(backendTex, GrColorType::kRGBA_8888,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
- ioType);
+ proxy = proxyProvider->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership,
+ GrWrapCacheable::kNo, ioType);
context->flush();
proxy->peekTexture()->texturePriv().markMipMapsDirty(); // avoids assert in GrGpu.
auto regenResult =
@@ -441,12 +439,10 @@
sk_sp<GrTexture> texture;
if (GrRenderable::kYes == renderable) {
texture = context->priv().resourceProvider()->wrapRenderableBackendTexture(
- backendTexture, 1, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo);
+ backendTexture, 1, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
} else {
texture = context->priv().resourceProvider()->wrapBackendTexture(
- backendTexture, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, kRW_GrIOType);
+ backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
}
// Add a release proc that deletes the GrBackendTexture.
struct ReleaseContext {
diff --git a/tests/GrTestingBackendTextureUploadTest.cpp b/tests/GrTestingBackendTextureUploadTest.cpp
index 126f72d..03f7dbb 100644
--- a/tests/GrTestingBackendTextureUploadTest.cpp
+++ b/tests/GrTestingBackendTextureUploadTest.cpp
@@ -63,11 +63,10 @@
sk_sp<GrTextureProxy> wrappedProxy;
if (GrRenderable::kYes == renderable) {
wrappedProxy = context->priv().proxyProvider()->wrapRenderableBackendTexture(
- backendTex, 1, grCT, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo);
+ backendTex, 1, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo);
} else {
wrappedProxy = context->priv().proxyProvider()->wrapBackendTexture(
- backendTex, grCT, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo,
- GrIOType::kRW_GrIOType);
+ backendTex, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo, GrIOType::kRW_GrIOType);
}
REPORTER_ASSERT(reporter, wrappedProxy);
diff --git a/tests/MtlCopySurfaceTest.mm b/tests/MtlCopySurfaceTest.mm
index a151593..e6603f8 100644
--- a/tests/MtlCopySurfaceTest.mm
+++ b/tests/MtlCopySurfaceTest.mm
@@ -41,8 +41,7 @@
GrBackendRenderTarget backendRT(kWidth, kHeight, 1, fbInfo);
GrProxyProvider* proxyProvider = context->priv().proxyProvider();
- sk_sp<GrSurfaceProxy> srcProxy = proxyProvider->wrapBackendRenderTarget(
- backendRT, GrColorType::kBGRA_8888);
+ sk_sp<GrSurfaceProxy> srcProxy = proxyProvider->wrapBackendRenderTarget(backendRT);
GrSurfaceProxyView dstView = GrSurfaceProxy::Copy(context, srcProxy.get(),
kTopLeft_GrSurfaceOrigin,
diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp
index 2f9d665..e5bdfda 100644
--- a/tests/ProxyConversionTest.cpp
+++ b/tests/ProxyConversionTest.cpp
@@ -26,7 +26,7 @@
GrColorType colorType) {
auto backendRT =
gpu->createTestingOnlyBackendRenderTarget(size.width(), size.height(), colorType);
- return provider->wrapBackendRenderTarget(backendRT, colorType, nullptr, nullptr);
+ return provider->wrapBackendRenderTarget(backendRT, nullptr, nullptr);
}
void clean_up_wrapped_rt(GrGpu* gpu, sk_sp<GrSurfaceProxy> proxy) {
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index c555665..9ff6656 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -222,8 +222,8 @@
if (ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType)) {
GrBackendRenderTarget backendRT = gpu->createTestingOnlyBackendRenderTarget(
kWidthHeight, kWidthHeight, grColorType);
- sk_sp<GrSurfaceProxy> sProxy(proxyProvider->wrapBackendRenderTarget(
- backendRT, grColorType, nullptr, nullptr));
+ sk_sp<GrSurfaceProxy> sProxy(
+ proxyProvider->wrapBackendRenderTarget(backendRT, nullptr, nullptr));
check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
static constexpr int kExpectedNumSamples = 1;
check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
@@ -250,8 +250,8 @@
static constexpr int kStencilBits = 8;
GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples,
kStencilBits, fboInfo);
- sk_sp<GrSurfaceProxy> sProxy(proxyProvider->wrapBackendRenderTarget(
- backendRT, grColorType, nullptr, nullptr));
+ sk_sp<GrSurfaceProxy> sProxy(
+ proxyProvider->wrapBackendRenderTarget(backendRT, nullptr, nullptr));
check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact, 0);
@@ -264,7 +264,7 @@
kWidthHeight, kWidthHeight, colorType, SkColors::kTransparent,
GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTextureAsRenderTarget(
- backendTex, grColorType, supportedNumSamples);
+ backendTex, supportedNumSamples);
if (!sProxy) {
context->deleteBackendTexture(backendTex);
continue; // This can fail on Mesa
@@ -285,7 +285,7 @@
GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapRenderableBackendTexture(
- backendTex, supportedNumSamples, grColorType, kBorrow_GrWrapOwnership,
+ backendTex, supportedNumSamples, kBorrow_GrWrapOwnership,
GrWrapCacheable::kNo, nullptr, nullptr);
if (!sProxy) {
context->deleteBackendTexture(backendTex);
@@ -308,8 +308,7 @@
GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTexture(
- backendTex, grColorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
- kRead_GrIOType);
+ backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType);
if (!sProxy) {
context->deleteBackendTexture(backendTex);
continue;
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index d30cf89..915efbe 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -167,8 +167,7 @@
}
sk_sp<GrTextureProxy> rectProxy = proxyProvider->wrapBackendTexture(
- rectangleTex, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, kRW_GrIOType);
+ rectangleTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
if (!rectProxy) {
ERRORF(reporter, "Error creating proxy for rectangle texture.");
diff --git a/tests/ResourceAllocatorTest.cpp b/tests/ResourceAllocatorTest.cpp
index 6db1aad..7c89bca 100644
--- a/tests/ResourceAllocatorTest.cpp
+++ b/tests/ResourceAllocatorTest.cpp
@@ -52,7 +52,7 @@
return nullptr;
}
- return proxyProvider->wrapBackendTexture(*backendTex, p.fColorType, kBorrow_GrWrapOwnership,
+ return proxyProvider->wrapBackendTexture(*backendTex, kBorrow_GrWrapOwnership,
GrWrapCacheable::kNo, kRead_GrIOType);
}
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 0b51aa7..cc769b6 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -212,12 +212,10 @@
context->resetContext();
sk_sp<GrTexture> borrowed(resourceProvider->wrapBackendTexture(
- backendTextures[0], GrColorType::kRGBA_8888,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType));
+ backendTextures[0], kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType));
sk_sp<GrTexture> adopted(resourceProvider->wrapBackendTexture(
- backendTextures[1], GrColorType::kRGBA_8888,
- kAdopt_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType));
+ backendTextures[1], kAdopt_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType));
REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr);
if (!borrowed || !adopted) {
@@ -1485,11 +1483,11 @@
for (int i = 0; i < 3; ++i) {
backends[i] = context->createBackendTexture(16, 16, SkColorType::kRGBA_8888_SkColorType,
GrMipMapped::kNo, GrRenderable::kNo);
- wrapped[i] = gpu->wrapBackendTexture(backends[i], GrColorType::kRGBA_8888,
+ wrapped[i] = gpu->wrapBackendTexture(backends[i],
GrWrapOwnership::kBorrow_GrWrapOwnership,
- (i < 2) ? GrWrapCacheable::kYes
- : GrWrapCacheable::kNo,
- GrIOType::kRead_GrIOType).release();
+ (i < 2) ? GrWrapCacheable::kYes : GrWrapCacheable::kNo,
+ GrIOType::kRead_GrIOType)
+ .release();
wrapped[i]->setRelease(releaseProc, &freed[i]);
}
@@ -1567,10 +1565,11 @@
GrBackendTexture backend = context->createBackendTexture(16, 16,
SkColorType::kRGBA_8888_SkColorType,
GrMipMapped::kNo, GrRenderable::kNo);
- GrTexture* tex = gpu->wrapBackendTexture(backend, GrColorType::kRGBA_8888,
+ GrTexture* tex = gpu->wrapBackendTexture(backend,
GrWrapOwnership::kBorrow_GrWrapOwnership,
GrWrapCacheable::kYes,
- GrIOType::kRead_GrIOType).release();
+ GrIOType::kRead_GrIOType)
+ .release();
auto releaseProc = [](void* ctx) {
int* index = (int*) ctx;
diff --git a/tests/TextureProxyTest.cpp b/tests/TextureProxyTest.cpp
index 5b19f1e..285db98 100644
--- a/tests/TextureProxyTest.cpp
+++ b/tests/TextureProxyTest.cpp
@@ -103,9 +103,8 @@
GrBackendTexture backendTex = (*backingSurface)->getBackendTexture();
- return proxyProvider->wrapBackendTexture(backendTex, GrColorType::kRGBA_8888,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kYes,
- kRead_GrIOType);
+ return proxyProvider->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership,
+ GrWrapCacheable::kYes, kRead_GrIOType);
}
diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp
index 9f9fda6..6abe470 100644
--- a/tests/VkWrapTests.cpp
+++ b/tests/VkWrapTests.cpp
@@ -30,7 +30,6 @@
const int kW = 1024;
const int kH = 1024;
const SkColorType kColorType = SkColorType::kRGBA_8888_SkColorType;
-const GrColorType kGrColorType = GrColorType::kRGBA_8888;
void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
@@ -45,9 +44,8 @@
GrVkImageInfo imageInfo;
SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
- sk_sp<GrTexture> tex = gpu->wrapBackendTexture(origBackendTex, kGrColorType,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
- kRead_GrIOType);
+ sk_sp<GrTexture> tex = gpu->wrapBackendTexture(origBackendTex, kBorrow_GrWrapOwnership,
+ GrWrapCacheable::kNo, kRead_GrIOType);
REPORTER_ASSERT(reporter, tex);
// image is null
@@ -55,11 +53,11 @@
GrVkImageInfo backendCopy = imageInfo;
backendCopy.fImage = VK_NULL_HANDLE;
GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
- tex = gpu->wrapBackendTexture(backendTex, kGrColorType, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, kRead_GrIOType);
+ tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
+ kRead_GrIOType);
REPORTER_ASSERT(reporter, !tex);
- tex = gpu->wrapBackendTexture(backendTex, kGrColorType, kAdopt_GrWrapOwnership,
- GrWrapCacheable::kNo, kRead_GrIOType);
+ tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo,
+ kRead_GrIOType);
REPORTER_ASSERT(reporter, !tex);
}
@@ -68,11 +66,11 @@
GrVkImageInfo backendCopy = imageInfo;
backendCopy.fAlloc = GrVkAlloc();
GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
- tex = gpu->wrapBackendTexture(backendTex, kGrColorType, kBorrow_GrWrapOwnership,
- GrWrapCacheable::kNo, kRead_GrIOType);
+ tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
+ kRead_GrIOType);
REPORTER_ASSERT(reporter, tex);
- tex = gpu->wrapBackendTexture(backendTex, kGrColorType, kAdopt_GrWrapOwnership,
- GrWrapCacheable::kNo, kRead_GrIOType);
+ tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo,
+ kRead_GrIOType);
REPORTER_ASSERT(reporter, !tex);
}
@@ -80,8 +78,8 @@
{
GrVkImageInfo backendCopy = imageInfo;
GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
- tex = gpu->wrapBackendTexture(backendTex, kGrColorType, kAdopt_GrWrapOwnership,
- GrWrapCacheable::kNo, kRead_GrIOType);
+ tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo,
+ kRead_GrIOType);
REPORTER_ASSERT(reporter, tex);
}
@@ -102,7 +100,7 @@
GrBackendRenderTarget origBackendRT(kW, kH, 1, 0, imageInfo);
- sk_sp<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(origBackendRT, kGrColorType);
+ sk_sp<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(origBackendRT);
REPORTER_ASSERT(reporter, rt);
// image is null
@@ -110,7 +108,7 @@
GrVkImageInfo backendCopy = imageInfo;
backendCopy.fImage = VK_NULL_HANDLE;
GrBackendRenderTarget backendRT(kW, kH, 1, 0, backendCopy);
- rt = gpu->wrapBackendRenderTarget(backendRT, kGrColorType);
+ rt = gpu->wrapBackendRenderTarget(backendRT);
REPORTER_ASSERT(reporter, !rt);
}
@@ -120,7 +118,7 @@
backendCopy.fAlloc = GrVkAlloc();
// can wrap null alloc
GrBackendRenderTarget backendRT(kW, kH, 1, 0, backendCopy);
- rt = gpu->wrapBackendRenderTarget(backendRT, kGrColorType);
+ rt = gpu->wrapBackendRenderTarget(backendRT);
REPORTER_ASSERT(reporter, rt);
}
@@ -142,7 +140,7 @@
SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
sk_sp<GrTexture> tex = gpu->wrapRenderableBackendTexture(
- origBackendTex, 1, kGrColorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
+ origBackendTex, 1, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, tex);
// image is null
@@ -150,11 +148,11 @@
GrVkImageInfo backendCopy = imageInfo;
backendCopy.fImage = VK_NULL_HANDLE;
GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
- tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kGrColorType,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
+ tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership,
+ GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, !tex);
- tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kGrColorType,
- kAdopt_GrWrapOwnership, GrWrapCacheable::kNo);
+ tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership,
+ GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, !tex);
}
@@ -163,11 +161,11 @@
GrVkImageInfo backendCopy = imageInfo;
backendCopy.fAlloc = GrVkAlloc();
GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
- tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kGrColorType,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
+ tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership,
+ GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, tex);
- tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kGrColorType,
- kAdopt_GrWrapOwnership, GrWrapCacheable::kNo);
+ tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership,
+ GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, !tex);
}
@@ -175,8 +173,8 @@
{
GrVkImageInfo backendCopy = imageInfo;
GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
- tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kGrColorType,
- kAdopt_GrWrapOwnership, GrWrapCacheable::kNo);
+ tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership,
+ GrWrapCacheable::kNo);
REPORTER_ASSERT(reporter, tex);
}
}
