Funnel most proxy creation through GrProxyProvider
This is to provide a choke point for DDL to create Lazy Proxies.
Change-Id: If178da13bc6447b31b7601810236d34502d9efbd
Reviewed-on: https://skia-review.googlesource.com/93303
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/gm/flippity.cpp b/gm/flippity.cpp
index 93813b9..bd9930c 100644
--- a/gm/flippity.cpp
+++ b/gm/flippity.cpp
@@ -13,6 +13,7 @@
#if SK_SUPPORT_GPU
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "SkImage_Gpu.h"
static const int kNumMatrices = 6;
@@ -93,6 +94,7 @@
static sk_sp<SkImage> make_reference_image(GrContext* context,
const SkTArray<sk_sp<SkImage>>& labels,
bool bottomLeftOrigin) {
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkASSERT(kNumLabels == labels.count());
SkImageInfo ii = SkImageInfo::Make(kImageSize, kImageSize,
@@ -130,10 +132,8 @@
}
}
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(
- context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kYes,
- bm.getPixels(), bm.rowBytes());
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ bm.getPixels(), bm.rowBytes());
if (!proxy) {
return nullptr;
}
diff --git a/gm/texdata.cpp b/gm/texdata.cpp
index 4e44bcc..b4193a3 100644
--- a/gm/texdata.cpp
+++ b/gm/texdata.cpp
@@ -12,6 +12,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrTextureContext.h"
#include "GrFixedClip.h"
@@ -76,6 +77,7 @@
return;
}
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
const SkImageInfo ii = SkImageInfo::Make(S, S, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
@@ -91,10 +93,8 @@
desc.fHeight = 2 * S;
desc.fConfig = SkImageInfo2GrPixelConfig(ii, *context->caps());
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(
- context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kNo,
- gTextureData.get(), 0);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
+ gTextureData.get(), 0);
if (!proxy) {
return;
}
diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp
index 7ee28b1..57f0129 100644
--- a/gm/texturedomaineffect.cpp
+++ b/gm/texturedomaineffect.cpp
@@ -13,6 +13,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContextPriv.h"
#include "SkBitmap.h"
#include "SkGr.h"
@@ -86,17 +87,16 @@
return;
}
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
desc.fWidth = fBmp.width();
desc.fHeight = fBmp.height();
desc.fConfig = SkImageInfo2GrPixelConfig(fBmp.info(), *context->caps());
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
- context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kYes,
- fBmp.getPixels(),
- fBmp.rowBytes()));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ fBmp.getPixels(),
+ fBmp.rowBytes());
if (!proxy) {
return;
}
diff --git a/gm/yuvtorgbeffect.cpp b/gm/yuvtorgbeffect.cpp
index ba27719..e314ea2 100644
--- a/gm/yuvtorgbeffect.cpp
+++ b/gm/yuvtorgbeffect.cpp
@@ -13,6 +13,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContextPriv.h"
#include "GrTextureProxy.h"
#include "SkBitmap.h"
@@ -82,6 +83,7 @@
return;
}
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> proxy[3];
{
@@ -93,9 +95,9 @@
desc.fHeight = fBmp[i].height();
desc.fConfig = SkImageInfo2GrPixelConfig(fBmp[i].info(), *context->caps());
- proxy[i] = GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kYes,
- fBmp[i].getPixels(), fBmp[i].rowBytes());
+ proxy[i] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ fBmp[i].getPixels(),
+ fBmp[i].rowBytes());
if (!proxy[i]) {
return;
}
@@ -210,6 +212,7 @@
return;
}
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> proxy[3];
{
@@ -223,10 +226,9 @@
desc.fHeight = fBmp[index].height();
desc.fConfig = SkImageInfo2GrPixelConfig(fBmp[index].info(), *context->caps());
- proxy[i] = GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kYes,
- fBmp[index].getPixels(),
- fBmp[index].rowBytes());
+ proxy[i] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ fBmp[index].getPixels(),
+ fBmp[index].rowBytes());
if (!proxy[i]) {
return;
}
diff --git a/include/private/GrRenderTargetProxy.h b/include/private/GrRenderTargetProxy.h
index bccb6a8..1cd3d5d 100644
--- a/include/private/GrRenderTargetProxy.h
+++ b/include/private/GrRenderTargetProxy.h
@@ -61,7 +61,7 @@
bool refsWrappedObjects() const;
protected:
- friend class GrSurfaceProxy; // for ctors
+ friend class GrProxyProvider; // for ctors
// Deferred version
GrRenderTargetProxy(const GrCaps&, const GrSurfaceDesc&,
diff --git a/include/private/GrSurfaceProxy.h b/include/private/GrSurfaceProxy.h
index 1a558fe..5a2a4b5 100644
--- a/include/private/GrSurfaceProxy.h
+++ b/include/private/GrSurfaceProxy.h
@@ -182,45 +182,9 @@
class GrSurfaceProxy : public GrIORefProxy {
public:
- static sk_sp<GrSurfaceProxy> MakeWrapped(sk_sp<GrSurface>, GrSurfaceOrigin);
+ // DDL TODO: remove this entry point
static sk_sp<GrTextureProxy> MakeWrapped(sk_sp<GrTexture>, GrSurfaceOrigin);
- static sk_sp<GrTextureProxy> MakeDeferred(GrProxyProvider*,
- const GrSurfaceDesc&, SkBackingFit,
- SkBudgeted, uint32_t flags = 0);
-
- /**
- * Creates a proxy that will be mipmapped.
- *
- * @param desc Description of the texture properties.
- * @param budgeted Does the texture count against the resource cache budget?
- * @param texels A contiguous array of mipmap levels
- * @param mipLevelCount The amount of elements in the texels array
- */
- static sk_sp<GrTextureProxy> MakeDeferredMipMap(GrProxyProvider*,
- const GrSurfaceDesc& desc, SkBudgeted budgeted,
- const GrMipLevel texels[], int mipLevelCount,
- SkDestinationSurfaceColorMode mipColorMode =
- SkDestinationSurfaceColorMode::kLegacy);
-
- /**
- * Like the call above but there are no texels to upload. A texture proxy is returned that
- * simply has space allocated for the mips. We will allocated the full amount of mip levels
- * based on the width and height in the GrSurfaceDesc.
- */
- static sk_sp<GrTextureProxy> MakeDeferredMipMap(GrProxyProvider*,
- const GrSurfaceDesc& desc, SkBudgeted budgeted);
-
-
- // TODO: need to refine ownership semantics of 'srcData' if we're in completely
- // deferred mode
- static sk_sp<GrTextureProxy> MakeDeferred(GrProxyProvider*,
- const GrSurfaceDesc&, SkBudgeted,
- const void* srcData, size_t rowBytes);
-
- static sk_sp<GrTextureProxy> MakeWrappedBackend(GrContext*, const GrBackendTexture&,
- GrSurfaceOrigin);
-
using LazyInstantiateCallback = std::function<sk_sp<GrTexture>(GrResourceProvider*,
GrSurfaceOrigin* outOrigin)>;
@@ -234,6 +198,7 @@
* (Stencil is not supported by this method.) The width and height must either both be greater
* than 0 or both less than or equal to zero. A non-positive value is a signal that the width
* and height are currently unknown.
+ * DDL TODO: remove this entry point
*/
static sk_sp<GrTextureProxy> MakeLazy(LazyInstantiateCallback&&, const GrSurfaceDesc& desc,
GrMipMapped, SkBackingFit fit, SkBudgeted budgeted);
diff --git a/include/private/GrTextureProxy.h b/include/private/GrTextureProxy.h
index d4daa8e..e9d4c50 100644
--- a/include/private/GrTextureProxy.h
+++ b/include/private/GrTextureProxy.h
@@ -61,7 +61,9 @@
const GrTextureProxyPriv texPriv() const;
protected:
+ // DDL TODO: rm the GrSurfaceProxy friending
friend class GrSurfaceProxy; // for ctors
+ friend class GrProxyProvider; // for ctors
friend class GrTextureProxyPriv;
// Deferred version
diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
index 55095e0..d414e66 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -227,8 +227,9 @@
create_circle_profile(sigma * scale, circleR * scale, kProfileTextureWidth));
}
- blurProfile = GrSurfaceProxy::MakeDeferred(proxyProvider, texDesc, SkBudgeted::kYes,
- profile.get(), 0);
+ // This will be an exact match texture
+ blurProfile = proxyProvider->createTextureProxy(texDesc, SkBudgeted::kYes,
+ profile.get(), 0);
if (!blurProfile) {
return nullptr;
}
diff --git a/src/gpu/GrBitmapTextureMaker.cpp b/src/gpu/GrBitmapTextureMaker.cpp
index 064b1aa..7531bf6 100644
--- a/src/gpu/GrBitmapTextureMaker.cpp
+++ b/src/gpu/GrBitmapTextureMaker.cpp
@@ -49,8 +49,7 @@
if (!proxy) {
if (willBeMipped) {
- proxy = GrGenerateMipMapsAndUploadToTextureProxy(this->context(), fBitmap,
- dstColorSpace);
+ proxy = GrGenerateMipMapsAndUploadToTextureProxy(proxyProvider, fBitmap, dstColorSpace);
}
if (!proxy) {
proxy = GrUploadBitmapToTextureProxy(proxyProvider, fBitmap, dstColorSpace);
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index ce77369..35fd52d 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -464,9 +464,8 @@
desc.fConfig = kAlpha_8_GrPixelConfig;
// MDB TODO: We're going to fill this proxy with an ASAP upload (which is out of order wrt
// to ops), so it can't have any pending IO.
- proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
- SkBackingFit::kApprox, SkBudgeted::kYes,
- GrResourceProvider::kNoPendingIO_Flag);
+ proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox, SkBudgeted::kYes,
+ GrResourceProvider::kNoPendingIO_Flag);
auto uploader = skstd::make_unique<GrTDeferredProxyUploader<ClipMaskData>>(reducedClip);
GrTDeferredProxyUploader<ClipMaskData>* uploaderRaw = uploader.get();
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index 131ac45..95d2344 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -530,10 +530,9 @@
sk_sp<GrTextureProxy> tempProxy;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
- tempProxy = GrSurfaceProxy::MakeDeferred(this->proxyProvider(),
- tempDrawInfo.fTempSurfaceDesc,
- SkBackingFit::kApprox,
- SkBudgeted::kYes);
+ tempProxy = this->proxyProvider()->createProxy(tempDrawInfo.fTempSurfaceDesc,
+ SkBackingFit::kApprox,
+ SkBudgeted::kYes);
if (!tempProxy && GrGpu::kRequireDraw_DrawPreference == drawPreference) {
return false;
}
@@ -821,12 +820,10 @@
sk_sp<GrTextureProxy> proxy;
if (GrMipMapped::kNo == mipMapped) {
- proxy = GrSurfaceProxy::MakeDeferred(this->proxyProvider(), dstDesc, fit,
- isDstBudgeted);
+ proxy = this->proxyProvider()->createProxy(dstDesc, fit, isDstBudgeted);
} else {
SkASSERT(SkBackingFit::kExact == fit);
- proxy = GrSurfaceProxy::MakeDeferredMipMap(this->proxyProvider(), dstDesc,
- isDstBudgeted);
+ proxy = this->proxyProvider()->createMipMapProxy(dstDesc, isDstBudgeted);
}
if (!proxy) {
return nullptr;
@@ -840,12 +837,7 @@
sk_sp<SkColorSpace> colorSpace) {
ASSERT_SINGLE_OWNER_PRIV
- sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTexture(tex));
- if (!surface) {
- return nullptr;
- }
-
- sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(surface), origin));
+ sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedTextureProxy(tex, origin);
if (!proxy) {
return nullptr;
}
@@ -861,13 +853,8 @@
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
- sk_sp<GrSurface> surface(
- fContext->resourceProvider()->wrapRenderableBackendTexture(tex, sampleCnt));
- if (!surface) {
- return nullptr;
- }
-
- sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(surface), origin));
+ sk_sp<GrTextureProxy> proxy(this->proxyProvider()->createWrappedTextureProxy(tex, origin,
+ sampleCnt));
if (!proxy) {
return nullptr;
}
@@ -883,12 +870,8 @@
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
- sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(backendRT));
- if (!rt) {
- return nullptr;
- }
-
- sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(rt), origin));
+ sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedRenderTargetProxy(backendRT,
+ origin);
if (!proxy) {
return nullptr;
}
@@ -903,24 +886,18 @@
GrSurfaceOrigin origin,
int sampleCnt,
sk_sp<SkColorSpace> colorSpace,
- const SkSurfaceProps* surfaceProps) {
+ const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
- sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTextureAsRenderTarget(
- tex,
- sampleCnt));
- if (!surface) {
- return nullptr;
- }
-
- sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(surface), origin));
+ sk_sp<GrSurfaceProxy> proxy(this->proxyProvider()->createWrappedRenderTargetProxy(tex, origin,
+ sampleCnt));
if (!proxy) {
return nullptr;
}
return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace),
- surfaceProps);
+ props);
}
void GrContextPriv::addOnFlushCallbackObject(GrOnFlushCallbackObject* onFlushCBObject) {
@@ -987,9 +964,9 @@
sk_sp<GrTextureProxy> rtp;
if (GrMipMapped::kNo == mipMapped) {
- rtp = GrSurfaceProxy::MakeDeferred(fProxyProvider, desc, fit, budgeted);
+ rtp = fProxyProvider->createProxy(desc, fit, budgeted);
} else {
- rtp = GrSurfaceProxy::MakeDeferredMipMap(fProxyProvider, desc, budgeted);
+ rtp = fProxyProvider->createMipMapProxy(desc, budgeted);
}
if (!rtp) {
return nullptr;
diff --git a/src/gpu/GrDrawOpAtlas.cpp b/src/gpu/GrDrawOpAtlas.cpp
index c0358b7..0ba9dec 100644
--- a/src/gpu/GrDrawOpAtlas.cpp
+++ b/src/gpu/GrDrawOpAtlas.cpp
@@ -8,8 +8,10 @@
#include "GrDrawOpAtlas.h"
#include "GrContext.h"
+#include "GrContextPriv.h"
#include "GrOpFlushState.h"
#include "GrRectanizer.h"
+#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
#include "GrTracing.h"
@@ -452,6 +454,8 @@
return false;
}
+ GrProxyProvider* proxyProvider = fContext->contextPriv().proxyProvider();
+
GrSurfaceDesc desc;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
@@ -463,16 +467,14 @@
// guarantee we do not recieve a texture with pending IO
// TODO: Determine how to avoid having to do this. (https://bug.skia.org/4156)
static const uint32_t kFlags = GrResourceProvider::kNoPendingIO_Flag;
- sk_sp<GrTexture> texture(fContext->resourceProvider()->createApproxTexture(desc, kFlags));
- if (texture) {
- // MDB TODO: for now, wrap an instantiated texture. Having the deferred instantiation
- // possess the correct properties (e.g., no pendingIO) should fall out of the system but
- // should receive special attention.
- // Note: When switching over to the deferred proxy, use the kExact flag to create
- // the atlas and assert that the width & height are powers of 2.
- fProxies[fNumPages] = GrSurfaceProxy::MakeWrapped(std::move(texture),
- kTopLeft_GrSurfaceOrigin);
- }
+ // MDB TODO: for now, wrap an instantiated texture. Having the deferred instantiation
+ // possess the correct properties (e.g., no pendingIO) should fall out of the system but
+ // should receive special attention.
+ // Note: When switching over to the deferred proxy, use the kExact flag to create
+ // the atlas and assert that the width & height are powers of 2.
+ // DDL TODO: remove this use of createInstantitateProxy & convert it to a testing-only method.
+ fProxies[fNumPages] = proxyProvider->createInstantiatedProxy(desc, SkBackingFit::kApprox,
+ SkBudgeted::kYes, kFlags);
if (!fProxies[fNumPages]) {
return false;
}
diff --git a/src/gpu/GrOnFlushResourceProvider.cpp b/src/gpu/GrOnFlushResourceProvider.cpp
index a93c9eb..7fcd30f 100644
--- a/src/gpu/GrOnFlushResourceProvider.cpp
+++ b/src/gpu/GrOnFlushResourceProvider.cpp
@@ -9,6 +9,7 @@
#include "GrContextPriv.h"
#include "GrDrawingManager.h"
+#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
sk_sp<GrRenderTargetContext> GrOnFlushResourceProvider::makeRenderTargetContext(
@@ -21,12 +22,10 @@
// Because this is being allocated at the start of a flush we must ensure the proxy
// will, when instantiated, have no pending IO.
// TODO: fold the kNoPendingIO_Flag into GrSurfaceFlags?
- sk_sp<GrSurfaceProxy> proxy = GrSurfaceProxy::MakeDeferred(
- fDrawingMgr->getContext()->contextPriv().proxyProvider(),
- tmpDesc,
- SkBackingFit::kExact,
- SkBudgeted::kYes,
- GrResourceProvider::kNoPendingIO_Flag);
+ GrProxyProvider* proxyProvider = fDrawingMgr->getContext()->contextPriv().proxyProvider();
+ sk_sp<GrSurfaceProxy> proxy = proxyProvider->createProxy(tmpDesc, SkBackingFit::kExact,
+ SkBudgeted::kYes,
+ GrResourceProvider::kNoPendingIO_Flag);
if (!proxy->asRenderTargetProxy()) {
return nullptr;
}
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index c9617ad..942d17f 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -8,13 +8,16 @@
#include "GrProxyProvider.h"
#include "GrCaps.h"
+#include "GrRenderTarget.h"
#include "GrResourceKey.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
#include "GrSurfaceProxyPriv.h"
#include "GrTexture.h"
#include "GrTextureProxyCacheAccess.h"
+#include "GrTextureRenderTargetProxy.h"
#include "../private/GrSingleOwner.h"
+#include "SkMipMap.h"
#define ASSERT_SINGLE_OWNER \
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fSingleOwner);)
@@ -126,24 +129,54 @@
return result;
}
+sk_sp<GrTextureProxy> GrProxyProvider::createInstantiatedProxy(const GrSurfaceDesc& desc,
+ SkBackingFit fit,
+ SkBudgeted budgeted,
+ uint32_t flags) {
+ sk_sp<GrTexture> tex;
+
+ if (SkBackingFit::kApprox == fit) {
+ tex = fResourceProvider->createApproxTexture(desc, flags);
+ } else {
+ tex = fResourceProvider->createTexture(desc, budgeted, flags);
+ }
+ if (!tex) {
+ return nullptr;
+ }
+
+ SkASSERT(!tex->getUniqueKey().isValid());
+
+ if (tex->asRenderTarget()) {
+ return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), desc.fOrigin));
+ }
+
+ return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), desc.fOrigin));
+}
+
sk_sp<GrTextureProxy> GrProxyProvider::createTextureProxy(const GrSurfaceDesc& desc,
SkBudgeted budgeted,
- const GrMipLevel& mipLevel) {
+ const void* srcData, size_t rowBytes) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
- sk_sp<GrTexture> tex = fResourceProvider->createTexture(desc, budgeted, mipLevel);
- if (!tex) {
- return nullptr;
+ if (srcData) {
+ GrMipLevel mipLevel = { srcData, rowBytes };
+
+ sk_sp<GrTexture> tex = fResourceProvider->createTexture(desc, budgeted, mipLevel);
+ if (!tex) {
+ return nullptr;
+ }
+
+ return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
}
- return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
+ return this->createProxy(desc, SkBackingFit::kExact, budgeted);
}
-sk_sp<GrTextureProxy> GrProxyProvider::createTextureProxy(
+sk_sp<GrTextureProxy> GrProxyProvider::createMipMapProxy(
const GrSurfaceDesc& desc, SkBudgeted budgeted,
const GrMipLevel texels[], int mipLevelCount,
SkDestinationSurfaceColorMode mipColorMode) {
@@ -153,6 +186,38 @@
return nullptr;
}
+ if (!mipLevelCount) {
+ if (texels) {
+ return nullptr;
+ }
+ return this->createProxy(desc, SkBackingFit::kExact, budgeted);
+ }
+ if (!texels) {
+ return nullptr;
+ }
+
+ if (1 == mipLevelCount) {
+ return this->createTextureProxy(desc, budgeted, texels[0].fPixels, texels[0].fRowBytes);
+ }
+
+#ifdef SK_DEBUG
+ // There are only three states we want to be in when uploading data to a mipped surface.
+ // 1) We have data to upload to all layers
+ // 2) We are not uploading data to any layers
+ // 3) We are only uploading data to the base layer
+ // We check here to make sure we do not have any other state.
+ bool firstLevelHasData = SkToBool(texels[0].fPixels);
+ bool allOtherLevelsHaveData = true, allOtherLevelsLackData = true;
+ for (int i = 1; i < mipLevelCount; ++i) {
+ if (texels[i].fPixels) {
+ allOtherLevelsLackData = false;
+ } else {
+ allOtherLevelsHaveData = false;
+ }
+ }
+ SkASSERT((firstLevelHasData && allOtherLevelsHaveData) || allOtherLevelsLackData);
+#endif
+
sk_sp<GrTexture> tex(fResourceProvider->createTexture(desc, budgeted,
texels, mipLevelCount,
mipColorMode));
@@ -163,6 +228,137 @@
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
}
+sk_sp<GrTextureProxy> GrProxyProvider::createMipMapProxy(const GrSurfaceDesc& desc,
+ SkBudgeted budgeted) {
+ // SkMipMap doesn't include the base level in the level count so we have to add 1
+ int mipCount = SkMipMap::ComputeLevelCount(desc.fWidth, desc.fHeight) + 1;
+
+ std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipCount]);
+
+ // We don't want to upload any texel data
+ for (int i = 0; i < mipCount; i++) {
+ texels[i].fPixels = nullptr;
+ texels[i].fRowBytes = 0;
+ }
+
+ return this->createMipMapProxy(desc, budgeted, texels.get(), mipCount,
+ SkDestinationSurfaceColorMode::kLegacy);
+}
+
+sk_sp<GrTextureProxy> GrProxyProvider::createProxy(const GrSurfaceDesc& desc,
+ SkBackingFit fit,
+ SkBudgeted budgeted,
+ uint32_t flags) {
+ SkASSERT(0 == flags || GrResourceProvider::kNoPendingIO_Flag == flags);
+
+ const GrCaps* caps = this->caps();
+
+ // TODO: move this logic into GrResourceProvider!
+ // TODO: share this testing code with check_texture_creation_params
+ if (!caps->isConfigTexturable(desc.fConfig)) {
+ return nullptr;
+ }
+
+ bool willBeRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
+ if (willBeRT && !caps->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+ return nullptr;
+ }
+
+ // We currently do not support multisampled textures
+ if (!willBeRT && desc.fSampleCnt > 0) {
+ return nullptr;
+ }
+
+ int maxSize;
+ if (willBeRT) {
+ maxSize = caps->maxRenderTargetSize();
+ } else {
+ maxSize = caps->maxTextureSize();
+ }
+
+ if (desc.fWidth > maxSize || desc.fHeight > maxSize || desc.fWidth <= 0 || desc.fHeight <= 0) {
+ return nullptr;
+ }
+
+ GrSurfaceDesc copyDesc = desc;
+ copyDesc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig);
+
+#ifdef SK_DISABLE_DEFERRED_PROXIES
+ // Temporarily force instantiation for crbug.com/769760 and crbug.com/769898
+ sk_sp<GrTexture> tex;
+
+ if (SkBackingFit::kApprox == fit) {
+ tex = resourceProvider->createApproxTexture(copyDesc, flags);
+ } else {
+ tex = resourceProvider->createTexture(copyDesc, budgeted, flags);
+ }
+
+ if (!tex) {
+ return nullptr;
+ }
+
+ return GrSurfaceProxy::MakeWrapped(std::move(tex), copyDesc.fOrigin);
+#else
+ if (willBeRT) {
+ // We know anything we instantiate later from this deferred path will be
+ // both texturable and renderable
+ return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(*caps, copyDesc, fit,
+ budgeted, flags));
+ }
+
+ return sk_sp<GrTextureProxy>(new GrTextureProxy(copyDesc, fit, budgeted, nullptr, 0, flags));
+#endif
+}
+
+sk_sp<GrTextureProxy> GrProxyProvider::createWrappedTextureProxy(const GrBackendTexture& backendTex,
+ GrSurfaceOrigin origin) {
+ sk_sp<GrTexture> texture(fResourceProvider->wrapBackendTexture(backendTex));
+ if (!texture) {
+ return nullptr;
+ }
+ SkASSERT(!texture->asRenderTarget()); // Strictly a GrTexture
+
+ return GrSurfaceProxy::MakeWrapped(std::move(texture), origin);
+}
+
+sk_sp<GrTextureProxy> GrProxyProvider::createWrappedTextureProxy(const GrBackendTexture& tex,
+ GrSurfaceOrigin origin,
+ int sampleCnt) {
+ sk_sp<GrTexture> texture(fResourceProvider->wrapRenderableBackendTexture(tex, sampleCnt));
+ if (!texture) {
+ return nullptr;
+ }
+ SkASSERT(texture->asRenderTarget()); // A GrTextureRenderTarget
+
+ return GrSurfaceProxy::MakeWrapped(std::move(texture), origin);
+}
+
+sk_sp<GrSurfaceProxy> GrProxyProvider::createWrappedRenderTargetProxy(
+ const GrBackendRenderTarget& backendRT,
+ GrSurfaceOrigin origin) {
+ sk_sp<GrRenderTarget> rt(fResourceProvider->wrapBackendRenderTarget(backendRT));
+ if (!rt) {
+ return nullptr;
+ }
+ SkASSERT(!rt->asTexture()); // Strictly a GrRenderTarget
+ SkASSERT(!rt->getUniqueKey().isValid());
+
+ return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin));
+}
+
+sk_sp<GrSurfaceProxy> GrProxyProvider::createWrappedRenderTargetProxy(const GrBackendTexture& tex,
+ GrSurfaceOrigin origin,
+ int sampleCnt) {
+ sk_sp<GrRenderTarget> rt(fResourceProvider->wrapBackendTextureAsRenderTarget(tex, sampleCnt));
+ if (!rt) {
+ return nullptr;
+ }
+ SkASSERT(!rt->asTexture()); // Strictly a GrRenderTarget
+ SkASSERT(!rt->getUniqueKey().isValid());
+
+ return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin));
+}
+
bool GrProxyProvider::IsFunctionallyExact(GrSurfaceProxy* proxy) {
return proxy->priv().isExact() || (SkIsPow2(proxy->width()) && SkIsPow2(proxy->height()));
}
diff --git a/src/gpu/GrProxyProvider.h b/src/gpu/GrProxyProvider.h
index 404e020..1150c79 100644
--- a/src/gpu/GrProxyProvider.h
+++ b/src/gpu/GrProxyProvider.h
@@ -17,6 +17,7 @@
class GrCaps;
class GrResourceProvider;
class GrSingleOwner;
+class GrBackendRenderTarget;
/*
* A factory for creating GrSurfaceProxy-derived objects.
@@ -57,16 +58,75 @@
sk_sp<GrTextureProxy> findOrCreateProxyByUniqueKey(const GrUniqueKey&, GrSurfaceOrigin);
/*
- * Create an un-mipmapped texture proxy with data.
+ * Create a texture proxy that is backed by an instantiated GrSurface. This is almost entirely
+ * used by Skia's testing code.
+ * DDL TODO: remove the remaining Skia-internal use of this method and make it truly
+ * testing-only.
*/
- sk_sp<GrTextureProxy> createTextureProxy(const GrSurfaceDesc&, SkBudgeted, const GrMipLevel&);
+ sk_sp<GrTextureProxy> createInstantiatedProxy(const GrSurfaceDesc&, SkBackingFit, SkBudgeted,
+ uint32_t flags = 0);
+
+ /*
+ * Create an un-mipmapped texture proxy with data.
+ * DDL TODO: need to refine ownership semantics of 'srcData' if we're in completely
+ * deferred mode
+ */
+ sk_sp<GrTextureProxy> createTextureProxy(const GrSurfaceDesc&, SkBudgeted,
+ const void* srcData, size_t rowBytes);
/*
* Create a mipmapped texture proxy with data.
+ *
+ * @param desc Description of the texture properties.
+ * @param budgeted Does the texture count against the resource cache budget?
+ * @param texels A contiguous array of mipmap levels
+ * @param mipLevelCount The amount of elements in the texels array
*/
- sk_sp<GrTextureProxy> createTextureProxy(const GrSurfaceDesc&, SkBudgeted,
- const GrMipLevel texels[], int mipLevelCount,
- SkDestinationSurfaceColorMode mipColorMode);
+ sk_sp<GrTextureProxy> createMipMapProxy(const GrSurfaceDesc&, SkBudgeted,
+ const GrMipLevel texels[], int mipLevelCount,
+ SkDestinationSurfaceColorMode mipColorMode =
+ SkDestinationSurfaceColorMode::kLegacy);
+
+
+ /*
+ * Create a mipmapped texture proxy without any data.
+ *
+ * Like the call above but there are no texels to upload. A texture proxy is returned that
+ * simply has space allocated for the mips. We will allocated the full amount of mip levels
+ * based on the width and height in the GrSurfaceDesc.
+ */
+ sk_sp<GrTextureProxy> createMipMapProxy(const GrSurfaceDesc&, SkBudgeted);
+
+ /*
+ * Create a GrSurfaceProxy without any data.
+ */
+ sk_sp<GrTextureProxy> createProxy(const GrSurfaceDesc&, SkBackingFit, SkBudgeted,
+ uint32_t flags = 0);
+
+ /*
+ * Create a texture proxy that wraps a (non-renderable) backend texture.
+ */
+ sk_sp<GrTextureProxy> createWrappedTextureProxy(const GrBackendTexture&, GrSurfaceOrigin);
+
+ /*
+ * Create a texture proxy that wraps a backend texture and is both texture-able and renderable
+ */
+ sk_sp<GrTextureProxy> createWrappedTextureProxy(const GrBackendTexture&,
+ GrSurfaceOrigin,
+ int sampleCnt);
+
+ /*
+ * Create a render target proxy that wraps a backend rendertarget
+ */
+ sk_sp<GrSurfaceProxy> createWrappedRenderTargetProxy(const GrBackendRenderTarget&,
+ GrSurfaceOrigin);
+
+ /*
+ * Create a render target proxy that wraps a backend texture?
+ */
+ sk_sp<GrSurfaceProxy> createWrappedRenderTargetProxy(const GrBackendTexture& tex,
+ GrSurfaceOrigin origin,
+ int sampleCnt);
// 'proxy' is about to be used as a texture src or drawn to. This query can be used to
// determine if it is going to need a texture domain or a full clear.
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index 048b87f..33773a8 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -15,6 +15,7 @@
#include "GrGpu.h"
#include "GrPath.h"
#include "GrPathRendering.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetPriv.h"
#include "GrResourceCache.h"
#include "GrResourceKey.h"
@@ -128,19 +129,22 @@
}
GrContext* context = fGpu->getContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkImageInfo srcInfo;
if (make_info(desc.fWidth, desc.fHeight, desc.fConfig, &srcInfo)) {
- sk_sp<GrTexture> tex = this->getExactScratch(desc, budgeted, 0);
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex, desc.fOrigin);
+ // DDL TODO: remove this use of createInstantiatedProxy and convert it to a testing-only
+ // method.
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createInstantiatedProxy(desc,
+ SkBackingFit::kExact,
+ budgeted);
if (proxy) {
sk_sp<GrSurfaceContext> sContext =
context->contextPriv().makeWrappedSurfaceContext(std::move(proxy), nullptr);
if (sContext) {
if (sContext->writePixels(srcInfo, mipLevel.fPixels, mipLevel.fRowBytes, 0, 0)) {
- SkASSERT(sContext->asTextureProxy()->priv().peekTexture() == tex.get());
- return tex;
+ return sk_ref_sp(sContext->asTextureProxy()->priv().peekTexture());
}
}
}
@@ -464,7 +468,7 @@
if (this->isAbandoned()) {
return nullptr;
}
- return this->gpu()->wrapBackendTextureAsRenderTarget(tex, sampleCnt);
+ return fGpu->wrapBackendTextureAsRenderTarget(tex, sampleCnt);
}
sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT GrResourceProvider::makeSemaphore(bool isOwned) {
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 3fd5df4..ff6a20f 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -169,15 +169,18 @@
static sk_sp<GrTextureProxy> make_deferred_mask_texture_proxy(GrContext* context, SkBackingFit fit,
int width, int height) {
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
+
GrSurfaceDesc desc;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = kAlpha_8_GrPixelConfig;
+
// MDB TODO: We're going to fill this proxy with an ASAP upload (which is out of order wrt to
// ops), so it can't have any pending IO.
- return GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(), desc, fit,
- SkBudgeted::kYes, GrResourceProvider::kNoPendingIO_Flag);
+ return proxyProvider->createProxy(desc, fit, SkBudgeted::kYes,
+ GrResourceProvider::kNoPendingIO_Flag);
}
namespace {
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index e505a9c..c9da6ce 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -223,35 +223,6 @@
return fLastOpList ? fLastOpList->asTextureOpList() : nullptr;
}
-sk_sp<GrSurfaceProxy> GrSurfaceProxy::MakeWrapped(sk_sp<GrSurface> surf, GrSurfaceOrigin origin) {
- if (!surf) {
- return nullptr;
- }
-
- if (surf->getUniqueKey().isValid()) {
- // The proxy may already be in the hash. Thus we need to look for it first before creating
- // new one.
- GrProxyProvider* provider = surf->getContext()->contextPriv().proxyProvider();
- sk_sp<GrSurfaceProxy> proxy = provider->findProxyByUniqueKey(surf->getUniqueKey(), origin);
- if (proxy) {
- return proxy;
- }
- }
-
- if (surf->asTexture()) {
- if (surf->asRenderTarget()) {
- return sk_sp<GrSurfaceProxy>(new GrTextureRenderTargetProxy(std::move(surf), origin));
- } else {
- return sk_sp<GrSurfaceProxy>(new GrTextureProxy(std::move(surf), origin));
- }
- } else {
- SkASSERT(surf->asRenderTarget());
-
- // Not texturable
- return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(surf), origin));
- }
-}
-
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeWrapped(sk_sp<GrTexture> tex, GrSurfaceOrigin origin) {
if (!tex) {
return nullptr;
@@ -274,152 +245,6 @@
}
}
-sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrProxyProvider* proxyProvider,
- const GrSurfaceDesc& desc,
- SkBackingFit fit,
- SkBudgeted budgeted,
- uint32_t flags) {
- SkASSERT(0 == flags || GrResourceProvider::kNoPendingIO_Flag == flags);
-
- const GrCaps* caps = proxyProvider->caps();
-
- // TODO: move this logic into GrResourceProvider!
- // TODO: share this testing code with check_texture_creation_params
- if (!caps->isConfigTexturable(desc.fConfig)) {
- return nullptr;
- }
-
- bool willBeRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
- if (willBeRT && !caps->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
- return nullptr;
- }
-
- // We currently do not support multisampled textures
- if (!willBeRT && desc.fSampleCnt > 0) {
- return nullptr;
- }
-
- int maxSize;
- if (willBeRT) {
- maxSize = caps->maxRenderTargetSize();
- } else {
- maxSize = caps->maxTextureSize();
- }
-
- if (desc.fWidth > maxSize || desc.fHeight > maxSize || desc.fWidth <= 0 || desc.fHeight <= 0) {
- return nullptr;
- }
-
- GrSurfaceDesc copyDesc = desc;
- copyDesc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig);
-
-#ifdef SK_DISABLE_DEFERRED_PROXIES
- // Temporarily force instantiation for crbug.com/769760 and crbug.com/769898
- sk_sp<GrTexture> tex;
-
- if (SkBackingFit::kApprox == fit) {
- tex = resourceProvider->createApproxTexture(copyDesc, flags);
- } else {
- tex = resourceProvider->createTexture(copyDesc, budgeted, flags);
- }
-
- if (!tex) {
- return nullptr;
- }
-
- return GrSurfaceProxy::MakeWrapped(std::move(tex), copyDesc.fOrigin);
-#else
- if (willBeRT) {
- // We know anything we instantiate later from this deferred path will be
- // both texturable and renderable
- return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(*caps, copyDesc, fit,
- budgeted, flags));
- }
-
- return sk_sp<GrTextureProxy>(new GrTextureProxy(copyDesc, fit, budgeted, nullptr, 0, flags));
-#endif
-}
-
-sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrProxyProvider* proxyProvider,
- const GrSurfaceDesc& desc,
- SkBudgeted budgeted,
- const void* srcData,
- size_t rowBytes) {
- if (srcData) {
- GrMipLevel mipLevel = { srcData, rowBytes };
-
- return proxyProvider->createTextureProxy(desc, budgeted, mipLevel);
- }
-
- return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBackingFit::kExact, budgeted);
-}
-
-sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferredMipMap(GrProxyProvider* proxyProvider,
- const GrSurfaceDesc& desc,
- SkBudgeted budgeted) {
- // SkMipMap doesn't include the base level in the level count so we have to add 1
- int mipCount = SkMipMap::ComputeLevelCount(desc.fWidth, desc.fHeight) + 1;
-
- std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipCount]);
-
- // We don't want to upload any texel data
- for (int i = 0; i < mipCount; i++) {
- texels[i].fPixels = nullptr;
- texels[i].fRowBytes = 0;
- }
-
- return MakeDeferredMipMap(proxyProvider, desc, budgeted, texels.get(), mipCount);
-}
-
-sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferredMipMap(
- GrProxyProvider* proxyProvider,
- const GrSurfaceDesc& desc,
- SkBudgeted budgeted,
- const GrMipLevel texels[],
- int mipLevelCount,
- SkDestinationSurfaceColorMode mipColorMode) {
- if (!mipLevelCount) {
- if (texels) {
- return nullptr;
- }
- return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, budgeted, nullptr, 0);
- }
- if (!texels) {
- return nullptr;
- }
-
- if (1 == mipLevelCount) {
- return proxyProvider->createTextureProxy(desc, budgeted, texels[0]);
- }
-
-#ifdef SK_DEBUG
- // There are only three states we want to be in when uploading data to a mipped surface.
- // 1) We have data to upload to all layers
- // 2) We are not uploading data to any layers
- // 3) We are only uploading data to the base layer
- // We check here to make sure we do not have any other state.
- bool firstLevelHasData = SkToBool(texels[0].fPixels);
- bool allOtherLevelsHaveData = true, allOtherLevelsLackData = true;
- for (int i = 1; i < mipLevelCount; ++i) {
- if (texels[i].fPixels) {
- allOtherLevelsLackData = false;
- } else {
- allOtherLevelsHaveData = false;
- }
- }
- SkASSERT((firstLevelHasData && allOtherLevelsHaveData) || allOtherLevelsLackData);
-#endif
-
- return proxyProvider->createTextureProxy(desc, budgeted, texels, mipLevelCount, mipColorMode);
-}
-
-sk_sp<GrTextureProxy> GrSurfaceProxy::MakeWrappedBackend(GrContext* context,
- const GrBackendTexture& backendTex,
- GrSurfaceOrigin origin) {
- sk_sp<GrTexture> tex(context->resourceProvider()->wrapBackendTexture(backendTex));
- return GrSurfaceProxy::MakeWrapped(std::move(tex), origin);
-}
-
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeLazy(LazyInstantiateCallback&& callback,
const GrSurfaceDesc& desc,
GrMipMapped mipMapped,
diff --git a/src/gpu/GrTextureRenderTargetProxy.h b/src/gpu/GrTextureRenderTargetProxy.h
index 739f797..63cc487 100644
--- a/src/gpu/GrTextureRenderTargetProxy.h
+++ b/src/gpu/GrTextureRenderTargetProxy.h
@@ -23,7 +23,9 @@
// the uniqueID of the RenderTarget/Texture it represents!
class GrTextureRenderTargetProxy : public GrTextureProxy, public GrRenderTargetProxy {
private:
+ // DDL TODO: rm the GrSurfaceProxy friending
friend class GrSurfaceProxy; // for ctors
+ friend class GrProxyProvider; // for ctors
// Deferred version
GrTextureRenderTargetProxy(const GrCaps&, const GrSurfaceDesc&,
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index da57a04..8faa9d4 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -92,8 +92,8 @@
ATRACE_ANDROID_FRAMEWORK("Upload Texture [%ux%u]", pixmap.width(), pixmap.height());
GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *proxyProvider->caps());
- return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, budgeted, pixmap.addr(),
- pixmap.rowBytes());
+
+ return proxyProvider->createTextureProxy(desc, budgeted, pixmap.addr(), pixmap.rowBytes());
}
////////////////////////////////////////////////////////////////////////////////
@@ -111,7 +111,7 @@
pixelRef->addGenIDChangeListener(new Invalidator(key));
}
-sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext* ctx,
+sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrProxyProvider* proxyProvider,
const SkBitmap& bitmap,
SkColorSpace* dstColorSpace) {
SkDestinationSurfaceColorMode colorMode = dstColorSpace
@@ -128,7 +128,7 @@
}
ATRACE_ANDROID_FRAMEWORK("Upload MipMap Texture [%ux%u]", pixmap.width(), pixmap.height());
- GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *ctx->resourceProvider()->caps());
+ GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *proxyProvider->caps());
std::unique_ptr<SkMipMap> mipmaps(SkMipMap::Build(pixmap, colorMode, nullptr));
if (!mipmaps) {
return nullptr;
@@ -151,22 +151,18 @@
texels[i].fRowBytes = generatedMipLevel.fPixmap.rowBytes();
}
- return GrSurfaceProxy::MakeDeferredMipMap(ctx->contextPriv().proxyProvider(),
- desc,
- SkBudgeted::kYes,
- texels.get(),
- mipLevelCount,
- colorMode);
+ return proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes, texels.get(), mipLevelCount,
+ colorMode);
}
-sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext* ctx,
- GrTextureProxy* baseProxy) {
+sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext* ctx, GrTextureProxy* baseProxy) {
SkASSERT(baseProxy);
if (!ctx->caps()->isConfigCopyable(baseProxy->config())) {
return nullptr;
}
+ GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fOrigin = baseProxy->origin();
@@ -175,9 +171,7 @@
desc.fConfig = baseProxy->config();
desc.fSampleCnt = 0;
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferredMipMap(ctx->contextPriv().proxyProvider(),
- desc,
- SkBudgeted::kYes);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes);
if (!proxy) {
return nullptr;
}
@@ -191,7 +185,8 @@
}
-sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext* ctx, const SkImageInfo& info,
+sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrProxyProvider* proxyProvider,
+ const SkImageInfo& info,
const GrMipLevel texels[],
int mipLevelCount,
SkDestinationSurfaceColorMode colorMode) {
@@ -199,10 +194,10 @@
return nullptr;
}
- return GrSurfaceProxy::MakeDeferredMipMap(ctx->contextPriv().proxyProvider(),
- GrImageInfoToSurfaceDesc(info, *ctx->caps()),
- SkBudgeted::kYes, texels,
- mipLevelCount, colorMode);
+ GrSurfaceDesc desc(GrImageInfoToSurfaceDesc(info, *proxyProvider->caps()));
+
+ return proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes,
+ texels, mipLevelCount, colorMode);
}
sk_sp<GrTextureProxy> GrRefCachedBitmapTextureProxy(GrContext* ctx,
diff --git a/src/gpu/SkGr.h b/src/gpu/SkGr.h
index 87b602e..3bf3ba9 100644
--- a/src/gpu/SkGr.h
+++ b/src/gpu/SkGr.h
@@ -208,7 +208,7 @@
sk_sp<GrTextureProxy> GrUploadBitmapToTextureProxy(GrProxyProvider*, const SkBitmap&,
SkColorSpace* dstColorSpace);
-sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext*, const SkBitmap&,
+sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrProxyProvider*, const SkBitmap&,
SkColorSpace* dstColorSpace);
/**
@@ -226,7 +226,7 @@
/**
* Creates a new texture populated with the mipmap levels.
*/
-sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext*, const SkImageInfo&,
+sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrProxyProvider*, const SkImageInfo&,
const GrMipLevel texels[],
int mipLevelCount,
SkDestinationSurfaceColorMode colorMode);
diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h
index 9656c7f..46964f5 100644
--- a/src/gpu/effects/GrConfigConversionEffect.h
+++ b/src/gpu/effects/GrConfigConversionEffect.h
@@ -16,6 +16,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
@@ -60,8 +61,8 @@
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
- sk_sp<GrTextureProxy> dataProxy =
- GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes, data, 0);
+ sk_sp<GrTextureProxy> dataProxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ data, 0);
if (!dataProxy) {
return false;
}
diff --git a/src/gpu/effects/GrRectBlurEffect.h b/src/gpu/effects/GrRectBlurEffect.h
index 4f9b971..acc38b3 100644
--- a/src/gpu/effects/GrRectBlurEffect.h
+++ b/src/gpu/effects/GrRectBlurEffect.h
@@ -40,8 +40,8 @@
std::unique_ptr<uint8_t[]> profile(SkBlurMask::ComputeBlurProfile(sigma));
- blurProfile = GrSurfaceProxy::MakeDeferred(proxyProvider, texDesc, SkBudgeted::kYes,
- profile.get(), 0);
+ blurProfile = proxyProvider->createTextureProxy(texDesc, SkBudgeted::kYes,
+ profile.get(), 0);
if (!blurProfile) {
return nullptr;
}
diff --git a/src/gpu/effects/GrTextureStripAtlas.cpp b/src/gpu/effects/GrTextureStripAtlas.cpp
index f39da2a..ab02b6d 100644
--- a/src/gpu/effects/GrTextureStripAtlas.cpp
+++ b/src/gpu/effects/GrTextureStripAtlas.cpp
@@ -218,10 +218,8 @@
texDesc.fHeight = fDesc.fHeight;
texDesc.fConfig = fDesc.fConfig;
- proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- texDesc, SkBackingFit::kExact,
- SkBudgeted::kYes,
- GrResourceProvider::kNoPendingIO_Flag);
+ proxy = proxyProvider->createProxy(texDesc, SkBackingFit::kExact, SkBudgeted::kYes,
+ GrResourceProvider::kNoPendingIO_Flag);
if (!proxy) {
return;
}
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index 6d735f5..6e2e430 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -793,6 +793,7 @@
#if GR_TEST_UTILS
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
GR_DRAW_OP_TEST_DEFINE(TextureOp) {
GrSurfaceDesc desc;
@@ -801,9 +802,10 @@
desc.fWidth = random->nextULessThan(90) + 10;
desc.fOrigin = random->nextBool() ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
SkBackingFit fit = random->nextBool() ? SkBackingFit::kApprox : SkBackingFit::kExact;
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(
- context->contextPriv().proxyProvider(),
- desc, fit, SkBudgeted::kNo);
+
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, fit, SkBudgeted::kNo);
+
SkRect rect = GrTest::TestRect(random);
SkRect srcRect;
srcRect.fLeft = random->nextRangeScalar(0.f, proxy->width() / 2.f);
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index e70ba05..20e8349 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -19,6 +19,7 @@
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrImageTextureMaker.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrResourceProvider.h"
#include "GrSemaphore.h"
@@ -291,10 +292,10 @@
tex->setRelease(releaseProc, releaseCtx);
}
- const SkBudgeted budgeted = SkBudgeted::kNo;
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(tex), origin));
+
return sk_make_sp<SkImage_Gpu>(ctx, kNeedNewImageUniqueID,
- at, std::move(proxy), std::move(colorSpace), budgeted);
+ at, std::move(proxy), std::move(colorSpace), SkBudgeted::kNo);
}
sk_sp<SkImage> SkImage::MakeFromTexture(GrContext* ctx,
@@ -394,20 +395,22 @@
const SkISize yuvSizes[],
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> imageColorSpace) {
+ GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
+
if (!are_yuv_sizes_valid(yuvSizes, nv12)) {
return nullptr;
}
- sk_sp<GrTextureProxy> yProxy = GrSurfaceProxy::MakeWrappedBackend(ctx, yuvBackendTextures[0],
- origin);
- sk_sp<GrTextureProxy> uProxy = GrSurfaceProxy::MakeWrappedBackend(ctx, yuvBackendTextures[1],
- origin);
+ sk_sp<GrTextureProxy> yProxy = proxyProvider->createWrappedTextureProxy(yuvBackendTextures[0],
+ origin);
+ sk_sp<GrTextureProxy> uProxy = proxyProvider->createWrappedTextureProxy(yuvBackendTextures[1],
+ origin);
sk_sp<GrTextureProxy> vProxy;
if (nv12) {
vProxy = uProxy;
} else {
- vProxy = GrSurfaceProxy::MakeWrappedBackend(ctx, yuvBackendTextures[2], origin);
+ vProxy = proxyProvider->createWrappedTextureProxy(yuvBackendTextures[2], origin);
}
if (!yProxy || !uProxy || !vProxy) {
return nullptr;
@@ -605,15 +608,16 @@
return SkImage::MakeRasterCopy(pixmap);
}
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
// Turn the pixmap into a GrTextureProxy
sk_sp<GrTextureProxy> proxy;
if (buildMips) {
SkBitmap bmp;
bmp.installPixels(pixmap);
- proxy = GrGenerateMipMapsAndUploadToTextureProxy(context, bmp, dstColorSpace);
+ proxy = GrGenerateMipMapsAndUploadToTextureProxy(proxyProvider, bmp, dstColorSpace);
} else {
- proxy = GrUploadPixmapToTextureProxy(context->contextPriv().proxyProvider(),
- pixmap, SkBudgeted::kYes, dstColorSpace);
+ proxy = GrUploadPixmapToTextureProxy(proxyProvider, pixmap, SkBudgeted::kYes,
+ dstColorSpace);
}
if (!proxy) {
@@ -1089,6 +1093,8 @@
if (!ctx) {
return nullptr;
}
+ GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
+
// For images where the client is passing the mip data we require that all the mip levels have
// valid data.
for (int i = 0; i < mipLevelCount; ++i) {
@@ -1096,8 +1102,8 @@
return nullptr;
}
}
- sk_sp<GrTextureProxy> proxy(GrUploadMipMapToTextureProxy(ctx, info, texels, mipLevelCount,
- colorMode));
+ sk_sp<GrTextureProxy> proxy(GrUploadMipMapToTextureProxy(proxyProvider, info,
+ texels, mipLevelCount, colorMode));
if (!proxy) {
return nullptr;
}
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
index ae4dfd6..53ebc0c 100644
--- a/src/image/SkImage_Lazy.cpp
+++ b/src/image/SkImage_Lazy.cpp
@@ -829,7 +829,7 @@
SkBitmap bitmap;
if (!proxy && this->lockAsBitmap(&bitmap, chint, format, genPixelsInfo, behavior)) {
if (willBeMipped) {
- proxy = GrGenerateMipMapsAndUploadToTextureProxy(ctx, bitmap, dstColorSpace);
+ proxy = GrGenerateMipMapsAndUploadToTextureProxy(proxyProvider, bitmap, dstColorSpace);
}
if (!proxy) {
proxy = GrUploadBitmapToTextureProxy(proxyProvider, bitmap, dstColorSpace);
diff --git a/tests/CopySurfaceTest.cpp b/tests/CopySurfaceTest.cpp
index 0d9fc86..1c31bbf 100644
--- a/tests/CopySurfaceTest.cpp
+++ b/tests/CopySurfaceTest.cpp
@@ -11,6 +11,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrSurfaceContext.h"
#include "GrSurfaceProxy.h"
@@ -74,17 +75,10 @@
dstDesc.fOrigin = dOrigin;
dstDesc.fFlags = dFlags;
- sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(
- proxyProvider,
- srcDesc, SkBudgeted::kNo,
- srcPixels.get(),
- kRowBytes));
-
- sk_sp<GrTextureProxy> dst(GrSurfaceProxy::MakeDeferred(
- proxyProvider,
- dstDesc, SkBudgeted::kNo,
- dstPixels.get(),
- kRowBytes));
+ sk_sp<GrTextureProxy> src = proxyProvider->createTextureProxy(
+ srcDesc, SkBudgeted::kNo, srcPixels.get(), kRowBytes);
+ sk_sp<GrTextureProxy> dst = proxyProvider->createTextureProxy(
+ dstDesc, SkBudgeted::kNo, dstPixels.get(), kRowBytes);
if (!src || !dst) {
ERRORF(reporter,
"Could not create surfaces for copy surface test.");
diff --git a/tests/DetermineDomainModeTest.cpp b/tests/DetermineDomainModeTest.cpp
index 5848ca8..7833da4 100644
--- a/tests/DetermineDomainModeTest.cpp
+++ b/tests/DetermineDomainModeTest.cpp
@@ -10,6 +10,7 @@
#if SK_SUPPORT_GPU
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTextureProducer.h"
#include "GrTextureProxy.h"
@@ -133,7 +134,7 @@
(isPowerOfTwo || isExact) ? RectInfo::kHard : RectInfo::kBad,
name);
- return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, fit, SkBudgeted::kYes);
+ return proxyProvider->createProxy(desc, fit, SkBudgeted::kYes);
}
static RectInfo::EdgeType compute_inset_edgetype(RectInfo::EdgeType previous,
diff --git a/tests/FloatingPointTextureTest.cpp b/tests/FloatingPointTextureTest.cpp
index 95c27f2..fe347d2 100644
--- a/tests/FloatingPointTextureTest.cpp
+++ b/tests/FloatingPointTextureTest.cpp
@@ -18,7 +18,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
-#include "GrResourceProvider.h"
+#include "GrProxyProvider.h"
#include "GrTextureProxy.h"
#include "SkHalf.h"
@@ -52,9 +52,9 @@
desc.fWidth = DEV_W;
desc.fHeight = DEV_H;
desc.fConfig = config;
- sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kNo,
- controlPixelData.begin(), 0);
+
+ sk_sp<GrTextureProxy> fpProxy = proxyProvider->createTextureProxy(
+ desc, SkBudgeted::kNo, controlPixelData.begin(), 0);
// Floating point textures are NOT supported everywhere
if (!fpProxy) {
continue;
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 202e085..cf92095 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -266,19 +266,24 @@
sk_sp<GrTextureProxy> proxies[2];
// setup dummy textures
- GrSurfaceDesc dummyDesc;
- dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
- dummyDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
- dummyDesc.fWidth = 34;
- dummyDesc.fHeight = 18;
- dummyDesc.fConfig = kRGBA_8888_GrPixelConfig;
- proxies[0] = GrSurfaceProxy::MakeDeferred(proxyProvider, dummyDesc, SkBudgeted::kNo, nullptr, 0);
- dummyDesc.fFlags = kNone_GrSurfaceFlags;
- dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
- dummyDesc.fWidth = 16;
- dummyDesc.fHeight = 22;
- dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
- proxies[1] = GrSurfaceProxy::MakeDeferred(proxyProvider, dummyDesc, SkBudgeted::kNo, nullptr, 0);
+ {
+ GrSurfaceDesc dummyDesc;
+ dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
+ dummyDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
+ dummyDesc.fWidth = 34;
+ dummyDesc.fHeight = 18;
+ dummyDesc.fConfig = kRGBA_8888_GrPixelConfig;
+ proxies[0] = proxyProvider->createProxy(dummyDesc, SkBackingFit::kExact, SkBudgeted::kNo);
+ }
+ {
+ GrSurfaceDesc dummyDesc;
+ dummyDesc.fFlags = kNone_GrSurfaceFlags;
+ dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
+ dummyDesc.fWidth = 16;
+ dummyDesc.fHeight = 22;
+ dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
+ proxies[1] = proxyProvider->createProxy(dummyDesc, SkBackingFit::kExact, SkBudgeted::kNo);
+ }
if (!proxies[0] || !proxies[1]) {
SkDebugf("Could not allocate dummy textures");
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index 137d2aa..6c1f209 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -13,6 +13,7 @@
#include "GrContextOptions.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
+#include "GrProxyProvider.h"
#include "GrTest.h"
#include "GrXferProcessor.h"
#include "effects/GrPorterDuffXferProcessor.h"
@@ -1060,6 +1061,7 @@
return;
}
+ GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
const GrCaps& caps = *ctx->caps();
if (caps.shaderCaps()->dualSourceBlendingSupport()) {
SK_ABORT("Null context failed to honor request for no ARB_blend_func_extended.");
@@ -1072,8 +1074,8 @@
GrXferProcessor::DstProxy fakeDstProxy;
{
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrappedBackend(ctx, backendTex,
- kTopLeft_GrSurfaceOrigin);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createWrappedTextureProxy(
+ backendTex, kTopLeft_GrSurfaceOrigin);
fakeDstProxy.setProxy(std::move(proxy));
}
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index ecfd9f2..582510c 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -12,6 +12,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
+#include "GrProxyProvider.h"
#include "GrRenderTarget.h"
#include "GrResourceProvider.h"
#include "GrTest.h"
@@ -126,10 +127,10 @@
texels[i].fPixels = pixelData.get();
texels[i].fRowBytes = rowBytes >> i;
}
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferredMipMap(proxyProvider,
- desc, SkBudgeted::kNo,
- texels.get(),
- levelCount);
+
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createMipMapProxy(
+ desc, SkBudgeted::kNo,
+ texels.get(), levelCount);
REPORTER_ASSERT(reporter, SkToBool(proxy.get()) ==
(caps->isConfigTexturable(desc.fConfig) &&
caps->mipMapSupport() &&
@@ -155,7 +156,10 @@
GrSurfaceDesc desc;
desc.fWidth = desc.fHeight = kSize;
std::unique_ptr<uint32_t[]> data(new uint32_t[kSize * kSize]);
+
GrContext* context = context_info.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
+
for (int c = 0; c <= kLast_GrPixelConfig; ++c) {
desc.fConfig = static_cast<GrPixelConfig>(c);
if (!context_info.grContext()->caps()->isConfigTexturable(desc.fConfig)) {
@@ -170,22 +174,16 @@
for (GrSurfaceOrigin origin :
{kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
desc.fOrigin = origin;
- for (bool approx : {false, true}) {
- auto resourceProvider = context->resourceProvider();
+ for (auto fit : { SkBackingFit::kApprox, SkBackingFit::kExact }) {
// Try directly creating the texture.
// Do this twice in an attempt to hit the cache on the second time through.
for (int i = 0; i < 2; ++i) {
- sk_sp<GrTexture> tex;
- if (approx) {
- tex = sk_sp<GrTexture>(
- resourceProvider->createApproxTexture(desc, 0));
- } else {
- tex = resourceProvider->createTexture(desc, SkBudgeted::kYes);
- }
- if (!tex) {
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createInstantiatedProxy(
+ desc, fit, SkBudgeted::kYes);
+ if (!proxy) {
continue;
}
- auto proxy = GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
+
auto texCtx = context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr);
SkImageInfo info = SkImageInfo::Make(
@@ -212,9 +210,7 @@
// Try creating the texture as a deferred proxy.
for (int i = 0; i < 2; ++i) {
auto surfCtx = context->contextPriv().makeDeferredSurfaceContext(
- desc, GrMipMapped::kNo,
- approx ? SkBackingFit::kApprox : SkBackingFit::kExact,
- SkBudgeted::kYes);
+ desc, GrMipMapped::kNo, fit, SkBudgeted::kYes);
if (!surfCtx) {
continue;
}
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index a722df0..c330808 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -180,6 +180,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxyPriv.h"
#include "GrTest.h"
@@ -196,9 +197,8 @@
desc.fHeight = kFullSize;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- return GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kYes,
- srcBM.getPixels(), srcBM.rowBytes());
+ return proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ srcBM.getPixels(), srcBM.rowBytes());
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
diff --git a/tests/IntTextureTest.cpp b/tests/IntTextureTest.cpp
index 74fbc59..2968c76 100644
--- a/tests/IntTextureTest.cpp
+++ b/tests/IntTextureTest.cpp
@@ -11,6 +11,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
@@ -68,25 +69,25 @@
levels[1].fPixels = testData.get();
levels[1].fRowBytes = (kS / 2) * sizeof(int32_t);
- sk_sp<GrTextureProxy> temp(GrSurfaceProxy::MakeDeferredMipMap(proxyProvider,
- desc, SkBudgeted::kYes,
- levels, 2));
+ sk_sp<GrTextureProxy> temp = proxyProvider->createMipMapProxy(
+ desc, SkBudgeted::kYes, levels, 2);
REPORTER_ASSERT(reporter, !temp);
}
- // Test that we can create an integer texture.
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kYes,
- testData.get(), kRowBytes);
- REPORTER_ASSERT(reporter, proxy);
- if (!proxy) {
- return;
- }
+ sk_sp<GrSurfaceContext> sContext;
+ // Test that we can create a non-mipmapped integer texture.
+ {
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ testData.get(), kRowBytes);
+ REPORTER_ASSERT(reporter, proxy);
+ if (!proxy) {
+ return;
+ }
- sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
- std::move(proxy), nullptr);
- if (!sContext) {
- return;
+ sContext = context->contextPriv().makeWrappedSurfaceContext(std::move(proxy), nullptr);
+ if (!sContext) {
+ return;
+ }
}
std::unique_ptr<int32_t[]> readData(new int32_t[kS * kS]);
diff --git a/tests/OnFlushCallbackTest.cpp b/tests/OnFlushCallbackTest.cpp
index 77ceb89..4ca7522 100644
--- a/tests/OnFlushCallbackTest.cpp
+++ b/tests/OnFlushCallbackTest.cpp
@@ -14,6 +14,7 @@
#include "GrContextPriv.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrOnFlushResourceProvider.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContextPriv.h"
#include "GrResourceProvider.h"
#include "GrQuad.h"
@@ -474,17 +475,16 @@
}
#else
// TODO: this is unfortunate and must be removed. We want the atlas to be created later.
-sk_sp<GrTextureProxy> pre_create_atlas(GrContext* context) {
+sk_sp<GrTextureProxy> pre_create_atlas(GrProxyProvider* proxyProvider) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fWidth = 32;
desc.fHeight = 16;
desc.fConfig = kSkia8888_GrPixelConfig;
- return GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
- desc, SkBackingFit::kExact,
- SkBudgeted::kYes,
- GrResourceProvider::kNoPendingIO_Flag);
+
+ return proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes,
+ GrResourceProvider::kNoPendingIO_Flag);
}
#endif
@@ -520,7 +520,7 @@
// For now (until we add a GrSuperDeferredSimpleTextureEffect), we create the final atlas
// proxy ahead of time.
- sk_sp<GrTextureProxy> atlasDest = pre_create_atlas(context);
+ sk_sp<GrTextureProxy> atlasDest = pre_create_atlas(context->contextPriv().proxyProvider());
object.setAtlasDest(atlasDest);
diff --git a/tests/PackedConfigsTextureTest.cpp b/tests/PackedConfigsTextureTest.cpp
index 1f51d65..56950ec 100644
--- a/tests/PackedConfigsTextureTest.cpp
+++ b/tests/PackedConfigsTextureTest.cpp
@@ -16,7 +16,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
-#include "GrResourceProvider.h"
+#include "GrProxyProvider.h"
#include "GrTextureProxy.h"
static const int DEV_W = 10, DEV_H = 10;
@@ -120,9 +120,8 @@
desc.fConfig = config;
desc.fOrigin = origin;
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kNo,
- controlPixelData.begin(), 0);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
+ desc, SkBudgeted::kNo, controlPixelData.begin(), 0);
SkASSERT(proxy);
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index d6d3635..e675335 100644
--- a/tests/ProcessorTest.cpp
+++ b/tests/ProcessorTest.cpp
@@ -14,6 +14,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpuResource.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrRenderTargetContextPriv.h"
#include "GrResourceProvider.h"
@@ -171,22 +172,14 @@
kRGBA_8888_GrPixelConfig, nullptr));
{
bool texelBufferSupport = context->caps()->shaderCaps()->texelBufferSupport();
- sk_sp<GrTextureProxy> proxy1(
- GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBackingFit::kExact,
- SkBudgeted::kYes));
- sk_sp<GrTextureProxy> proxy2
- (GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBackingFit::kExact,
- SkBudgeted::kYes));
- sk_sp<GrTextureProxy> proxy3(
- GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBackingFit::kExact,
- SkBudgeted::kYes));
- sk_sp<GrTextureProxy> proxy4(
- GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBackingFit::kExact,
- SkBudgeted::kYes));
+ sk_sp<GrTextureProxy> proxy1 =
+ proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
+ sk_sp<GrTextureProxy> proxy2 =
+ proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
+ sk_sp<GrTextureProxy> proxy3 =
+ proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
+ sk_sp<GrTextureProxy> proxy4 =
+ proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
sk_sp<GrBuffer> buffer(texelBufferSupport
? context->resourceProvider()->createBuffer(
1024, GrBufferType::kTexel_GrBufferType,
@@ -296,9 +289,8 @@
}
/** Initializes the two test texture proxies that are available to the FP test factories. */
-bool init_test_textures(GrContext* context, SkRandom* random, sk_sp<GrTextureProxy> proxies[2]) {
- GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
-
+bool init_test_textures(GrProxyProvider* proxyProvider, SkRandom* random,
+ sk_sp<GrTextureProxy> proxies[2]) {
static const int kTestTextureSize = 256;
GrSurfaceDesc desc;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
@@ -306,36 +298,41 @@
desc.fHeight = kTestTextureSize;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- // Put premul data into the RGBA texture that the test FPs can optionally use.
- std::unique_ptr<GrColor[]> rgbaData(new GrColor[kTestTextureSize * kTestTextureSize]);
- for (int y = 0; y < kTestTextureSize; ++y) {
- for (int x = 0; x < kTestTextureSize; ++x) {
- rgbaData[kTestTextureSize * y + x] =
- input_texel_color(random->nextULessThan(256), random->nextULessThan(256));
+ {
+ // Put premul data into the RGBA texture that the test FPs can optionally use.
+ std::unique_ptr<GrColor[]> rgbaData(new GrColor[kTestTextureSize * kTestTextureSize]);
+ for (int y = 0; y < kTestTextureSize; ++y) {
+ for (int x = 0; x < kTestTextureSize; ++x) {
+ rgbaData[kTestTextureSize * y + x] =
+ input_texel_color(random->nextULessThan(256), random->nextULessThan(256));
+ }
}
- }
- proxies[0] = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes,
- rgbaData.get(), kTestTextureSize * sizeof(GrColor));
- // Put random values into the alpha texture that the test FPs can optionally use.
- desc.fConfig = kAlpha_8_GrPixelConfig;
- std::unique_ptr<uint8_t[]> alphaData(new uint8_t[kTestTextureSize * kTestTextureSize]);
- for (int y = 0; y < kTestTextureSize; ++y) {
- for (int x = 0; x < kTestTextureSize; ++x) {
- alphaData[kTestTextureSize * y + x] = random->nextULessThan(256);
- }
+ proxies[0] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ rgbaData.get(),
+ kTestTextureSize * sizeof(GrColor));
}
- proxies[1] = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes,
- alphaData.get(), kTestTextureSize);
+
+ {
+ // Put random values into the alpha texture that the test FPs can optionally use.
+ desc.fConfig = kAlpha_8_GrPixelConfig;
+ std::unique_ptr<uint8_t[]> alphaData(new uint8_t[kTestTextureSize * kTestTextureSize]);
+ for (int y = 0; y < kTestTextureSize; ++y) {
+ for (int x = 0; x < kTestTextureSize; ++x) {
+ alphaData[kTestTextureSize * y + x] = random->nextULessThan(256);
+ }
+ }
+
+ proxies[1] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ alphaData.get(), kTestTextureSize);
+ }
return proxies[0] && proxies[1];
}
// Creates a texture of premul colors used as the output of the fragment processor that precedes
// the fragment processor under test. Color values are those provided by input_texel_color().
-sk_sp<GrTextureProxy> make_input_texture(GrContext* context, int width, int height) {
- GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
-
+sk_sp<GrTextureProxy> make_input_texture(GrProxyProvider* proxyProvider, int width, int height) {
std::unique_ptr<GrColor[]> data(new GrColor[width * height]);
for (int y = 0; y < width; ++y) {
for (int x = 0; x < height; ++x) {
@@ -347,11 +344,14 @@
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes,
- data.get(), width * sizeof(GrColor));
+
+ return proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
+ data.get(), width * sizeof(GrColor));
}
+
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
using FPFactory = GrFragmentProcessorTestFactory;
uint32_t seed = 0;
@@ -369,13 +369,13 @@
SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig, nullptr);
sk_sp<GrTextureProxy> proxies[2];
- if (!init_test_textures(context, &random, proxies)) {
+ if (!init_test_textures(proxyProvider, &random, proxies)) {
ERRORF(reporter, "Could not create test textures");
return;
}
GrProcessorTestData testData(&random, context, rtc.get(), proxies);
- auto inputTexture = make_input_texture(context, kRenderSize, kRenderSize);
+ auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize);
std::unique_ptr<GrColor[]> readData(new GrColor[kRenderSize * kRenderSize]);
// Because processor factories configure themselves in random ways, this is not exhaustive.
@@ -489,6 +489,7 @@
// progenitors.
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorCloneTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkRandom random;
@@ -498,13 +499,13 @@
SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig, nullptr);
sk_sp<GrTextureProxy> proxies[2];
- if (!init_test_textures(context, &random, proxies)) {
+ if (!init_test_textures(proxyProvider, &random, proxies)) {
ERRORF(reporter, "Could not create test textures");
return;
}
GrProcessorTestData testData(&random, context, rtc.get(), proxies);
- auto inputTexture = make_input_texture(context, kRenderSize, kRenderSize);
+ auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize);
std::unique_ptr<GrColor[]> readData1(new GrColor[kRenderSize * kRenderSize]);
std::unique_ptr<GrColor[]> readData2(new GrColor[kRenderSize * kRenderSize]);
auto readInfo = SkImageInfo::Make(kRenderSize, kRenderSize, kRGBA_8888_SkColorType,
diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp
index fda71d7..98ceca7 100644
--- a/tests/ProxyConversionTest.cpp
+++ b/tests/ProxyConversionTest.cpp
@@ -12,14 +12,14 @@
#if SK_SUPPORT_GPU
#include "GrBackendSurface.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTarget.h"
#include "GrRenderTargetProxy.h"
-#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTexture.h"
#include "GrTextureProxy.h"
-static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrResourceProvider* provider,
+static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrProxyProvider* provider,
skiatest::Reporter* reporter,
const GrSurfaceDesc& desc) {
GrGLFramebufferInfo fboInfo;
@@ -27,35 +27,25 @@
GrBackendRenderTarget backendRT(desc.fWidth, desc.fHeight, desc.fSampleCnt, 8,
desc.fConfig, fboInfo);
- sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendRT));
- SkASSERT(!defaultFBO->asTexture());
-
- return GrSurfaceProxy::MakeWrapped(std::move(defaultFBO), desc.fOrigin);
+ return provider->createWrappedRenderTargetProxy(backendRT, desc.fOrigin);
}
-static sk_sp<GrSurfaceProxy> make_wrapped_offscreen_rt(GrResourceProvider* provider,
- skiatest::Reporter* reporter,
- const GrSurfaceDesc& desc,
- SkBudgeted budgeted) {
+static sk_sp<GrSurfaceProxy> make_wrapped_offscreen_rt(GrProxyProvider* provider,
+ const GrSurfaceDesc& desc) {
SkASSERT(kRenderTarget_GrSurfaceFlag == desc.fFlags);
- sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
-
- return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
+ return provider->createInstantiatedProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
}
-static sk_sp<GrSurfaceProxy> make_wrapped_texture(GrResourceProvider* provider,
- const GrSurfaceDesc& desc,
- SkBudgeted budgeted) {
- sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
-
- return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
+static sk_sp<GrSurfaceProxy> make_wrapped_texture(GrProxyProvider* provider,
+ const GrSurfaceDesc& desc) {
+ return provider->createInstantiatedProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
}
// Test converting between RenderTargetProxies and TextureProxies for wrapped
// Proxies
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo) {
- GrResourceProvider* provider = ctxInfo.grContext()->resourceProvider();
+ GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
@@ -66,7 +56,7 @@
if (kOpenGL_GrBackend == ctxInfo.backend()) {
// External on-screen render target.
- sk_sp<GrSurfaceProxy> sProxy(make_wrapped_FBO0(provider, reporter, desc));
+ sk_sp<GrSurfaceProxy> sProxy(make_wrapped_FBO0(proxyProvider, reporter, desc));
// RenderTarget-only
GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy();
@@ -77,9 +67,7 @@
{
// Internal offscreen render target.
- sk_sp<GrSurfaceProxy> sProxy(make_wrapped_offscreen_rt(provider,
- reporter, desc,
- SkBudgeted::kYes));
+ sk_sp<GrSurfaceProxy> sProxy(make_wrapped_offscreen_rt(proxyProvider, desc));
// Both RenderTarget and Texture
GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy();
@@ -92,7 +80,7 @@
{
// Internal offscreen render target - but through GrTextureProxy
- sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(provider, desc, SkBudgeted::kYes));
+ sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(proxyProvider, desc));
// Both RenderTarget and Texture
GrTextureProxy* tProxy = sProxy->asTextureProxy();
@@ -106,7 +94,7 @@
{
desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
- sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(provider, desc, SkBudgeted::kYes));
+ sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(proxyProvider, desc));
// Texture-only
GrTextureProxy* tProxy = sProxy->asTextureProxy();
@@ -129,9 +117,8 @@
desc.fConfig = kRGBA_8888_GrPixelConfig;
{
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
- SkBackingFit::kApprox,
- SkBudgeted::kYes));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
+ SkBudgeted::kYes);
// Both RenderTarget and Texture
GrRenderTargetProxy* rtProxy = proxy->asRenderTargetProxy();
@@ -143,9 +130,8 @@
}
{
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
- SkBackingFit::kApprox,
- SkBudgeted::kYes));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
+ SkBudgeted::kYes);
// Both RenderTarget and Texture - but via GrTextureProxy
GrTextureProxy* tProxy = proxy->asTextureProxy();
@@ -160,10 +146,8 @@
desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
- SkBackingFit::kApprox,
- SkBudgeted::kYes));
-
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
+ SkBudgeted::kYes);
// Texture-only
GrTextureProxy* tProxy = proxy->asTextureProxy();
REPORTER_ASSERT(reporter, tProxy);
diff --git a/tests/ProxyRefTest.cpp b/tests/ProxyRefTest.cpp
index 5bf3a57..acd17be 100644
--- a/tests/ProxyRefTest.cpp
+++ b/tests/ProxyRefTest.cpp
@@ -12,6 +12,7 @@
#if SK_SUPPORT_GPU
#include "GrContextPriv.h"
#include "GrGpuResourceRef.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
@@ -65,7 +66,7 @@
SkASSERT(proxy->getPendingWriteCnt_TestOnly() == expectedNumWrites);
}
-static sk_sp<GrTextureProxy> make_deferred(GrContext* context) {
+static sk_sp<GrTextureProxy> make_deferred(GrProxyProvider* proxyProvider) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
@@ -73,12 +74,11 @@
desc.fHeight = kWidthHeight;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- return GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(), desc,
- SkBackingFit::kApprox, SkBudgeted::kYes,
- GrResourceProvider::kNoPendingIO_Flag);
+ return proxyProvider->createProxy(desc, SkBackingFit::kApprox, SkBudgeted::kYes,
+ GrResourceProvider::kNoPendingIO_Flag);
}
-static sk_sp<GrTextureProxy> make_wrapped(GrContext* context) {
+static sk_sp<GrTextureProxy> make_wrapped(GrProxyProvider* proxyProvider) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
@@ -86,18 +86,17 @@
desc.fHeight = kWidthHeight;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- sk_sp<GrTexture> tex(context->resourceProvider()->createTexture(desc, SkBudgeted::kNo));
-
- return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
+ return proxyProvider->createInstantiatedProxy(desc, SkBackingFit::kExact, SkBudgeted::kNo);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
- GrResourceProvider* provider = ctxInfo.grContext()->resourceProvider();
+ GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
+ GrResourceProvider* resourceProvider = ctxInfo.grContext()->resourceProvider();
for (auto make : { make_deferred, make_wrapped }) {
// A single write
{
- sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
+ sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
GrPendingIOResource<GrSurfaceProxy, kWrite_GrIOType> fWrite(proxy.get());
@@ -106,7 +105,7 @@
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
- proxy->instantiate(provider);
+ proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transfered to the GrSurface
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
@@ -115,7 +114,7 @@
// A single read
{
- sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
+ sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
GrPendingIOResource<GrSurfaceProxy, kRead_GrIOType> fRead(proxy.get());
@@ -124,7 +123,7 @@
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
- proxy->instantiate(provider);
+ proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transfered to the GrSurface
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
@@ -133,7 +132,7 @@
// A single read/write pair
{
- sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
+ sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
GrPendingIOResource<GrSurfaceProxy, kRW_GrIOType> fRW(proxy.get());
@@ -142,7 +141,7 @@
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
- proxy->instantiate(provider);
+ proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transferred to the GrSurface
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
@@ -151,7 +150,7 @@
// Multiple normal refs
{
- sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
+ sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
proxy->ref();
proxy->ref();
@@ -161,7 +160,7 @@
check_refs(reporter, proxy.get(), 3, 3,kExpectedReads, kExpectedWrites);
- proxy->instantiate(provider);
+ proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transferred to the GrSurface
check_refs(reporter, proxy.get(), 3, 3, kExpectedReads, kExpectedWrites);
@@ -173,7 +172,7 @@
// Continue using (reffing) proxy after instantiation
{
- sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
+ sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
proxy->ref();
@@ -183,7 +182,7 @@
check_refs(reporter, proxy.get(), 2, 2, 0, kExpectedWrites);
- proxy->instantiate(provider);
+ proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transfered to the GrSurface
check_refs(reporter, proxy.get(), 2, 2, 0, kExpectedWrites);
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index 01c881c..077045f 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -13,6 +13,7 @@
#include "GrBackendSurface.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetPriv.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
@@ -26,17 +27,12 @@
GrSurfaceOrigin origin,
int width, int height,
GrPixelConfig config,
- const GrGpuResource::UniqueID& uniqueID,
SkBudgeted budgeted) {
REPORTER_ASSERT(reporter, proxy->origin() == origin);
REPORTER_ASSERT(reporter, proxy->width() == width);
REPORTER_ASSERT(reporter, proxy->height() == height);
REPORTER_ASSERT(reporter, proxy->config() == config);
- if (!uniqueID.isInvalid()) {
- REPORTER_ASSERT(reporter, proxy->uniqueID().asUInt() == uniqueID.asUInt());
- } else {
- REPORTER_ASSERT(reporter, !proxy->uniqueID().isInvalid());
- }
+ REPORTER_ASSERT(reporter, !proxy->uniqueID().isInvalid());
REPORTER_ASSERT(reporter, proxy->isBudgeted() == budgeted);
}
@@ -114,8 +110,6 @@
GrResourceProvider* resourceProvider = ctxInfo.grContext()->resourceProvider();
const GrCaps& caps = *ctxInfo.grContext()->caps();
- const GrGpuResource::UniqueID kInvalidResourceID = GrGpuResource::UniqueID::InvalidID();
-
int attempt = 0; // useful for debugging
for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
@@ -141,9 +135,8 @@
tex = resourceProvider->createTexture(desc, budgeted);
}
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
- proxyProvider, desc,
- fit, budgeted));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
+ desc, fit, budgeted);
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
@@ -155,8 +148,7 @@
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), origin,
- widthHeight, widthHeight, config,
- kInvalidResourceID, budgeted);
+ widthHeight, widthHeight, config, budgeted);
int supportedSamples = caps.getSampleCount(numSamples, config);
check_rendertarget(reporter, caps, resourceProvider,
proxy->asRenderTargetProxy(),
@@ -175,11 +167,8 @@
tex = resourceProvider->createTexture(desc, budgeted);
}
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
- proxyProvider,
- desc,
- fit,
- budgeted));
+ sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
+ desc, fit, budgeted));
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
// This forces the proxy to compute and cache its
@@ -190,8 +179,7 @@
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), origin,
- widthHeight, widthHeight, config,
- kInvalidResourceID, budgeted);
+ widthHeight, widthHeight, config, budgeted);
check_texture(reporter, resourceProvider,
proxy->asTextureProxy(), fit, false);
}
@@ -207,6 +195,7 @@
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
+ GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
GrResourceProvider* provider = ctxInfo.grContext()->resourceProvider();
const GrCaps& caps = *ctxInfo.grContext()->caps();
@@ -234,49 +223,45 @@
GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, 8,
config, fboInfo);
- sk_sp<GrRenderTarget> defaultFBO(
- provider->wrapBackendRenderTarget(backendRT));
-
- sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(defaultFBO,
- origin));
+ sk_sp<GrSurfaceProxy> sProxy(proxyProvider->createWrappedRenderTargetProxy(
+ backendRT, origin));
check_surface(reporter, sProxy.get(), origin,
- kWidthHeight, kWidthHeight, config,
- defaultFBO->uniqueID(), SkBudgeted::kNo);
+ kWidthHeight, kWidthHeight, config, SkBudgeted::kNo);
check_rendertarget(reporter, caps, provider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact, 0, true);
}
- sk_sp<GrTexture> tex;
-
- // Internal offscreen render target.
if (renderable) {
+ // Internal offscreen render target.
desc.fFlags = kRenderTarget_GrSurfaceFlag;
- tex = provider->createTexture(desc, budgeted);
- if (!tex) {
- continue; // This can fail on Mesa
- }
- sk_sp<GrRenderTarget> rt(sk_ref_sp(tex->asRenderTarget()));
- sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(rt, origin));
+ sk_sp<GrSurfaceProxy> sProxy = proxyProvider->createInstantiatedProxy(
+ desc, SkBackingFit::kExact, budgeted);
+ if (!sProxy) {
+ continue; // This can fail on Mesa
+ }
+
check_surface(reporter, sProxy.get(), origin,
- kWidthHeight, kWidthHeight, config,
- rt->uniqueID(), budgeted);
+ kWidthHeight, kWidthHeight, config, budgeted);
check_rendertarget(reporter, caps, provider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles(), true);
- }
-
- if (!tex) {
+ } else {
+ // Internal offscreen texture
SkASSERT(kNone_GrSurfaceFlags == desc.fFlags );
desc.fSampleCnt = 0;
- tex = provider->createTexture(desc, budgeted);
- }
- sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(tex, origin));
- check_surface(reporter, sProxy.get(), origin,
- kWidthHeight, kWidthHeight, config, tex->uniqueID(), budgeted);
- check_texture(reporter, provider, sProxy->asTextureProxy(),
- SkBackingFit::kExact, true);
+ sk_sp<GrSurfaceProxy> sProxy = proxyProvider->createInstantiatedProxy(
+ desc, SkBackingFit::kExact, budgeted);
+ if (!sProxy) {
+ continue;
+ }
+
+ check_surface(reporter, sProxy.get(), origin,
+ kWidthHeight, kWidthHeight, config, budgeted);
+ check_texture(reporter, provider, sProxy->asTextureProxy(),
+ SkBackingFit::kExact, true);
+ }
}
}
}
@@ -302,10 +287,7 @@
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fSampleCnt = 0;
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(provider,
- desc,
- fit,
- SkBudgeted::kNo));
+ sk_sp<GrTextureProxy> proxy = provider->createProxy(desc, fit, SkBudgeted::kNo);
REPORTER_ASSERT(reporter, !proxy);
}
}
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index ec3e464..47b4cd8 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -18,6 +18,7 @@
#include "GrContext.h"
#include "GrContextFactory.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "SkGr.h"
#endif
@@ -463,10 +464,9 @@
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fOrigin = origin;
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kNo,
- bmp.getPixels(),
- bmp.rowBytes());
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
+ bmp.getPixels(),
+ bmp.rowBytes());
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr);
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index ee3588f..00891c1 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -12,6 +12,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrSurfaceContext.h"
#include "GrSurfaceProxy.h"
@@ -60,9 +61,8 @@
// We are initializing the texture with zeros here
memset(alphaData, 0, X_SIZE * Y_SIZE);
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kNo,
- alphaData, 0));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
+ alphaData, 0);
if (!proxy) {
ERRORF(reporter, "Could not create alpha texture.");
return;
@@ -167,9 +167,9 @@
rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
}
}
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kNo,
- rgbaData, 0));
+
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
+ rgbaData, 0);
if (!proxy) {
// We always expect to be able to create a RGBA texture
if (!rt && kRGBA_8888_GrPixelConfig == desc.fConfig) {
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index f5453bd..16dc940 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -12,6 +12,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrTest.h"
#include "gl/GLTestContext.h"
@@ -85,6 +86,7 @@
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_gpu_test::GLTestContext* glContext = ctxInfo.glContext();
static const int kWidth = 13;
static const int kHeight = 13;
@@ -125,9 +127,9 @@
}
}
- sk_sp<GrTextureProxy> rectProxy = GrSurfaceProxy::MakeWrappedBackend(context,
- rectangleTex,
- origin);
+ sk_sp<GrTextureProxy> rectProxy = proxyProvider->createWrappedTextureProxy(
+ rectangleTex, origin);
+
if (!rectProxy) {
ERRORF(reporter, "Error creating proxy for rectangle texture.");
GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
diff --git a/tests/ResourceAllocatorTest.cpp b/tests/ResourceAllocatorTest.cpp
index 8d196f6..6ca4b0c 100644
--- a/tests/ResourceAllocatorTest.cpp
+++ b/tests/ResourceAllocatorTest.cpp
@@ -14,6 +14,7 @@
#include "GrContextPriv.h"
#include "GrGpu.h"
+#include "GrProxyProvider.h"
#include "GrResourceAllocator.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxyPriv.h"
@@ -40,18 +41,18 @@
desc.fConfig = p.fConfig;
desc.fSampleCnt = p.fSampleCnt;
- return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, p.fFit, SkBudgeted::kNo);
+ return proxyProvider->createProxy(desc, p.fFit, SkBudgeted::kNo);
}
static sk_sp<GrSurfaceProxy> make_backend(GrContext* context, const ProxyParams& p,
GrBackendTexture* backendTex) {
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
+
*backendTex = context->getGpu()->createTestingOnlyBackendTexture(nullptr, p.fSize, p.fSize,
p.fConfig, false,
GrMipMapped::kNo);
- sk_sp<GrSurface> tex = context->resourceProvider()->wrapBackendTexture(*backendTex,
- kBorrow_GrWrapOwnership);
- return GrSurfaceProxy::MakeWrapped(std::move(tex), p.fOrigin);
+ return proxyProvider->createWrappedTextureProxy(*backendTex, p.fOrigin);
}
static void cleanup_backend(GrContext* context, GrBackendTexture* backendTex) {
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 27d1971..96cda79 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -16,6 +16,7 @@
#include "GrGpu.h"
#include "GrGpuResourceCacheAccess.h"
#include "GrGpuResourcePriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetPriv.h"
#include "GrResourceCache.h"
#include "GrResourceProvider.h"
@@ -1632,7 +1633,7 @@
return provider->createTexture(desc, SkBudgeted::kYes);
}
-static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* provider,
+static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* proxyProvider,
GrSurfaceFlags flags,
int width, int height,
int sampleCnt) {
@@ -1668,8 +1669,7 @@
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fSampleCnt = sampleCnt;
- return GrSurfaceProxy::MakeDeferredMipMap(provider, desc, SkBudgeted::kYes,
- texels.get(), mipLevelCount);
+ return proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes, texels.get(), mipLevelCount);
}
// Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,
diff --git a/tests/SRGBMipMapTest.cpp b/tests/SRGBMipMapTest.cpp
index b74663d..7d6f6a9 100644
--- a/tests/SRGBMipMapTest.cpp
+++ b/tests/SRGBMipMapTest.cpp
@@ -11,6 +11,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "SkCanvas.h"
#include "SkGr.h"
@@ -131,9 +132,8 @@
desc.fConfig = kSRGBA_8888_GrPixelConfig;
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- desc, SkBudgeted::kNo,
- texData, 0);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
+ desc, SkBudgeted::kNo, texData, 0);
// Create two render target contexts (L32 and S32)
sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::MakeSRGB();
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 6dfcfc4..4b86697 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -18,6 +18,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTextureProxy.h"
#include "SkGr.h"
@@ -207,6 +208,7 @@
// Test out the SkSpecialImage::makeTextureImage entry point
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkBitmap bm = create_bm();
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
@@ -235,10 +237,8 @@
// gpu
const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
- context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kNo,
- bm.getPixels(), bm.rowBytes()));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
+ desc, SkBudgeted::kNo, bm.getPixels(), bm.rowBytes());
if (!proxy) {
return;
}
@@ -265,13 +265,13 @@
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkBitmap bm = create_bm();
const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kNo,
- bm.getPixels(), bm.rowBytes()));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
+ desc, SkBudgeted::kNo, bm.getPixels(), bm.rowBytes());
if (!proxy) {
return;
}
@@ -300,6 +300,7 @@
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_DeferredGpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkBitmap bm = create_bm();
GrSurfaceDesc desc;
@@ -309,9 +310,8 @@
desc.fHeight = kFullSize;
desc.fConfig = kSkia8888_GrPixelConfig;
- sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
- desc, SkBudgeted::kNo,
- bm.getPixels(), 0));
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
+ desc, SkBudgeted::kNo, bm.getPixels(), bm.rowBytes());
if (!proxy) {
return;
}
diff --git a/tests/TestUtils.cpp b/tests/TestUtils.cpp
index 588d479..463a8e9 100644
--- a/tests/TestUtils.cpp
+++ b/tests/TestUtils.cpp
@@ -9,6 +9,7 @@
#if SK_SUPPORT_GPU
+#include "GrProxyProvider.h"
#include "GrSurfaceContext.h"
#include "GrSurfaceProxy.h"
#include "GrTextureProxy.h"
@@ -111,9 +112,9 @@
copySrcDesc.fOrigin = (kNone_GrSurfaceFlags == flags) ? kTopLeft_GrSurfaceOrigin
: kBottomLeft_GrSurfaceOrigin;
- sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(proxyProvider,
- copySrcDesc,
- SkBudgeted::kYes, pixels.get(), 0));
+ sk_sp<GrTextureProxy> src = proxyProvider->createTextureProxy(copySrcDesc, SkBudgeted::kYes,
+ pixels.get(), 0);
+
dstContext->copy(src.get());
test_read_pixels(reporter, dstContext, pixels.get(), testName);
diff --git a/tests/TextureProxyTest.cpp b/tests/TextureProxyTest.cpp
index 425fab2..82a726d 100644
--- a/tests/TextureProxyTest.cpp
+++ b/tests/TextureProxyTest.cpp
@@ -45,11 +45,10 @@
static sk_sp<GrTextureProxy> deferred_tex(skiatest::Reporter* reporter,
GrContext* context, SkBackingFit fit) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
- GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
+ const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, fit, SkBudgeted::kYes);
// Only budgeted & wrapped external proxies get to carry uniqueKeys
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, fit,
- SkBudgeted::kYes);
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
}
@@ -57,31 +56,22 @@
static sk_sp<GrTextureProxy> deferred_texRT(skiatest::Reporter* reporter,
GrContext* context, SkBackingFit fit) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
- GrSurfaceDesc desc = make_desc(kRenderTarget_GrSurfaceFlag);
+ const GrSurfaceDesc desc = make_desc(kRenderTarget_GrSurfaceFlag);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, fit, SkBudgeted::kYes);
// Only budgeted & wrapped external proxies get to carry uniqueKeys
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, fit,
- SkBudgeted::kYes);
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
}
static sk_sp<GrTextureProxy> wrapped(skiatest::Reporter* reporter,
GrContext* context, SkBackingFit fit) {
- GrResourceProvider* resourceProvider = context->resourceProvider();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
+ const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
- GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
-
- sk_sp<GrTexture> tex;
- if (SkBackingFit::kApprox == fit) {
- tex = sk_sp<GrTexture>(resourceProvider->createApproxTexture(desc, 0));
- } else {
- // Only budgeted & wrapped external proxies get to carry uniqueKeys
- tex = resourceProvider->createTexture(desc, SkBudgeted::kYes);
- }
-
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(std::move(tex),
- kBottomLeft_GrSurfaceOrigin);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createInstantiatedProxy(desc, fit,
+ SkBudgeted::kYes);
+ // Only budgeted & wrapped external proxies get to carry uniqueKeys
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
}
@@ -99,7 +89,7 @@
builder[0] = kUniqueKeyData++;
builder.finish();
- GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
+ const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
@@ -119,18 +109,19 @@
static sk_sp<GrTextureProxy> create_wrapped_backend(GrContext* context, SkBackingFit fit,
sk_sp<GrTexture>* backingSurface) {
- GrResourceProvider* provider = context->resourceProvider();
+ GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
+ GrResourceProvider* resourceProvider = context->resourceProvider();
const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
- *backingSurface = provider->createTexture(desc, SkBudgeted::kNo);
+ *backingSurface = resourceProvider->createTexture(desc, SkBudgeted::kNo);
if (!(*backingSurface)) {
return nullptr;
}
GrBackendTexture backendTex = (*backingSurface)->getBackendTexture();
- return GrSurfaceProxy::MakeWrappedBackend(context, backendTex, kBottomLeft_GrSurfaceOrigin);
+ return proxyProvider->createWrappedTextureProxy(backendTex, kBottomLeft_GrSurfaceOrigin);
}
diff --git a/tests/VkUploadPixelsTests.cpp b/tests/VkUploadPixelsTests.cpp
index d05ca77..6f79df7 100644
--- a/tests/VkUploadPixelsTests.cpp
+++ b/tests/VkUploadPixelsTests.cpp
@@ -13,6 +13,7 @@
#include "GrContextFactory.h"
#include "GrContextPriv.h"
+#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTest.h"
#include "SkGr.h"
@@ -73,9 +74,8 @@
SkColorType ct;
SkAssertResult(GrPixelConfigToColorType(config, &ct));
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
- surfDesc, SkBudgeted::kNo,
- srcBuffer, 0);
+ sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(surfDesc, SkBudgeted::kNo,
+ srcBuffer, 0);
REPORTER_ASSERT(reporter, proxy);
if (proxy) {
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
@@ -107,7 +107,7 @@
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
- proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, surfDesc, SkBudgeted::kNo, srcBuffer, 0);
+ proxy = proxyProvider->createTextureProxy(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
REPORTER_ASSERT(reporter, proxy);
if (proxy) {
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index 9a76dcf..b3da67b 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -17,6 +17,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
+#include "GrProxyProvider.h"
#include "GrTest.h"
#endif
@@ -501,9 +502,8 @@
desc.fHeight = 64;
desc.fConfig = kRGBA_8888_GrPixelConfig;
- sk_sp<GrTextureProxy> temp = GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
- SkBackingFit::kApprox,
- SkBudgeted::kYes);
+ sk_sp<GrTextureProxy> temp = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
+ SkBudgeted::kYes);
temp->instantiate(context->resourceProvider());
}