}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
- GrContext* context = rt->getContext();
- if (nullptr == context) {
- return;
- }
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
- if (!drawContext) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
return;
}
// Mult by 3 for each edge effect type
int numCols = SkScalarCeilToInt(SkScalarSqrt(SkIntToScalar(kNumCubics*3)));
int numRows = SkScalarCeilToInt(SkIntToScalar(kNumCubics*3) / numCols);
- SkScalar w = SkIntToScalar(rt->width()) / numCols;
- SkScalar h = SkIntToScalar(rt->height()) / numRows;
+ SkScalar w = SkIntToScalar(drawContext->width()) / numCols;
+ SkScalar h = SkIntToScalar(drawContext->height()) / numRows;
int row = 0;
int col = 0;
static const GrColor color = 0xff000000;
GrPipelineBuilder pipelineBuilder;
pipelineBuilder.setXPFactory(
GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
SkAutoTUnref<GrDrawBatch> batch(
new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, klmSigns[c]));
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
- GrContext* context = rt->getContext();
- if (nullptr == context) {
- return;
- }
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
- if (!drawContext) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
return;
}
// Mult by 3 for each edge effect type
int numCols = SkScalarCeilToInt(SkScalarSqrt(SkIntToScalar(kNumConics*3)));
int numRows = SkScalarCeilToInt(SkIntToScalar(kNumConics*3) / numCols);
- SkScalar w = SkIntToScalar(rt->width()) / numCols;
- SkScalar h = SkIntToScalar(rt->height()) / numRows;
+ SkScalar w = SkIntToScalar(drawContext->width()) / numCols;
+ SkScalar h = SkIntToScalar(drawContext->height()) / numRows;
int row = 0;
int col = 0;
static const GrColor color = 0xff000000;
GrPipelineBuilder pipelineBuilder;
pipelineBuilder.setXPFactory(
GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
SkAutoTUnref<GrDrawBatch> batch(
new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f));
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
- GrContext* context = rt->getContext();
- if (nullptr == context) {
- return;
- }
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
- if (!drawContext) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
return;
}
int numCols = SkScalarCeilToInt(SkScalarSqrt(SkIntToScalar(kNumQuads*3)));
int numRows = SkScalarCeilToInt(SkIntToScalar(kNumQuads*3) / numCols);
- SkScalar w = SkIntToScalar(rt->width()) / numCols;
- SkScalar h = SkIntToScalar(rt->height()) / numRows;
+ SkScalar w = SkIntToScalar(drawContext->width()) / numCols;
+ SkScalar h = SkIntToScalar(drawContext->height()) / numRows;
int row = 0;
int col = 0;
static const GrColor color = 0xff000000;
GrPipelineBuilder pipelineBuilder;
pipelineBuilder.setXPFactory(
GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
GrPathUtils::QuadUVMatrix DevToUV(pts);
SkISize onISize() override { return SkISize::Make(fWidth, fHeight); }
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- GrContext* context = rt ? rt->getContext() : nullptr;
- if (!context) {
- skiagm::GM::DrawGpuOnlyMessage(canvas);
- return;
- }
-
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
if (!drawContext) {
+ skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
SkASSERT(fp);
if (fp) {
pipelineBuilder.addCoverageFragmentProcessor(fp);
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
SkRect bounds = testBounds;
bounds.offset(SkIntToScalar(x), SkIntToScalar(y));
}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
- return;
- }
- GrContext* context = rt->getContext();
- if (nullptr == context) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
- if (!drawContext) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
return;
}
SkAutoTUnref<GrFragmentProcessor> fp(GrConstColorProcessor::Create(color, mode));
GrClip clip;
- GrPipelineBuilder pipelineBuilder(grPaint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(grPaint,
+ drawContext->accessRenderTarget(),
+ clip);
pipelineBuilder.addColorFragmentProcessor(fp);
SkAutoTUnref<GrDrawBatch> batch(
}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
- skiagm::GM::DrawGpuOnlyMessage(canvas);
- return;
- }
- GrContext* context = rt->getContext();
- if (nullptr == context) {
- return;
- }
-
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
if (!drawContext) {
+ skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
pipelineBuilder.setXPFactory(
GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
pipelineBuilder.addCoverageFragmentProcessor(fp);
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(p.getBounds(), 0xff000000));
pipelineBuilder.setXPFactory(
GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
pipelineBuilder.addCoverageFragmentProcessor(fp);
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(rect, 0xff000000));
}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- GrContext* context;
- if (!rt || !(context = rt->getContext())) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- GrContext* context;
- if (!rt || !(context = rt->getContext())) {
+ GrContext *context = canvas->getGrContext();
+ if (!context) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
SkISize onISize() override { return SkISize::Make(kImageWidth, kImageHeight); }
void onDraw(SkCanvas* canvas) override {
- GrContext* context = nullptr;
-#if SK_SUPPORT_GPU
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- context = rt ? rt->getContext() : nullptr;
- sk_sp<GrDrawContext> drawContext;
- if (kEffect_Type == fType) {
- if (!context) {
- skiagm::GM::DrawGpuOnlyMessage(canvas);
- return;
- }
-
- drawContext = context->drawContext(sk_ref_sp(rt));
- if (!drawContext) {
- return;
- }
- }
-#endif
- if (kEffect_Type == fType && nullptr == context) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (kEffect_Type == fType && !drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
rrect));
if (fp) {
pipelineBuilder.addCoverageFragmentProcessor(fp);
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
SkRect bounds = rrect.getBounds();
bounds.outset(2.f, 2.f);
static const int S = 200;
DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) {
- GrRenderTarget* target = canvas->internal_private_accessTopLayerRenderTarget();
- GrContext* ctx = canvas->getGrContext();
- sk_sp<GrDrawContext> drawContext(ctx ? ctx->drawContext(sk_ref_sp(target)) : nullptr);
- if (drawContext && target) {
- SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
- static const int stride = 2 * S;
- static const SkPMColor gray = SkPackARGB32(0x40, 0x40, 0x40, 0x40);
- static const SkPMColor white = SkPackARGB32(0xff, 0xff, 0xff, 0xff);
- static const SkPMColor red = SkPackARGB32(0x80, 0x80, 0x00, 0x00);
- static const SkPMColor blue = SkPackARGB32(0x80, 0x00, 0x00, 0x80);
- static const SkPMColor green = SkPackARGB32(0x80, 0x00, 0x80, 0x00);
- static const SkPMColor black = SkPackARGB32(0x00, 0x00, 0x00, 0x00);
- for (int i = 0; i < 2; ++i) {
- int offset = 0;
- // fill upper-left
- for (int y = 0; y < S; ++y) {
- for (int x = 0; x < S; ++x) {
- gTextureData[offset + y * stride + x] = gray;
- }
- }
- // fill upper-right
- offset = S;
- for (int y = 0; y < S; ++y) {
- for (int x = 0; x < S; ++x) {
- gTextureData[offset + y * stride + x] = white;
- }
- }
- // fill lower left
- offset = S * stride;
- for (int y = 0; y < S; ++y) {
- for (int x = 0; x < S; ++x) {
- gTextureData[offset + y * stride + x] = black;
- }
- }
- // fill lower right
- offset = S * stride + S;
- for (int y = 0; y < S; ++y) {
- for (int x = 0; x < S; ++x) {
- gTextureData[offset + y * stride + x] = gray;
- }
- }
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
+ skiagm::GM::DrawGpuOnlyMessage(canvas);
+ return;
+ }
- GrSurfaceDesc desc;
- // use RT flag bit because in GL it makes the texture be bottom-up
- desc.fFlags = i ? kRenderTarget_GrSurfaceFlag :
- kNone_GrSurfaceFlags;
- desc.fConfig = kSkia8888_GrPixelConfig;
- desc.fWidth = 2 * S;
- desc.fHeight = 2 * S;
- GrTexture* texture = ctx->textureProvider()->createTexture(
- desc, SkBudgeted::kNo, gTextureData.get(), 0);
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
+ return;
+ }
- if (!texture) {
- return;
- }
- SkAutoTUnref<GrTexture> au(texture);
+ SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
+ static const int stride = 2 * S;
+ static const SkPMColor gray = SkPackARGB32(0x40, 0x40, 0x40, 0x40);
+ static const SkPMColor white = SkPackARGB32(0xff, 0xff, 0xff, 0xff);
+ static const SkPMColor red = SkPackARGB32(0x80, 0x80, 0x00, 0x00);
+ static const SkPMColor blue = SkPackARGB32(0x80, 0x00, 0x00, 0x80);
+ static const SkPMColor green = SkPackARGB32(0x80, 0x00, 0x80, 0x00);
+ static const SkPMColor black = SkPackARGB32(0x00, 0x00, 0x00, 0x00);
+ for (int i = 0; i < 2; ++i) {
+ int offset = 0;
+ // fill upper-left
+ for (int y = 0; y < S; ++y) {
+ for (int x = 0; x < S; ++x) {
+ gTextureData[offset + y * stride + x] = gray;
+ }
+ }
+ // fill upper-right
+ offset = S;
+ for (int y = 0; y < S; ++y) {
+ for (int x = 0; x < S; ++x) {
+ gTextureData[offset + y * stride + x] = white;
+ }
+ }
+ // fill lower left
+ offset = S * stride;
+ for (int y = 0; y < S; ++y) {
+ for (int x = 0; x < S; ++x) {
+ gTextureData[offset + y * stride + x] = black;
+ }
+ }
+ // fill lower right
+ offset = S * stride + S;
+ for (int y = 0; y < S; ++y) {
+ for (int x = 0; x < S; ++x) {
+ gTextureData[offset + y * stride + x] = gray;
+ }
+ }
- // setup new clip
- GrClip clip(SkRect::MakeWH(2*S, 2*S));
+ GrSurfaceDesc desc;
+ // use RT flag bit because in GL it makes the texture be bottom-up
+ desc.fFlags = i ? kRenderTarget_GrSurfaceFlag :
+ kNone_GrSurfaceFlags;
+ desc.fConfig = kSkia8888_GrPixelConfig;
+ desc.fWidth = 2 * S;
+ desc.fHeight = 2 * S;
+ GrTexture* texture = context->textureProvider()->createTexture(
+ desc, SkBudgeted::kNo, gTextureData.get(), 0);
- GrPaint paint;
- paint.setPorterDuffXPFactory(SkXfermode::kSrcOver_Mode);
+ if (!texture) {
+ return;
+ }
+ SkAutoTUnref<GrTexture> au(texture);
- SkMatrix vm;
- if (i) {
- vm.setRotate(90 * SK_Scalar1,
- S * SK_Scalar1,
- S * SK_Scalar1);
- } else {
- vm.reset();
- }
- SkMatrix tm;
- tm = vm;
- tm.postIDiv(2*S, 2*S);
- paint.addColorTextureProcessor(texture, tm);
+ // setup new clip
+ GrClip clip(SkRect::MakeWH(2*S, 2*S));
- drawContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
+ GrPaint paint;
+ paint.setPorterDuffXPFactory(SkXfermode::kSrcOver_Mode);
- // now update the lower right of the texture in first pass
- // or upper right in second pass
- offset = 0;
- for (int y = 0; y < S; ++y) {
- for (int x = 0; x < S; ++x) {
- gTextureData[offset + y * stride + x] =
- ((x + y) % 2) ? (i ? green : red) : blue;
- }
- }
- texture->writePixels(S, (i ? 0 : S), S, S,
- texture->config(), gTextureData.get(),
- 4 * stride);
- drawContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
- }
+ SkMatrix vm;
+ if (i) {
+ vm.setRotate(90 * SK_Scalar1,
+ S * SK_Scalar1,
+ S * SK_Scalar1);
} else {
- skiagm::GM::DrawGpuOnlyMessage(canvas);
+ vm.reset();
}
+ SkMatrix tm;
+ tm = vm;
+ tm.postIDiv(2*S, 2*S);
+ paint.addColorTextureProcessor(texture, tm);
+
+ drawContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
+
+ // now update the lower right of the texture in first pass
+ // or upper right in second pass
+ offset = 0;
+ for (int y = 0; y < S; ++y) {
+ for (int x = 0; x < S; ++x) {
+ gTextureData[offset + y * stride + x] =
+ ((x + y) % 2) ? (i ? green : red) : blue;
+ }
+ }
+ texture->writePixels(S, (i ? 0 : S), S, S,
+ texture->config(), gTextureData.get(),
+ 4 * stride);
+ drawContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
+ }
}
#endif
+
}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
- return;
- }
- GrContext* context = rt->getContext();
- if (nullptr == context) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
- if (!drawContext) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
return;
}
continue;
}
const SkMatrix viewMatrix = SkMatrix::MakeTrans(x, y);
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
pipelineBuilder.addColorFragmentProcessor(fp);
SkAutoTUnref<GrDrawBatch> batch(
}
void onDraw(SkCanvas* canvas) override {
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (nullptr == rt) {
- return;
- }
- GrContext* context = rt->getContext();
- if (nullptr == context) {
+ GrDrawContext* drawContext = canvas->internal_private_accessTopLayerDrawContext();
+ if (!drawContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
- return;
+ return;
}
- sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(rt)));
- if (!drawContext) {
+ GrContext* context = canvas->getGrContext();
+ if (!context) {
return;
}
if (fp) {
SkMatrix viewMatrix;
viewMatrix.setTranslate(x, y);
- pipelineBuilder.setRenderTarget(rt);
+ pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
pipelineBuilder.addColorFragmentProcessor(fp);
SkAutoTUnref<GrDrawBatch> batch(
GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE, viewMatrix,
#include "SkXfermode.h"
class GrContext;
-class GrRenderTarget;
+class GrDrawContext;
class SkBaseDevice;
class SkCanvasClipVisitor;
class SkClipStack;
///////////////////////////////////////////////////////////////////////////
// don't call
- GrRenderTarget* internal_private_accessTopLayerRenderTarget();
+ GrDrawContext* internal_private_accessTopLayerDrawContext();
// don't call
static void Internal_Private_SetIgnoreSaveLayerBounds(bool);
/**
* Return the device's associated gpu render target, or NULL.
*/
- virtual GrRenderTarget* accessRenderTarget() { return NULL; }
+ virtual GrRenderTarget* accessRenderTarget() { return nullptr; }
+ /**
+ * Don't call this!
+ */
+ virtual GrDrawContext* accessDrawContext() { return nullptr; }
/**
* Return the device's origin: its offset in device coordinates from
SkBitmap srcBM;
#if SK_SUPPORT_GPU
+ // TODO: remove this virtual usage of accessRenderTarget! It is preventing
+ // removal of the virtual on SkBaseDevice.
GrRenderTarget* srcRT = src->accessRenderTarget();
if (srcRT && !srcRT->asTexture() && dst->accessRenderTarget()) {
// When both the src & the dst are on the gpu but the src doesn't have a texture,
return fMCRec->fRasterClip.forceGetBW();
}
-GrRenderTarget* SkCanvas::internal_private_accessTopLayerRenderTarget() {
+GrDrawContext* SkCanvas::internal_private_accessTopLayerDrawContext() {
SkBaseDevice* dev = this->getTopDevice();
- return dev ? dev->accessRenderTarget() : nullptr;
+ return dev ? dev->accessDrawContext() : nullptr;
}
GrContext* SkCanvas::getGrContext() {
#if SK_SUPPORT_GPU
#include "GrContext.h"
+#include "GrDrawContext.h"
#include "GrLayerHoister.h"
#include "GrRecordReplaceDraw.h"
#include "GrRenderTarget.h"
SkMatrix initialMatrix = data.fCanvas->getTotalMatrix();
initialMatrix.preConcat(data.fMatrix);
- GrRenderTarget* rt = data.fCanvas->internal_private_accessTopLayerRenderTarget();
- SkASSERT(rt);
+ GrDrawContext* dc = data.fCanvas->internal_private_accessTopLayerDrawContext();
+ SkASSERT(dc);
// TODO: sorting the cacheable layers from smallest to largest
// would improve the packing and reduce the number of swaps
GrLayerHoister::FindLayersToAtlas(context, data.fPicture, initialMatrix,
clipBounds,
&atlasedNeedRendering, &atlasedRecycled,
- rt->numColorSamples());
+ dc->numColorSamples());
}
}
const SkMatrix initialMatrix = canvas->getTotalMatrix();
- GrRenderTarget* rt = data.fCanvas->internal_private_accessTopLayerRenderTarget();
- SkASSERT(rt);
+ GrDrawContext* dc = data.fCanvas->internal_private_accessTopLayerDrawContext();
+ SkASSERT(dc);
// Find the layers required by this canvas. It will return atlased
// layers in the 'recycled' list since they have already been drawn.
GrLayerHoister::FindLayersToHoist(context, picture, initialMatrix,
clipBounds, &needRendering, &recycled,
- rt->numColorSamples());
+ dc->numColorSamples());
GrLayerHoister::DrawLayers(context, needRendering);
return fRenderTarget;
}
+GrDrawContext* SkGpuDevice::accessDrawContext() {
+ ASSERT_SINGLE_OWNER
+ return fDrawContext.get();
+}
+
void SkGpuDevice::clearAll() {
ASSERT_SINGLE_OWNER
GrColor color = 0;
void replaceRenderTarget(bool shouldRetainContent);
GrRenderTarget* accessRenderTarget() override;
+ GrDrawContext* accessDrawContext() override;
SkImageInfo imageInfo() const override {
return fLegacyBitmap.info();
#if SK_SUPPORT_GPU
#include "GrContext.h"
+#include "GrDrawContext.h"
#include "GrGpu.h"
#endif
};
auto surfaceBackingStore = [reporter](SkSurface* surface) {
- GrRenderTarget* rt =
- surface->getCanvas()->internal_private_accessTopLayerRenderTarget();
+ GrDrawContext* dc = surface->getCanvas()->internal_private_accessTopLayerDrawContext();
+ GrRenderTarget* rt = dc->accessRenderTarget();
if (!rt) {
ERRORF(reporter, "Not render target backed.");
return static_cast<intptr_t>(0);
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.fGrContext;
std::function<GrSurface*(SkSurface*)> grSurfaceGetters[] = {
- [] (SkSurface* s){ return s->getCanvas()->internal_private_accessTopLayerRenderTarget(); },
+ [] (SkSurface* s){
+ GrDrawContext* dc = s->getCanvas()->internal_private_accessTopLayerDrawContext();
+ return dc->accessRenderTarget(); },
[] (SkSurface* s){
SkBaseDevice* d =
s->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
#include "Benchmark.h"
#include "SkSurface.h"
#include "GrContext.h"
+#include "GrDrawContext.h"
#include "GrRenderTarget.h"
// Wrap some other benchmark to allow specialization to either
void onBlitToScreen(SkCanvas* canvas, int w, int h) override {
// We call copySurface directly on the underlying GPU surfaces for a more efficient blit.
- GrRenderTarget* dst = canvas->internal_private_accessTopLayerRenderTarget();
- SkASSERT(dst);
+ GrDrawContext* dstDC = canvas->internal_private_accessTopLayerDrawContext();
+ SkASSERT(dstDC);
- GrRenderTarget* src = fOffScreen->getCanvas()->internal_private_accessTopLayerRenderTarget();
+ GrDrawContext* srcDC =
+ fOffScreen->getCanvas()->internal_private_accessTopLayerDrawContext();
+ SkASSERT(srcDC);
+ GrRenderTarget* src = srcDC->accessRenderTarget();
SkASSERT(src);
- SkASSERT(dst->getContext() == src->getContext());
+ SkASSERT(canvas->getGrContext() == fOffScreen->getCanvas()->getGrContext());
- dst->getContext()->copySurface(dst, src, SkIRect::MakeWH(w, h), SkIPoint::Make(0, 0));
+ dstDC->copySurface(src, SkIRect::MakeWH(w, h), SkIPoint::Make(0, 0));
}
int fNumSamples;
GrAuditTrail* SkDebugCanvas::getAuditTrail(SkCanvas* canvas) {
GrAuditTrail* at = nullptr;
#if SK_SUPPORT_GPU
- GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
- if (rt) {
- GrContext* ctx = rt->getContext();
- if (ctx) {
- at = ctx->getAuditTrail();
- }
+ GrContext* ctx = canvas->getGrContext();
+ if (ctx) {
+ at = ctx->getAuditTrail();
}
#endif
return at;