AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Rm makeRenderTargetContext in favor of deferred version"

Browse Source 
This reverts commit d83ec04412.

Reason for revert: various bot failures

Original change's description:
> Rm makeRenderTargetContext in favor of deferred version
> 
> Change-Id: Ifdf67453607256ba7cdb0837263377bd83907212
> Reviewed-on: https://skia-review.googlesource.com/13001
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Robert Phillips <robertphillips@google.com>
> 

TBR=bsalomon@google.com,robertphillips@google.com,reviews@skia.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Change-Id: I4e67a20cbe658b24725dcf386ac8bfdd127647ea
Reviewed-on: https://skia-review.googlesource.com/13131
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Robert Phillips 2017-04-11 12:23:17 +00:00 committed by Skia Commit-Bot
parent d83ec04412
commit 934292170b
24 changed files with 151 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gm/windowrectangles.cpp
View File

@ -202,10 +202,10 @@ void WindowRectanglesMaskGM::visualizeAlphaMask(GrContext* ctx, GrRenderTargetCo
const int padRight = (kDeviceRect.right() - kCoverRect.right()) / 2;
const int padBottom = (kDeviceRect.bottom() - kCoverRect.bottom()) / 2;
sk_sp<GrRenderTargetContext> maskRTC(
ctx->makeDeferredRenderTargetContextWithFallback(SkBackingFit::kExact,
kCoverRect.width() + padRight,
kCoverRect.height() + padBottom,
kAlpha_8_GrPixelConfig, nullptr));
ctx->makeRenderTargetContextWithFallback(SkBackingFit::kExact,
kCoverRect.width() + padRight,
kCoverRect.height() + padBottom,
kAlpha_8_GrPixelConfig, nullptr));
if (!maskRTC ||
!ctx->resourceProvider()->attachStencilAttachment(maskRTC->accessRenderTarget())) {
return;

34
include/gpu/GrContext.h
View File

@ -183,12 +183,12 @@ public:
*/
int getRecommendedSampleCount(GrPixelConfig config, SkScalar dpi) const;
/*
* Create a new render target context backed by a deferred-style
* GrRenderTargetProxy. We guarantee that "asTextureProxy" will succeed for
* renderTargetContexts created via this entry point.
/**
* Create both a GrRenderTarget and a matching GrRenderTargetContext to wrap it.
* We guarantee that "asTexture" will succeed for renderTargetContexts created
* via this entry point.
*/
sk_sp<GrRenderTargetContext> makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> makeRenderTargetContext(
SkBackingFit fit,
int width, int height,
GrPixelConfig config,
@ -197,12 +197,36 @@ public:
GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin,
const SkSurfaceProps* surfaceProps = nullptr,
SkBudgeted = SkBudgeted::kYes);
// Create a new render target context as above but have it backed by a deferred-style
// GrRenderTargetProxy rather than one that is backed by an actual GrRenderTarget
sk_sp<GrRenderTargetContext> makeDeferredRenderTargetContext(
SkBackingFit fit,
int width, int height,
GrPixelConfig config,
sk_sp<SkColorSpace> colorSpace,
int sampleCnt = 0,
GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin,
const SkSurfaceProps* surfaceProps = nullptr,
SkBudgeted = SkBudgeted::kYes);
/*
* This method will attempt to create a renderTargetContext that has, at least, the number of
* channels and precision per channel as requested in 'config' (e.g., A8 and 888 can be
* converted to 8888). It may also swizzle the channels (e.g., BGRA -> RGBA).
* SRGB-ness will be preserved.
*/
sk_sp<GrRenderTargetContext> makeRenderTargetContextWithFallback(
SkBackingFit fit,
int width, int height,
GrPixelConfig config,
sk_sp<SkColorSpace> colorSpace,
int sampleCnt = 0,
GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin,
const SkSurfaceProps* surfaceProps = nullptr,
SkBudgeted budgeted = SkBudgeted::kYes);
// Create a new render target context as above but have it backed by a deferred-style
// GrRenderTargetProxy rather than one that is backed by an actual GrRenderTarget
sk_sp<GrRenderTargetContext> makeDeferredRenderTargetContextWithFallback(
SkBackingFit fit,
int width, int height,

2
src/core/SkSpecialSurface.cpp
View File

@ -164,7 +164,7 @@ sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRenderTarget(GrContext* context,
return nullptr;
}
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
SkBackingFit::kApprox, width, height, config, std::move(colorSpace)));
if (!renderTargetContext) {
return nullptr;

2
src/gpu/GrClipStackClip.cpp
View File

@ -392,7 +392,7 @@ sk_sp<GrTextureProxy> GrClipStackClip::createAlphaClipMask(GrContext* context,
return proxy;
}
sk_sp<GrRenderTargetContext> rtc(context->makeDeferredRenderTargetContextWithFallback(
sk_sp<GrRenderTargetContext> rtc(context->makeRenderTargetContextWithFallback(
SkBackingFit::kApprox,
reducedClip.width(),
reducedClip.height(),

61
src/gpu/GrContext.cpp
View File

@ -489,7 +489,7 @@ bool GrContextPriv::readSurfacePixels(GrSurfaceProxy* srcProxy, SkColorSpace* sr
// TODO: Need to decide the semantics of this function for color spaces. Do we support
// conversion to a passed-in color space? For now, specifying nullptr means that this
// path will do no conversion, so it will match the behavior of the non-draw path.
sk_sp<GrRenderTargetContext> tempRTC = fContext->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> tempRTC = fContext->makeRenderTargetContext(
tempDrawInfo.fTempSurfaceFit,
tempDrawInfo.fTempSurfaceDesc.fWidth,
tempDrawInfo.fTempSurfaceDesc.fHeight,
@ -776,6 +776,23 @@ static inline GrPixelConfig GrPixelConfigFallback(GrPixelConfig config) {
}
}
sk_sp<GrRenderTargetContext> GrContext::makeRenderTargetContextWithFallback(
SkBackingFit fit,
int width, int height,
GrPixelConfig config,
sk_sp<SkColorSpace> colorSpace,
int sampleCnt,
GrSurfaceOrigin origin,
const SkSurfaceProps* surfaceProps,
SkBudgeted budgeted) {
if (!this->caps()->isConfigRenderable(config, sampleCnt > 0)) {
config = GrPixelConfigFallback(config);
}
return this->makeRenderTargetContext(fit, width, height, config, std::move(colorSpace),
sampleCnt, origin, surfaceProps, budgeted);
}
sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContextWithFallback(
SkBackingFit fit,
int width, int height,
@ -793,6 +810,46 @@ sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContextWithFallb
sampleCnt, origin, surfaceProps, budgeted);
}
sk_sp<GrRenderTargetContext> GrContext::makeRenderTargetContext(SkBackingFit fit,
int width, int height,
GrPixelConfig config,
sk_sp<SkColorSpace> colorSpace,
int sampleCnt,
GrSurfaceOrigin origin,
const SkSurfaceProps* surfaceProps,
SkBudgeted budgeted) {
if (!this->caps()->isConfigRenderable(config, sampleCnt > 0)) {
return nullptr;
}
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = origin;
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = config;
desc.fSampleCnt = sampleCnt;
sk_sp<GrTexture> tex;
if (SkBackingFit::kExact == fit) {
tex = this->resourceProvider()->createTexture(desc, budgeted);
} else {
tex.reset(this->resourceProvider()->createApproxTexture(desc, 0));
}
if (!tex) {
return nullptr;
}
sk_sp<GrRenderTargetContext> renderTargetContext(
this->contextPriv().makeWrappedRenderTargetContext(sk_ref_sp(tex->asRenderTarget()),
std::move(colorSpace), surfaceProps));
if (!renderTargetContext) {
return nullptr;
}
return renderTargetContext;
}
sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContext(
SkBackingFit fit,
int width, int height,
@ -802,8 +859,6 @@ sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContext(
GrSurfaceOrigin origin,
const SkSurfaceProps* surfaceProps,
SkBudgeted budgeted) {
SkASSERT(kDefault_GrSurfaceOrigin != origin);
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = origin;

2
src/gpu/GrTextureProducer.cpp
View File

@ -27,7 +27,7 @@ sk_sp<GrTextureProxy> GrTextureProducer::CopyOnGpu(GrContext* context,
const SkRect dstRect = SkRect::MakeIWH(copyParams.fWidth, copyParams.fHeight);
sk_sp<GrRenderTargetContext> copyRTC = context->makeDeferredRenderTargetContextWithFallback(
sk_sp<GrRenderTargetContext> copyRTC = context->makeRenderTargetContextWithFallback(
SkBackingFit::kExact, dstRect.width(), dstRect.height(), config, nullptr);
if (!copyRTC) {
return nullptr;

10
src/gpu/GrTextureToYUVPlanes.cpp
View File

@ -73,7 +73,7 @@ bool GrTextureToYUVPlanes(GrContext* context, sk_sp<GrTextureProxy> proxy,
// sizes however we optimize for two other cases - all planes are the same (1 draw to YUV),
// and U and V are the same but Y differs (2 draws, one for Y, one for UV).
if (sizes[0] == sizes[1] && sizes[1] == sizes[2]) {
yuvRenderTargetContext = context->makeDeferredRenderTargetContextWithFallback(
yuvRenderTargetContext = context->makeRenderTargetContextWithFallback(
SkBackingFit::kApprox,
sizes[0].fWidth,
sizes[0].fHeight,
@ -83,7 +83,7 @@ bool GrTextureToYUVPlanes(GrContext* context, sk_sp<GrTextureProxy> proxy,
return false;
}
} else {
yRenderTargetContext = context->makeDeferredRenderTargetContextWithFallback(
yRenderTargetContext = context->makeRenderTargetContextWithFallback(
SkBackingFit::kApprox,
sizes[0].fWidth,
sizes[0].fHeight,
@ -94,7 +94,7 @@ bool GrTextureToYUVPlanes(GrContext* context, sk_sp<GrTextureProxy> proxy,
}
if (sizes[1] == sizes[2]) {
// TODO: Add support for GL_RG when available.
uvRenderTargetContext = context->makeDeferredRenderTargetContextWithFallback(
uvRenderTargetContext = context->makeRenderTargetContextWithFallback(
SkBackingFit::kApprox,
sizes[1].fWidth,
sizes[1].fHeight,
@ -104,13 +104,13 @@ bool GrTextureToYUVPlanes(GrContext* context, sk_sp<GrTextureProxy> proxy,
return false;
}
} else {
uRenderTargetContext = context->makeDeferredRenderTargetContextWithFallback(
uRenderTargetContext = context->makeRenderTargetContextWithFallback(
SkBackingFit::kApprox,
sizes[1].fWidth,
sizes[1].fHeight,
kAlpha_8_GrPixelConfig,
nullptr);
vRenderTargetContext = context->makeDeferredRenderTargetContextWithFallback(
vRenderTargetContext = context->makeRenderTargetContextWithFallback(
SkBackingFit::kApprox,
sizes[2].fWidth,
sizes[2].fHeight,

2
src/gpu/GrYUVProvider.cpp
View File

@ -121,7 +121,7 @@ sk_sp<GrTextureProxy> GrYUVProvider::refAsTextureProxy(GrContext* ctx,
}
// We never want to perform color-space conversion during the decode
sk_sp<GrRenderTargetContext> renderTargetContext(ctx->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(ctx->makeRenderTargetContext(
SkBackingFit::kExact,
desc.fWidth, desc.fHeight,
desc.fConfig, nullptr,

14
src/gpu/SkGpuDevice.cpp
View File

@ -168,8 +168,7 @@ sk_sp<GrRenderTargetContext> SkGpuDevice::MakeRenderTargetContext(
GrPixelConfig config = SkImageInfo2GrPixelConfig(origInfo, *context->caps());
// This method is used to create SkGpuDevice's for SkSurface_Gpus. In this case
// they need to be exact.
return context->makeDeferredRenderTargetContext(
SkBackingFit::kExact,
return context->makeRenderTargetContext(SkBackingFit::kExact,
origInfo.width(), origInfo.height(),
config, origInfo.refColorSpace(), sampleCount,
origin, surfaceProps, budgeted);
@ -1336,6 +1335,7 @@ sk_sp<SkSpecialImage> SkGpuDevice::snapSpecial() {
const SkImageInfo ii = this->imageInfo();
const SkIRect srcRect = SkIRect::MakeWH(ii.width(), ii.height());
SkASSERT(proxy->priv().isExact());
return SkSpecialImage::MakeDeferredFromGpu(fContext.get(),
srcRect,
kNeedNewImageUniqueID_SpecialImage,
@ -1766,13 +1766,13 @@ SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint
SkBackingFit fit = kNever_TileUsage == cinfo.fTileUsage ? SkBackingFit::kApprox
: SkBackingFit::kExact;
sk_sp<GrRenderTargetContext> rtc(fContext->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> rtc(fContext->makeRenderTargetContext(
fit,
cinfo.fInfo.width(), cinfo.fInfo.height(),
fRenderTargetContext->config(),
fRenderTargetContext->refColorSpace(),
fRenderTargetContext->desc().fSampleCnt,
kBottomLeft_GrSurfaceOrigin,
fRenderTargetContext->config(),
fRenderTargetContext->refColorSpace(),
fRenderTargetContext->desc().fSampleCnt,
kDefault_GrSurfaceOrigin,
&props));
if (!rtc) {
return nullptr;

6
src/gpu/effects/GrConfigConversionEffect.cpp
View File

@ -147,12 +147,10 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context
const SkImageInfo ii = SkImageInfo::Make(kSize, kSize,
kRGBA_8888_SkColorType, kPremul_SkAlphaType);
sk_sp<GrRenderTargetContext> readRTC(context->makeDeferredRenderTargetContext(
SkBackingFit::kExact,
sk_sp<GrRenderTargetContext> readRTC(context->makeRenderTargetContext(SkBackingFit::kExact,
kSize, kSize,
kConfig, nullptr));
sk_sp<GrRenderTargetContext> tempRTC(context->makeDeferredRenderTargetContext(
SkBackingFit::kExact,
sk_sp<GrRenderTargetContext> tempRTC(context->makeRenderTargetContext(SkBackingFit::kExact,
kSize, kSize,
kConfig, nullptr));
if (!readRTC || !tempRTC) {

2
src/gpu/text/GrAtlasTextContext.cpp
View File

@ -352,7 +352,7 @@ DRAW_OP_TEST_DEFINE(TextBlobOp) {
}
// Setup dummy SkPaint / GrPaint / GrRenderTargetContext
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
SkBackingFit::kApprox, 1024, 1024, kRGBA_8888_GrPixelConfig, nullptr));
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);

4
src/image/SkImage_Gpu.cpp
View File

@ -340,7 +340,7 @@ static sk_sp<SkImage> make_from_yuv_textures_copy(GrContext* ctx, SkYUVColorSpac
const int height = yuvSizes[0].fHeight;
// Needs to be a render target in order to draw to it for the yuv->rgb conversion.
sk_sp<GrRenderTargetContext> renderTargetContext(ctx->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(ctx->makeRenderTargetContext(
SkBackingFit::kExact,
width, height,
kRGBA_8888_GrPixelConfig,
@ -871,7 +871,7 @@ sk_sp<SkImage> SkImage_Gpu::onMakeColorSpace(sk_sp<SkColorSpace> colorSpace) con
return sk_ref_sp(const_cast<SkImage_Gpu*>(this));
}
sk_sp<GrRenderTargetContext> renderTargetContext(fContext->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(fContext->makeRenderTargetContext(
SkBackingFit::kExact, this->width(), this->height(), kRGBA_8888_GrPixelConfig, nullptr));
if (!renderTargetContext) {
return nullptr;

4
tests/ClearTest.cpp
View File

@ -57,8 +57,8 @@ static bool reset_rtc(sk_sp<GrRenderTargetContext>* rtc, GrContext* context, int
}
context->freeGpuResources();
*rtc = context->makeDeferredRenderTargetContext(SkBackingFit::kExact, w, h,
kRGBA_8888_GrPixelConfig, nullptr);
*rtc = context->makeRenderTargetContext(SkBackingFit::kExact, w, h, kRGBA_8888_GrPixelConfig,
nullptr);
SkASSERT((*rtc)->accessRenderTarget()->uniqueID() != oldID);

4
tests/GLProgramsTest.cpp
View File

@ -148,7 +148,7 @@ static sk_sp<GrRenderTargetContext> random_render_target_context(GrContext* cont
: kBottomLeft_GrSurfaceOrigin;
int sampleCnt = random->nextBool() ? SkTMin(4, caps->maxSampleCount()) : 0;
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
SkBackingFit::kExact,
kRenderTargetWidth,
kRenderTargetHeight,
@ -345,7 +345,7 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
drawingManager->flush(nullptr);
// Validate that GrFPs work correctly without an input.
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
SkBackingFit::kExact,
kRenderTargetWidth,
kRenderTargetHeight,

4
tests/GpuSampleLocationsTest.cpp
View File

@ -122,11 +122,11 @@ void test_sampleLocations(skiatest::Reporter* reporter, TestSampleLocationsInter
for (int i = 0; i < numTestPatterns; ++i) {
int numSamples = (int)kTestPatterns[i].size();
GrAlwaysAssert(numSamples > 1 && SkIsPow2(numSamples));
bottomUps[i] = ctx->makeDeferredRenderTargetContextWithFallback(
bottomUps[i] = ctx->makeRenderTargetContextWithFallback(
SkBackingFit::kExact, 100, 100, kRGBA_8888_GrPixelConfig, nullptr,
rand.nextRangeU(1 + numSamples / 2, numSamples),
kBottomLeft_GrSurfaceOrigin);
topDowns[i] = ctx->makeDeferredRenderTargetContextWithFallback(
topDowns[i] = ctx->makeRenderTargetContextWithFallback(
SkBackingFit::kExact, 100, 100, kRGBA_8888_GrPixelConfig, nullptr,
rand.nextRangeU(1 + numSamples / 2, numSamples),
kTopLeft_GrSurfaceOrigin);

4
tests/ImageStorageTest.cpp
View File

@ -140,8 +140,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
SkBudgeted::kYes, test.fData.get(), 0);
sk_sp<GrRenderTargetContext> rtContext =
context->makeDeferredRenderTargetContext(SkBackingFit::kExact, kS, kS,
kRGBA_8888_GrPixelConfig, nullptr);
context->makeRenderTargetContext(SkBackingFit::kExact, kS, kS,
kRGBA_8888_GrPixelConfig, nullptr);
GrPaint paint;
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
paint.addColorFragmentProcessor(TestFP::Make(context->resourceProvider(),

2
tests/IntTextureTest.cpp
View File

@ -239,7 +239,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
kRGBA_8888_sint_GrPixelConfig, nullptr,
testData.get(), 0);
sk_sp<GrRenderTargetContext> rtContext = context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> rtContext = context->makeRenderTargetContext(
SkBackingFit::kExact, kS, kS, kRGBA_8888_GrPixelConfig, nullptr);
struct {

6
tests/PreFlushCallbackTest.cpp
View File

@ -419,8 +419,7 @@ private:
static sk_sp<GrTextureProxy> make_upstream_image(GrContext* context, AtlasObject* object, int start,
sk_sp<GrTextureProxy> fakeAtlas) {
sk_sp<GrRenderTargetContext> rtc(context->makeDeferredRenderTargetContext(
SkBackingFit::kApprox,
sk_sp<GrRenderTargetContext> rtc(context->makeRenderTargetContext(SkBackingFit::kApprox,
3*kDrawnTileSize,
kDrawnTileSize,
kRGBA_8888_GrPixelConfig,
@ -555,8 +554,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(PreFlushCallbackTest, reporter, ctxInfo) {
static const int kFinalWidth = 6*kDrawnTileSize;
static const int kFinalHeight = kDrawnTileSize;
sk_sp<GrRenderTargetContext> rtc(context->makeDeferredRenderTargetContext(
SkBackingFit::kApprox,
sk_sp<GrRenderTargetContext> rtc(context->makeRenderTargetContext(SkBackingFit::kApprox,
kFinalWidth,
kFinalHeight,
kRGBA_8888_GrPixelConfig,

2
tests/PrimitiveProcessorTest.cpp
View File

@ -105,7 +105,7 @@ private:
DEF_GPUTEST_FOR_ALL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
SkBackingFit::kApprox,
1, 1, kRGBA_8888_GrPixelConfig,
nullptr));

4
tests/ProcessorTest.cpp
View File

@ -137,7 +137,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
desc.fHeight = 10;
for (int parentCnt = 0; parentCnt < 2; parentCnt++) {
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
SkBackingFit::kApprox, 1, 1, kRGBA_8888_GrPixelConfig, nullptr));
{
bool texelBufferSupport = context->caps()->shaderCaps()->texelBufferSupport();
@ -290,7 +290,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
// hard-code that value here:
SkRandom random(seed);
sk_sp<GrRenderTargetContext> rtc = context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> rtc = context->makeRenderTargetContext(
SkBackingFit::kExact, 256, 256, kRGBA_8888_GrPixelConfig, nullptr);
GrSurfaceDesc desc;
desc.fWidth = 256;

6
tests/RectangleTextureTest.cpp
View File

@ -21,9 +21,9 @@
static void test_basic_draw_as_src(skiatest::Reporter* reporter, GrContext* context,
sk_sp<GrSurfaceProxy> rectProxy, uint32_t expectedPixelValues[]) {
sk_sp<GrRenderTargetContext> rtContext(
context->makeDeferredRenderTargetContext(SkBackingFit::kExact, rectProxy->width(),
rectProxy->height(), rectProxy->config(),
nullptr));
context->makeRenderTargetContext(SkBackingFit::kExact, rectProxy->width(),
rectProxy->height(), rectProxy->config(),
nullptr));
for (auto filter : {GrSamplerParams::kNone_FilterMode,
GrSamplerParams::kBilerp_FilterMode,
GrSamplerParams::kMipMap_FilterMode}) {

25
tests/RenderTargetContextTest.cpp
View File

@ -15,10 +15,17 @@
static const int kSize = 64;
static sk_sp<GrRenderTargetContext> get_rtc(GrContext* ctx) {
return ctx->makeDeferredRenderTargetContext(SkBackingFit::kExact,
kSize, kSize,
kRGBA_8888_GrPixelConfig, nullptr);
static sk_sp<GrRenderTargetContext> get_rtc(GrContext* ctx, bool wrapped) {
if (wrapped) {
return ctx->makeRenderTargetContext(SkBackingFit::kExact,
kSize, kSize,
kRGBA_8888_GrPixelConfig, nullptr);
} else {
return ctx->makeDeferredRenderTargetContext(SkBackingFit::kExact,
kSize, kSize,
kRGBA_8888_GrPixelConfig, nullptr);
}
}
static void check_is_wrapped_status(skiatest::Reporter* reporter,
@ -35,10 +42,16 @@ static void check_is_wrapped_status(skiatest::Reporter* reporter,
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(RenderTargetContextTest, reporter, ctxInfo) {
GrContext* ctx = ctxInfo.grContext();
// A wrapped rtCtx's textureProxy is also wrapped
{
sk_sp<GrRenderTargetContext> rtCtx(get_rtc(ctx, true));
check_is_wrapped_status(reporter, rtCtx.get(), true);
}
// Calling instantiate on a GrRenderTargetContext's textureProxy also instantiates the
// GrRenderTargetContext
{
sk_sp<GrRenderTargetContext> rtCtx(get_rtc(ctx));
sk_sp<GrRenderTargetContext> rtCtx(get_rtc(ctx, false));
check_is_wrapped_status(reporter, rtCtx.get(), false);
@ -53,7 +66,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(RenderTargetContextTest, reporter, ctxInfo) {
// readPixels switches a deferred rtCtx to wrapped
{
sk_sp<GrRenderTargetContext> rtCtx(get_rtc(ctx));
sk_sp<GrRenderTargetContext> rtCtx(get_rtc(ctx, false));
check_is_wrapped_status(reporter, rtCtx.get(), false);

4
tests/SRGBMipMapTest.cpp
View File

@ -136,9 +136,9 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SRGBMipMaps, reporter, ctxInfo) {
// Create two render target contexts (L32 and S32)
sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::MakeSRGB();
sk_sp<GrRenderTargetContext> l32RenderTargetContext = context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> l32RenderTargetContext = context->makeRenderTargetContext(
SkBackingFit::kExact, rtS, rtS, kRGBA_8888_GrPixelConfig, nullptr);
sk_sp<GrRenderTargetContext> s32RenderTargetContext = context->makeDeferredRenderTargetContext(
sk_sp<GrRenderTargetContext> s32RenderTargetContext = context->makeRenderTargetContext(
SkBackingFit::kExact, rtS, rtS, kSRGBA_8888_GrPixelConfig, std::move(srgbColorSpace));
SkRect rect = SkRect::MakeWH(SkIntToScalar(rtS), SkIntToScalar(rtS));

3
tests/TessellatingPathRendererTests.cpp
View File

@ -303,8 +303,7 @@ static void test_path(GrContext* ctx,
DEF_GPUTEST_FOR_ALL_CONTEXTS(TessellatingPathRendererTests, reporter, ctxInfo) {
GrContext* ctx = ctxInfo.grContext();
sk_sp<GrRenderTargetContext> rtc(ctx->makeDeferredRenderTargetContext(
SkBackingFit::kApprox,
sk_sp<GrRenderTargetContext> rtc(ctx->makeRenderTargetContext(SkBackingFit::kApprox,
800, 800,
kRGBA_8888_GrPixelConfig,
nullptr,