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/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());
}