*
* @return a draw context
*/
- sk_sp<GrDrawContext> drawContext(sk_sp<GrRenderTarget> rt, sk_sp<SkColorSpace> colorSpace,
- const SkSurfaceProps* = nullptr);
+ sk_sp<GrDrawContext> makeDrawContext(sk_sp<GrRenderTarget> rt, sk_sp<SkColorSpace> colorSpace,
+ const SkSurfaceProps* = nullptr);
/**
* Create both a GrRenderTarget and a matching GrDrawContext to wrap it.
* We guarantee that "asTexture" will succeed for drawContexts created
* via this entry point.
*/
- sk_sp<GrDrawContext> newDrawContext(SkBackingFit fit,
- int width, int height,
- GrPixelConfig config,
- sk_sp<SkColorSpace> colorSpace,
- int sampleCnt = 0,
- GrSurfaceOrigin origin = kDefault_GrSurfaceOrigin,
- const SkSurfaceProps* surfaceProps = nullptr,
- SkBudgeted = SkBudgeted::kYes);
+ sk_sp<GrDrawContext> makeDrawContext(SkBackingFit fit,
+ int width, int height,
+ GrPixelConfig config,
+ sk_sp<SkColorSpace> colorSpace,
+ int sampleCnt = 0,
+ GrSurfaceOrigin origin = kDefault_GrSurfaceOrigin,
+ const SkSurfaceProps* surfaceProps = nullptr,
+ SkBudgeted = SkBudgeted::kYes);
///////////////////////////////////////////////////////////////////////////
// Misc.
paint.addColorFragmentProcessor(std::move(fp));
paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- bounds.width(), bounds.height(),
- kRGBA_8888_GrPixelConfig,
- std::move(colorSpace)));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ bounds.width(), bounds.height(),
+ kRGBA_8888_GrPixelConfig,
+ std::move(colorSpace)));
if (!drawContext) {
return nullptr;
}
return nullptr;
}
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- width, height, config,
- std::move(colorSpace)));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ width, height, config,
+ std::move(colorSpace)));
if (!drawContext) {
return nullptr;
}
config = kRGBA_8888_GrPixelConfig;
}
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- bounds.width(), bounds.height(),
- config, nullptr));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ bounds.width(), bounds.height(),
+ config, nullptr));
if (!drawContext) {
return nullptr;
}
matrix.setTranslate(-SkIntToScalar(colorBounds.x()), -SkIntToScalar(colorBounds.y()));
sk_sp<GrDrawContext> drawContext(
- context->newDrawContext(SkBackingFit::kApprox, bounds.width(), bounds.height(),
- kSkia8888_GrPixelConfig, sk_ref_sp(source->getColorSpace())));
+ context->makeDrawContext(SkBackingFit::kApprox, bounds.width(), bounds.height(),
+ kSkia8888_GrPixelConfig, sk_ref_sp(source->getColorSpace())));
if (!drawContext) {
return nullptr;
}
const int height = dstBounds.height();
const GrPixelConfig config = srcTexture->config();
- sk_sp<GrDrawContext> dstDrawContext(context->newDrawContext(SkBackingFit::kApprox,
- width, height, config, colorSpace,
- 0, kDefault_GrSurfaceOrigin));
+ sk_sp<GrDrawContext> dstDrawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ width, height, config, colorSpace,
+ 0, kDefault_GrSurfaceOrigin));
if (!dstDrawContext) {
return nullptr;
}
return dstDrawContext;
}
- sk_sp<GrDrawContext> tmpDrawContext(context->newDrawContext(SkBackingFit::kApprox,
- width, height, config, colorSpace,
- 0, kDefault_GrSurfaceOrigin));
+ sk_sp<GrDrawContext> tmpDrawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ width, height, config, colorSpace,
+ 0, kDefault_GrSurfaceOrigin));
if (!tmpDrawContext) {
return nullptr;
}
sk_sp<GrTexture> inputTexture(input->asTextureRef(context));
SkASSERT(inputTexture);
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- offsetBounds.width(),
- offsetBounds.height(),
- kRGBA_8888_GrPixelConfig,
- sk_ref_sp(source->getColorSpace())));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ offsetBounds.width(),
+ offsetBounds.height(),
+ kRGBA_8888_GrPixelConfig,
+ sk_ref_sp(source->getColorSpace())));
if (!drawContext) {
return nullptr;
}
SkASSERT(radius.width() > 0 || radius.height() > 0);
if (radius.fWidth > 0) {
- sk_sp<GrDrawContext> dstDrawContext(context->newDrawContext(SkBackingFit::kApprox,
- rect.width(), rect.height(),
- kSkia8888_GrPixelConfig,
- colorSpace));
+ sk_sp<GrDrawContext> dstDrawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ rect.width(), rect.height(),
+ kSkia8888_GrPixelConfig,
+ colorSpace));
if (!dstDrawContext) {
return nullptr;
}
srcRect = dstRect;
}
if (radius.fHeight > 0) {
- sk_sp<GrDrawContext> dstDrawContext(context->newDrawContext(SkBackingFit::kApprox,
- rect.width(), rect.height(),
- kSkia8888_GrPixelConfig,
- colorSpace));
+ sk_sp<GrDrawContext> dstDrawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ rect.width(), rect.height(),
+ kSkia8888_GrPixelConfig,
+ colorSpace));
if (!dstDrawContext) {
return nullptr;
}
paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- bounds.width(), bounds.height(),
- kSkia8888_GrPixelConfig,
- sk_ref_sp(source->getColorSpace())));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ bounds.width(), bounds.height(),
+ kSkia8888_GrPixelConfig,
+ sk_ref_sp(source->getColorSpace())));
if (!drawContext) {
return nullptr;
}
config = kAlpha_8_GrPixelConfig;
}
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- maskRect.width(),
- maskRect.height(),
- config,
- nullptr,
- sampleCnt));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ maskRect.width(),
+ maskRect.height(),
+ config,
+ nullptr,
+ sampleCnt));
if (!drawContext) {
return nullptr;
}
config = kAlpha_8_GrPixelConfig;
}
- sk_sp<GrDrawContext> dc(context->newDrawContext(SkBackingFit::kApprox,
- clipSpaceIBounds.width(),
- clipSpaceIBounds.height(),
- config, nullptr));
+ sk_sp<GrDrawContext> dc(context->makeDrawContext(SkBackingFit::kApprox,
+ clipSpaceIBounds.width(),
+ clipSpaceIBounds.height(),
+ config, nullptr));
if (!dc) {
return nullptr;
}
// TODO: Need to decide the semantics of this function for color spaces. Do we support
// conversion from 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<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(renderTarget), nullptr));
+ sk_sp<GrDrawContext> drawContext(this->makeDrawContext(sk_ref_sp(renderTarget), nullptr));
if (!drawContext) {
return false;
}
// 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<GrDrawContext> tempDC = this->newDrawContext(tempDrawInfo.fTempSurfaceFit,
+ sk_sp<GrDrawContext> tempDC = this->makeDrawContext(tempDrawInfo.fTempSurfaceFit,
tempDrawInfo.fTempSurfaceDesc.fWidth,
tempDrawInfo.fTempSurfaceDesc.fHeight,
tempDrawInfo.fTempSurfaceDesc.fConfig,
}
// TODO: Supply color space?
- sk_sp<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(dst), nullptr));
+ sk_sp<GrDrawContext> drawContext(this->makeDrawContext(sk_ref_sp(dst), nullptr));
if (!drawContext) {
return false;
}
src->flushWrites();
return fGpu->copySurface(dst, src, clippedSrcRect, clippedDstPoint);
}
- sk_sp<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(dst->asRenderTarget()), nullptr));
+ sk_sp<GrDrawContext> drawContext(this->makeDrawContext(sk_ref_sp(dst->asRenderTarget()), nullptr));
if (!drawContext) {
return false;
}
}
-sk_sp<GrDrawContext> GrContext::drawContext(sk_sp<GrRenderTarget> rt,
+sk_sp<GrDrawContext> GrContext::makeDrawContext(sk_sp<GrRenderTarget> rt,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER
return fDrawingManager->drawContext(std::move(rt), std::move(colorSpace), surfaceProps);
}
-sk_sp<GrDrawContext> GrContext::newDrawContext(SkBackingFit fit,
- int width, int height,
- GrPixelConfig config,
- sk_sp<SkColorSpace> colorSpace,
- int sampleCnt,
- GrSurfaceOrigin origin,
- const SkSurfaceProps* surfaceProps,
- SkBudgeted budgeted) {
+sk_sp<GrDrawContext> GrContext::makeDrawContext(SkBackingFit fit,
+ int width, int height,
+ GrPixelConfig config,
+ sk_sp<SkColorSpace> colorSpace,
+ int sampleCnt,
+ GrSurfaceOrigin origin,
+ const SkSurfaceProps* surfaceProps,
+ SkBudgeted budgeted) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = origin;
return nullptr;
}
- sk_sp<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(tex->asRenderTarget()),
- std::move(colorSpace), surfaceProps));
+ sk_sp<GrDrawContext> drawContext(this->makeDrawContext(sk_ref_sp(tex->asRenderTarget()),
+ std::move(colorSpace), surfaceProps));
if (!drawContext) {
return nullptr;
}
return;
}
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(this), nullptr));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(sk_ref_sp(this), nullptr));
if (!drawContext) {
return;
}
}
}
- sk_sp<GrDrawContext> copyDC = context->newDrawContext(SkBackingFit::kExact, copyParams.fWidth,
- copyParams.fHeight, config, nullptr);
+ sk_sp<GrDrawContext> copyDC = context->makeDrawContext(SkBackingFit::kExact, copyParams.fWidth,
+ copyParams.fHeight, config, nullptr);
if (!copyDC) {
return nullptr;
}
// 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]) {
- yuvDrawContext = context->newDrawContext(SkBackingFit::kApprox,
- sizes[0].fWidth, sizes[0].fHeight,
- kRGBA_8888_GrPixelConfig, nullptr);
+ yuvDrawContext = context->makeDrawContext(SkBackingFit::kApprox,
+ sizes[0].fWidth, sizes[0].fHeight,
+ kRGBA_8888_GrPixelConfig, nullptr);
if (!yuvDrawContext) {
return false;
}
} else {
- yDrawContext = context->newDrawContext(SkBackingFit::kApprox,
- sizes[0].fWidth, sizes[0].fHeight,
- singleChannelPixelConfig, nullptr);
+ yDrawContext = context->makeDrawContext(SkBackingFit::kApprox,
+ sizes[0].fWidth, sizes[0].fHeight,
+ singleChannelPixelConfig, nullptr);
if (!yDrawContext) {
return false;
}
if (sizes[1] == sizes[2]) {
// TODO: Add support for GL_RG when available.
- uvDrawContext = context->newDrawContext(SkBackingFit::kApprox,
- sizes[1].fWidth, sizes[1].fHeight,
- kRGBA_8888_GrPixelConfig, nullptr);
+ uvDrawContext = context->makeDrawContext(SkBackingFit::kApprox,
+ sizes[1].fWidth, sizes[1].fHeight,
+ kRGBA_8888_GrPixelConfig, nullptr);
if (!uvDrawContext) {
return false;
}
} else {
- uDrawContext = context->newDrawContext(SkBackingFit::kApprox,
- sizes[1].fWidth, sizes[1].fHeight,
- singleChannelPixelConfig, nullptr);
- vDrawContext = context->newDrawContext(SkBackingFit::kApprox,
- sizes[2].fWidth, sizes[2].fHeight,
- singleChannelPixelConfig, nullptr);
+ uDrawContext = context->makeDrawContext(SkBackingFit::kApprox,
+ sizes[1].fWidth, sizes[1].fHeight,
+ singleChannelPixelConfig, nullptr);
+ vDrawContext = context->makeDrawContext(SkBackingFit::kApprox,
+ sizes[2].fWidth, sizes[2].fHeight,
+ singleChannelPixelConfig, nullptr);
if (!uDrawContext || !vDrawContext) {
return false;
}
}
// We never want to perform color-space conversion during the decode
- sk_sp<GrDrawContext> drawContext(ctx->newDrawContext(SkBackingFit::kExact,
- desc.fWidth, desc.fHeight,
- desc.fConfig, nullptr,
- desc.fSampleCnt));
+ sk_sp<GrDrawContext> drawContext(ctx->makeDrawContext(SkBackingFit::kExact,
+ desc.fWidth, desc.fHeight,
+ desc.fConfig, nullptr,
+ desc.fSampleCnt));
if (!drawContext) {
return nullptr;
}
GrContext* context = rt->getContext();
- sk_sp<GrDrawContext> drawContext(context->drawContext(std::move(rt), std::move(colorSpace),
- props));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(std::move(rt), std::move(colorSpace),
+ props));
return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
}
GrPixelConfig config = SkImageInfo2GrPixelConfig(ct, at, cs, *context->caps());
- return context->newDrawContext(SkBackingFit::kExact, // Why exact?
- origInfo.width(), origInfo.height(),
- config, sk_ref_sp(cs), sampleCount,
- origin, surfaceProps, budgeted);
+ return context->makeDrawContext(SkBackingFit::kExact, // Why exact?
+ origInfo.width(), origInfo.height(),
+ config, sk_ref_sp(cs), sampleCount,
+ origin, surfaceProps, budgeted);
}
sk_sp<SkSpecialImage> SkGpuDevice::filterTexture(const SkDraw& draw,
SkBackingFit fit = kNever_TileUsage == cinfo.fTileUsage ? SkBackingFit::kApprox
: SkBackingFit::kExact;
- sk_sp<GrDrawContext> dc(fContext->newDrawContext(fit,
- cinfo.fInfo.width(), cinfo.fInfo.height(),
- fDrawContext->config(),
- sk_ref_sp(fDrawContext->getColorSpace()),
- fDrawContext->desc().fSampleCnt,
- kDefault_GrSurfaceOrigin,
- &props));
+ sk_sp<GrDrawContext> dc(fContext->makeDrawContext(fit,
+ cinfo.fInfo.width(), cinfo.fInfo.height(),
+ fDrawContext->config(),
+ sk_ref_sp(fDrawContext->getColorSpace()),
+ fDrawContext->desc().fSampleCnt,
+ kDefault_GrSurfaceOrigin,
+ &props));
if (!dc) {
SkErrorInternals::SetError( kInternalError_SkError,
"---- failed to create gpu device texture [%d %d]\n",
}
}
- sk_sp<GrDrawContext> readDC(context->newDrawContext(SkBackingFit::kExact, kSize, kSize,
- kConfig, nullptr));
- sk_sp<GrDrawContext> tempDC(context->newDrawContext(SkBackingFit::kExact, kSize, kSize,
- kConfig, nullptr));
+ sk_sp<GrDrawContext> readDC(context->makeDrawContext(SkBackingFit::kExact, kSize, kSize,
+ kConfig, nullptr));
+ sk_sp<GrDrawContext> tempDC(context->makeDrawContext(SkBackingFit::kExact, kSize, kSize,
+ kConfig, nullptr));
if (!readDC || !tempDC) {
return;
}
}
// Setup dummy SkPaint / GrPaint / GrDrawContext
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox, 1024, 1024,
- kSkia8888_GrPixelConfig, nullptr));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox, 1024, 1024,
+ kSkia8888_GrPixelConfig, nullptr));
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
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<GrDrawContext> drawContext(ctx->newDrawContext(SkBackingFit::kExact,
- width, height,
- kRGBA_8888_GrPixelConfig,
- std::move(imageColorSpace),
- 0,
- origin));
+ sk_sp<GrDrawContext> drawContext(ctx->makeDrawContext(SkBackingFit::kExact,
+ width, height,
+ kRGBA_8888_GrPixelConfig,
+ std::move(imageColorSpace),
+ 0,
+ origin));
if (!drawContext) {
return nullptr;
}
}
context->freeGpuResources();
- *dc = context->newDrawContext(SkBackingFit::kExact, w, h, kRGBA_8888_GrPixelConfig, nullptr);
+ *dc = context->makeDrawContext(SkBackingFit::kExact, w, h, kRGBA_8888_GrPixelConfig, nullptr);
SkASSERT((*dc)->accessRenderTarget()->getUniqueID() != oldID);
if (!ctxInfo.grContext()->caps()->shaderCaps()->shaderDerivativeSupport()) {
return;
}
- sk_sp<GrDrawContext> drawContext(ctxInfo.grContext()->newDrawContext(SkBackingFit::kApprox,
- 800, 800,
- kSkia8888_GrPixelConfig,
- nullptr,
- 0,
- kTopLeft_GrSurfaceOrigin));
- if (!drawContext) {
+ sk_sp<GrDrawContext> dc(ctxInfo.grContext()->makeDrawContext(SkBackingFit::kApprox,
+ 800, 800,
+ kSkia8888_GrPixelConfig,
+ nullptr,
+ 0,
+ kTopLeft_GrSurfaceOrigin));
+ if (!dc) {
return;
}
GrAADistanceFieldPathRenderer dfpr;
GrTestTarget tt;
- ctxInfo.grContext()->getTestTarget(&tt, drawContext);
+ ctxInfo.grContext()->getTestTarget(&tt, dc);
GrResourceProvider* rp = tt.resourceProvider();
- test_far_from_origin(drawContext.get(), &dfpr, rp);
+ test_far_from_origin(dc.get(), &dfpr, rp);
ctxInfo.grContext()->flush();
}
#endif
: kBottomLeft_GrSurfaceOrigin;
int sampleCnt = random->nextBool() ? SkTMin(4, caps->maxSampleCount()) : 0;
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kExact,
- kRenderTargetWidth,
- kRenderTargetHeight,
- kRGBA_8888_GrPixelConfig,
- nullptr,
- sampleCnt,
- origin));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kExact,
+ kRenderTargetWidth,
+ kRenderTargetHeight,
+ kRGBA_8888_GrPixelConfig,
+ nullptr,
+ sampleCnt,
+ origin));
return drawContext;
}
drawingManager->flush();
// Validate that GrFPs work correctly without an input.
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kExact,
- kRenderTargetWidth,
- kRenderTargetHeight,
- kRGBA_8888_GrPixelConfig,
- nullptr));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kExact,
+ kRenderTargetWidth,
+ kRenderTargetHeight,
+ kRGBA_8888_GrPixelConfig,
+ nullptr));
if (!drawContext) {
SkDebugf("Could not allocate a drawContext");
return false;
DEF_GPUTEST_FOR_ALL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
- sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
- 1, 1, kRGBA_8888_GrPixelConfig,
- nullptr));
+ sk_sp<GrDrawContext> drawContext(context->makeDrawContext(SkBackingFit::kApprox,
+ 1, 1, kRGBA_8888_GrPixelConfig,
+ nullptr));
if (!drawContext) {
ERRORF(reporter, "Could not create draw context.");
return;
GrTexture* rectangleTexture) {
if (rectangleTexture->asRenderTarget()) {
sk_sp<GrDrawContext> dc(
- context->drawContext(sk_ref_sp(rectangleTexture->asRenderTarget()),
- nullptr));
+ context->makeDrawContext(sk_ref_sp(rectangleTexture->asRenderTarget()),
+ nullptr));
if (!dc) {
ERRORF(reporter, "Could not get GrDrawContext for rectangle texture.");
return;
// Create two draw contexts (L32 and S32)
sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
- sk_sp<GrDrawContext> l32DrawContext = context->newDrawContext(SkBackingFit::kExact, rtS, rtS,
- kSkia8888_GrPixelConfig,
- nullptr);
- sk_sp<GrDrawContext> s32DrawContext = context->newDrawContext(SkBackingFit::kExact, rtS, rtS,
- kSkiaGamma8888_GrPixelConfig,
- std::move(srgbColorSpace));
+ sk_sp<GrDrawContext> l32DrawContext = context->makeDrawContext(SkBackingFit::kExact, rtS, rtS,
+ kSkia8888_GrPixelConfig,
+ nullptr);
+ sk_sp<GrDrawContext> s32DrawContext = context->makeDrawContext(SkBackingFit::kExact, rtS, rtS,
+ kSkiaGamma8888_GrPixelConfig,
+ std::move(srgbColorSpace));
SkRect rect = SkRect::MakeWH(SkIntToScalar(rtS), SkIntToScalar(rtS));
GrNoClip noClip;
}
DEF_GPUTEST_FOR_ALL_CONTEXTS(TessellatingPathRendererTests, reporter, ctxInfo) {
- sk_sp<GrDrawContext> drawContext(ctxInfo.grContext()->newDrawContext(SkBackingFit::kApprox,
- 800, 800,
- kSkia8888_GrPixelConfig,
- nullptr,
- 0,
- kTopLeft_GrSurfaceOrigin));
- if (!drawContext) {
+ sk_sp<GrDrawContext> dc(ctxInfo.grContext()->makeDrawContext(SkBackingFit::kApprox,
+ 800, 800,
+ kSkia8888_GrPixelConfig,
+ nullptr,
+ 0,
+ kTopLeft_GrSurfaceOrigin));
+ if (!dc) {
return;
}
GrTestTarget tt;
- ctxInfo.grContext()->getTestTarget(&tt, drawContext);
+ ctxInfo.grContext()->getTestTarget(&tt, dc);
GrResourceProvider* rp = tt.resourceProvider();
- test_path(drawContext.get(), rp, create_path_0());
- test_path(drawContext.get(), rp, create_path_1());
- test_path(drawContext.get(), rp, create_path_2());
- test_path(drawContext.get(), rp, create_path_3());
- test_path(drawContext.get(), rp, create_path_4());
- test_path(drawContext.get(), rp, create_path_5());
- test_path(drawContext.get(), rp, create_path_6());
- test_path(drawContext.get(), rp, create_path_7());
- test_path(drawContext.get(), rp, create_path_8());
- test_path(drawContext.get(), rp, create_path_9());
- test_path(drawContext.get(), rp, create_path_10());
- test_path(drawContext.get(), rp, create_path_11());
- test_path(drawContext.get(), rp, create_path_12());
- test_path(drawContext.get(), rp, create_path_13());
- test_path(drawContext.get(), rp, create_path_14());
- test_path(drawContext.get(), rp, create_path_15());
+ test_path(dc.get(), rp, create_path_0());
+ test_path(dc.get(), rp, create_path_1());
+ test_path(dc.get(), rp, create_path_2());
+ test_path(dc.get(), rp, create_path_3());
+ test_path(dc.get(), rp, create_path_4());
+ test_path(dc.get(), rp, create_path_5());
+ test_path(dc.get(), rp, create_path_6());
+ test_path(dc.get(), rp, create_path_7());
+ test_path(dc.get(), rp, create_path_8());
+ test_path(dc.get(), rp, create_path_9());
+ test_path(dc.get(), rp, create_path_10());
+ test_path(dc.get(), rp, create_path_11());
+ test_path(dc.get(), rp, create_path_12());
+ test_path(dc.get(), rp, create_path_13());
+ test_path(dc.get(), rp, create_path_14());
+ test_path(dc.get(), rp, create_path_15());
}
#endif