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

Add another dollop of sk_sp to SkSpecialImage and SkSpecialSurface

Browse Source 
This is split out of https://codereview.chromium.org/1914883002/ (Refactor drawContext/RenderTarget creation)

GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1913743002

Review URL: https://codereview.chromium.org/1913743002
This commit is contained in:
robertphillips 2016-04-25 12:32:54 -07:00 committed by Commit bot
parent 1eca11659e
commit c91fd3447e
15 changed files with 94 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/core/SkImageFilter.cpp
View File

@ -313,8 +313,7 @@ sk_sp<SkSpecialImage> SkImageFilter::DrawWithFP(GrContext* context,
return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
kNeedNewImageUniqueID_SpecialImage,
dst.get());
std::move(dst));
}
#endif

74
src/core/SkSpecialImage.cpp
View File

@ -32,7 +32,9 @@ public:
virtual GrTexture* onPeekTexture() const { return nullptr; }
virtual GrTexture* onAsTextureRef(GrContext* context) const = 0;
#if SK_SUPPORT_GPU
virtual sk_sp<GrTexture> onAsTextureRef(GrContext* context) const = 0;
#endif
// Delete this entry point ASAP (see skbug.com/4965)
virtual bool getBitmapDeprecated(SkBitmap* result) const = 0;
@ -80,8 +82,9 @@ sk_sp<SkSpecialImage> SkSpecialImage::makeTextureImage(GrContext* context) {
return SkSpecialImage::MakeFromRaster(SkIRect::MakeEmpty(), bmp, &this->props());
}
SkAutoTUnref<GrTexture> resultTex(
GrRefCachedBitmapTexture(context, bmp, GrTextureParams::ClampNoFilter()));
sk_sp<GrTexture> resultTex(GrRefCachedBitmapTexture(context,
bmp,
GrTextureParams::ClampNoFilter()));
if (!resultTex) {
return nullptr;
}
@ -123,10 +126,11 @@ GrContext* SkSpecialImage::getContext() const {
return nullptr;
}
GrTexture* SkSpecialImage::asTextureRef(GrContext* context) const {
#if SK_SUPPORT_GPU
sk_sp<GrTexture> SkSpecialImage::asTextureRef(GrContext* context) const {
return as_SIB(this)->onAsTextureRef(context);
}
#endif
sk_sp<SkSpecialSurface> SkSpecialImage::makeSurface(const SkImageInfo& info) const {
return as_SIB(this)->onMakeSurface(info);
@ -151,13 +155,15 @@ sk_sp<SkImage> SkSpecialImage::makeTightSubset(const SkIRect& subset) const {
sk_sp<SkSpecialImage> SkSpecialImage::internal_fromBM(const SkBitmap& src,
const SkSurfaceProps* props) {
#if SK_SUPPORT_GPU
// Need to test offset case! (see skbug.com/4967)
if (src.getTexture()) {
return SkSpecialImage::MakeFromGpu(src.bounds(),
src.getGenerationID(),
src.getTexture(),
sk_ref_sp(src.getTexture()),
props);
}
#endif
return SkSpecialImage::MakeFromRaster(src.bounds(), src, props);
}
@ -217,13 +223,12 @@ public:
GrTexture* onPeekTexture() const override { return as_IB(fImage)->peekTexture(); }
GrTexture* onAsTextureRef(GrContext* context) const override {
#if SK_SUPPORT_GPU
return as_IB(fImage)->asTextureRef(context, GrTextureParams::ClampNoFilter());
#else
return nullptr;
#endif
sk_sp<GrTexture> onAsTextureRef(GrContext* context) const override {
return sk_sp<GrTexture>(as_IB(fImage)->asTextureRef(context,
GrTextureParams::ClampNoFilter()));
}
#endif
bool getBitmapDeprecated(SkBitmap* result) const override {
#if SK_SUPPORT_GPU
@ -356,15 +361,17 @@ public:
return true;
}
GrTexture* onAsTextureRef(GrContext* context) const override {
#if SK_SUPPORT_GPU
sk_sp<GrTexture> onAsTextureRef(GrContext* context) const override {
if (context) {
return GrRefCachedBitmapTexture(context, fBitmap, GrTextureParams::ClampNoFilter());
return sk_ref_sp(GrRefCachedBitmapTexture(context,
fBitmap,
GrTextureParams::ClampNoFilter()));
}
#endif
return nullptr;
}
#endif
bool getBitmapDeprecated(SkBitmap* result) const override {
*result = fBitmap;
@ -437,10 +444,10 @@ sk_sp<SkSpecialImage> SkSpecialImage::MakeFromPixmap(const SkIRect& subset,
class SkSpecialImage_Gpu : public SkSpecialImage_Base {
public:
SkSpecialImage_Gpu(const SkIRect& subset,
uint32_t uniqueID, GrTexture* tex, SkAlphaType at,
uint32_t uniqueID, sk_sp<GrTexture> tex, SkAlphaType at,
const SkSurfaceProps* props)
: INHERITED(subset, uniqueID, props)
, fTexture(SkRef(tex))
, fTexture(std::move(tex))
, fAlphaType(at)
, fAddedRasterVersionToCache(false) {
}
@ -463,16 +470,16 @@ public:
SkBitmap bm;
GrWrapTextureInBitmap(fTexture,
GrWrapTextureInBitmap(fTexture.get(),
fTexture->width(), fTexture->height(), this->isOpaque(), &bm);
canvas->drawBitmapRect(bm, this->subset(),
dst, paint, SkCanvas::kStrict_SrcRectConstraint);
}
GrTexture* onPeekTexture() const override { return fTexture; }
GrTexture* onPeekTexture() const override { return fTexture.get(); }
GrTexture* onAsTextureRef(GrContext*) const override { return SkRef(fTexture.get()); }
sk_sp<GrTexture> onAsTextureRef(GrContext*) const override { return fTexture; }
bool onGetROPixels(SkBitmap* dst) const override {
if (SkBitmapCache::Find(this->uniqueID(), dst)) {
@ -502,7 +509,7 @@ public:
}
bool getBitmapDeprecated(SkBitmap* result) const override {
const SkImageInfo info = GrMakeInfoFromTexture(fTexture,
const SkImageInfo info = GrMakeInfoFromTexture(fTexture.get(),
this->width(), this->height(),
this->isOpaque());
if (!result->setInfo(info)) {
@ -511,7 +518,7 @@ public:
const SkImageInfo prInfo = info.makeWH(fTexture->width(), fTexture->height());
SkAutoTUnref<SkGrPixelRef> pixelRef(new SkGrPixelRef(prInfo, fTexture));
SkAutoTUnref<SkGrPixelRef> pixelRef(new SkGrPixelRef(prInfo, fTexture.get()));
result->setPixelRef(pixelRef, this->subset().fLeft, this->subset().fTop);
return true;
}
@ -542,7 +549,7 @@ public:
// The existing GrTexture is already tight so reuse it in the SkImage
return sk_make_sp<SkImage_Gpu>(fTexture->width(), fTexture->height(),
kNeedNewImageUniqueID,
fAlphaType, fTexture, SkBudgeted::kYes);
fAlphaType, fTexture.get(), SkBudgeted::kYes);
}
GrContext* ctx = fTexture->getContext();
@ -550,14 +557,13 @@ public:
desc.fWidth = subset.width();
desc.fHeight = subset.height();
SkAutoTUnref<GrTexture> subTx(ctx->textureProvider()->createTexture(desc,
SkBudgeted::kYes));
sk_sp<GrTexture> subTx(ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes));
if (!subTx) {
return nullptr;
}
ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0));
ctx->copySurface(subTx.get(), fTexture.get(), subset, SkIPoint::Make(0, 0));
return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID,
fAlphaType, subTx, SkBudgeted::kYes);
fAlphaType, subTx.get(), SkBudgeted::kYes);
}
sk_sp<SkSurface> onMakeTightSurface(const SkImageInfo& info) const override {
@ -565,7 +571,7 @@ public:
}
private:
SkAutoTUnref<GrTexture> fTexture;
sk_sp<GrTexture> fTexture;
const SkAlphaType fAlphaType;
mutable SkAtomic<bool> fAddedRasterVersionToCache;
@ -574,21 +580,11 @@ private:
sk_sp<SkSpecialImage> SkSpecialImage::MakeFromGpu(const SkIRect& subset,
uint32_t uniqueID,
GrTexture* tex,
sk_sp<GrTexture> tex,
const SkSurfaceProps* props,
SkAlphaType at) {
SkASSERT(rect_fits(subset, tex->width(), tex->height()));
return sk_make_sp<SkSpecialImage_Gpu>(subset, uniqueID, tex, at, props);
}
#else
sk_sp<SkSpecialImage> SkSpecialImage::MakeFromGpu(const SkIRect& subset,
uint32_t uniqueID,
GrTexture* tex,
const SkSurfaceProps* props,
SkAlphaType at) {
return nullptr;
return sk_make_sp<SkSpecialImage_Gpu>(subset, uniqueID, std::move(tex), at, props);
}
#endif

8
src/core/SkSpecialImage.h
View File

@ -73,11 +73,13 @@ public:
static sk_sp<SkSpecialImage> MakeFromRaster(const SkIRect& subset,
const SkBitmap&,
const SkSurfaceProps* = nullptr);
#if SK_SUPPORT_GPU
static sk_sp<SkSpecialImage> MakeFromGpu(const SkIRect& subset,
uint32_t uniqueID,
GrTexture*,
sk_sp<GrTexture>,
const SkSurfaceProps* = nullptr,
SkAlphaType at = kPremul_SkAlphaType);
#endif
static sk_sp<SkSpecialImage> MakeFromPixmap(const SkIRect& subset,
const SkPixmap&,
RasterReleaseProc,
@ -123,11 +125,13 @@ public:
*/
GrContext* getContext() const;
#if SK_SUPPORT_GPU
/**
* Regardless of the underlying backing store, return the contents as a GrTexture.
* The active portion of the texture can be retrieved via 'subset'.
*/
GrTexture* asTextureRef(GrContext*) const;
sk_sp<GrTexture> asTextureRef(GrContext*) const;
#endif
// TODO: hide this whe the imagefilter all have a consistent draw path (see skbug.com/5063)
/**

32
src/core/SkSpecialSurface.cpp
View File

@ -112,11 +112,11 @@ sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRaster(const SkImageInfo& info,
class SkSpecialSurface_Gpu : public SkSpecialSurface_Base {
public:
SkSpecialSurface_Gpu(GrTexture* texture,
SkSpecialSurface_Gpu(sk_sp<GrTexture> texture,
const SkIRect& subset,
const SkSurfaceProps* props)
: INHERITED(subset, props)
, fTexture(SkRef(texture)) {
, fTexture(std::move(texture)) {
SkASSERT(fTexture->asRenderTarget());
@ -133,25 +133,27 @@ public:
~SkSpecialSurface_Gpu() override { }
sk_sp<SkSpecialImage> onMakeImageSnapshot() override {
// Note: we are intentionally zeroing out 'fTexture' here
return SkSpecialImage::MakeFromGpu(this->subset(),
kNeedNewImageUniqueID_SpecialImage, fTexture,
kNeedNewImageUniqueID_SpecialImage,
std::move(fTexture),
&this->props());
}
private:
SkAutoTUnref<GrTexture> fTexture;
sk_sp<GrTexture> fTexture;
typedef SkSpecialSurface_Base INHERITED;
};
sk_sp<SkSpecialSurface> SkSpecialSurface::MakeFromTexture(const SkIRect& subset,
GrTexture* texture,
sk_sp<GrTexture> texture,
const SkSurfaceProps* props) {
if (!texture->asRenderTarget()) {
return nullptr;
}
return sk_make_sp<SkSpecialSurface_Gpu>(texture, subset, props);
return sk_make_sp<SkSpecialSurface_Gpu>(std::move(texture), subset, props);
}
sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRenderTarget(GrContext* context,
@ -161,28 +163,14 @@ sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRenderTarget(GrContext* context,
return nullptr;
}
SkAutoTUnref<GrTexture> temp(context->textureProvider()->createApproxTexture(desc));
sk_sp<GrTexture> temp(context->textureProvider()->createApproxTexture(desc));
if (!temp) {
return nullptr;
}
const SkIRect subset = SkIRect::MakeWH(desc.fWidth, desc.fHeight);
return sk_make_sp<SkSpecialSurface_Gpu>(temp, subset, props);
}
#else
sk_sp<SkSpecialSurface> SkSpecialSurface::MakeFromTexture(const SkIRect& subset,
GrTexture*,
const SkSurfaceProps*) {
return nullptr;
}
sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRenderTarget(GrContext* context,
const GrSurfaceDesc& desc,
const SkSurfaceProps* props) {
return nullptr;
return sk_make_sp<SkSpecialSurface_Gpu>(std::move(temp), subset, props);
}
#endif

4
src/core/SkSpecialSurface.h
View File

@ -50,10 +50,11 @@ public:
*/
sk_sp<SkSpecialImage> makeImageSnapshot();
#if SK_SUPPORT_GPU
/**
* Use an existing (renderTarget-capable) GrTexture as the backing store.
*/
static sk_sp<SkSpecialSurface> MakeFromTexture(const SkIRect& subset, GrTexture*,
static sk_sp<SkSpecialSurface> MakeFromTexture(const SkIRect& subset, sk_sp<GrTexture>,
const SkSurfaceProps* = nullptr);
/**
@ -62,6 +63,7 @@ public:
*/
static sk_sp<SkSpecialSurface> MakeRenderTarget(GrContext*, const GrSurfaceDesc&,
const SkSurfaceProps* = nullptr);
#endif
/**
* Use and existing SkBitmap as the backing store.

20
src/effects/SkBlurImageFilter.cpp
View File

@ -106,7 +106,7 @@ sk_sp<SkSpecialImage> SkBlurImageFilter::onFilterImage(SkSpecialImage* source,
#if SK_SUPPORT_GPU
if (source->isTextureBacked()) {
GrContext* context = source->getContext();
SkAutoTUnref<GrTexture> inputTexture(input->asTextureRef(context));
sk_sp<GrTexture> inputTexture(input->asTextureRef(context));
SkASSERT(inputTexture);
if (0 == sigma.x() && 0 == sigma.y()) {
@ -121,21 +121,21 @@ sk_sp<SkSpecialImage> SkBlurImageFilter::onFilterImage(SkSpecialImage* source,
inputBounds.offset(-inputOffset);
dstBounds.offset(-inputOffset);
SkRect inputBoundsF(SkRect::Make(inputBounds));
SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(context,
inputTexture,
false,
source->props().isGammaCorrect(),
SkRect::Make(dstBounds),
&inputBoundsF,
sigma.x(),
sigma.y()));
sk_sp<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(context,
inputTexture.get(),
false,
source->props().isGammaCorrect(),
SkRect::Make(dstBounds),
&inputBoundsF,
sigma.x(),
sigma.y()));
if (!tex) {
return nullptr;
}
return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(dstBounds.width(), dstBounds.height()),
kNeedNewImageUniqueID_SpecialImage,
tex, &source->props());
std::move(tex), &source->props());
}
#endif

4
src/effects/SkDisplacementMapEffect.cpp
View File

@ -323,7 +323,7 @@ sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* sou
desc.fHeight = bounds.height();
desc.fConfig = kSkia8888_GrPixelConfig;
SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
sk_sp<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
if (!dst) {
return nullptr;
}
@ -357,7 +357,7 @@ sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* sou
offset->fY = bounds.top();
return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
kNeedNewImageUniqueID_SpecialImage,
dst);
std::move(dst));
}
#endif

2
src/effects/SkLightingImageFilter.cpp
View File

@ -462,7 +462,7 @@ sk_sp<SkSpecialImage> SkLightingImageFilterInternal::filterImageGPU(SkSpecialIma
return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(offsetBounds.width(), offsetBounds.height()),
kNeedNewImageUniqueID_SpecialImage,
dst.get());
std::move(dst));
}
#endif

8
src/effects/SkMorphologyImageFilter.cpp
View File

@ -474,7 +474,7 @@ static sk_sp<SkSpecialImage> apply_morphology(GrContext* context,
const SkIRect& rect,
GrMorphologyEffect::MorphologyType morphType,
SkISize radius) {
SkAutoTUnref<GrTexture> srcTexture(input->asTextureRef(context));
sk_sp<GrTexture> srcTexture(input->asTextureRef(context));
SkASSERT(srcTexture);
// setup new clip
@ -502,7 +502,7 @@ static sk_sp<SkSpecialImage> apply_morphology(GrContext* context,
return nullptr;
}
apply_morphology_pass(dstDrawContext, clip, srcTexture,
apply_morphology_pass(dstDrawContext, clip, srcTexture.get(),
srcRect, dstRect, radius.fWidth, morphType,
Gr1DKernelEffect::kX_Direction);
SkIRect clearRect = SkIRect::MakeXYWH(dstRect.fLeft, dstRect.fBottom,
@ -526,7 +526,7 @@ static sk_sp<SkSpecialImage> apply_morphology(GrContext* context,
return nullptr;
}
apply_morphology_pass(dstDrawContext, clip, srcTexture,
apply_morphology_pass(dstDrawContext, clip, srcTexture.get(),
srcRect, dstRect, radius.fHeight, morphType,
Gr1DKernelEffect::kY_Direction);
@ -535,7 +535,7 @@ static sk_sp<SkSpecialImage> apply_morphology(GrContext* context,
return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(rect.width(), rect.height()),
kNeedNewImageUniqueID_SpecialImage,
srcTexture, &input->props());
std::move(srcTexture), &input->props());
}
#endif

8
src/effects/SkXfermodeImageFilter.cpp
View File

@ -169,11 +169,11 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter::filterImageGPU(SkSpecialImage* sour
sk_sp<GrTexture> backgroundTex, foregroundTex;
if (background) {
backgroundTex.reset(background->asTextureRef(context));
backgroundTex = background->asTextureRef(context);
}
if (foreground) {
foregroundTex.reset(foreground->asTextureRef(context));
foregroundTex = foreground->asTextureRef(context);
}
GrSurfaceDesc desc;
@ -181,7 +181,7 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter::filterImageGPU(SkSpecialImage* sour
desc.fWidth = bounds.width();
desc.fHeight = bounds.height();
desc.fConfig = kSkia8888_GrPixelConfig;
SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
sk_sp<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
if (!dst) {
return nullptr;
}
@ -259,7 +259,7 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter::filterImageGPU(SkSpecialImage* sour
return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
kNeedNewImageUniqueID_SpecialImage,
dst.get());
std::move(dst));
}
#endif

6
src/gpu/GrLayerHoister.cpp
View File

@ -303,7 +303,7 @@ void GrLayerHoister::FilterLayer(GrContext* context,
const SkIRect subset = SkIRect::MakeWH(layer->texture()->width(), layer->texture()->height());
sk_sp<SkSpecialImage> img(SkSpecialImage::MakeFromGpu(subset,
kNeedNewImageUniqueID_SpecialImage,
layer->texture(),
sk_ref_sp(layer->texture()),
props));
SkIPoint offset = SkIPoint::Make(0, 0);
@ -316,8 +316,8 @@ void GrLayerHoister::FilterLayer(GrContext* context,
}
SkASSERT(result->isTextureBacked());
SkAutoTUnref<GrTexture> texture(result->asTextureRef(context));
layer->setTexture(texture, result->subset(), false);
sk_sp<GrTexture> texture(result->asTextureRef(context));
layer->setTexture(texture.get(), result->subset(), false);
layer->setOffset(offset);
}

2
tests/ImageFilterCacheTest.cpp
View File

@ -213,7 +213,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter,
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_GPUBacked, reporter, ctxInfo) {
SkAutoTUnref<GrTexture> srcTexture(create_texture(ctxInfo.fGrContext));
sk_sp<GrTexture> srcTexture(create_texture(ctxInfo.fGrContext));
if (!srcTexture) {
return;
}

5
tests/ImageFilterTest.cpp
View File

@ -368,6 +368,7 @@ static sk_sp<SkImageFilter> make_blue(sk_sp<SkImageFilter> input,
}
static sk_sp<SkSpecialSurface> create_empty_special_surface(GrContext* context, int widthHeight) {
#if SK_SUPPORT_GPU
if (context) {
GrSurfaceDesc desc;
desc.fConfig = kSkia8888_GrPixelConfig;
@ -375,7 +376,9 @@ static sk_sp<SkSpecialSurface> create_empty_special_surface(GrContext* context,
desc.fWidth = widthHeight;
desc.fHeight = widthHeight;
return SkSpecialSurface::MakeRenderTarget(context, desc);
} else {
} else
#endif
{
const SkImageInfo info = SkImageInfo::MakeN32(widthHeight, widthHeight,
kOpaque_SkAlphaType);
return SkSpecialSurface::MakeRaster(info);

16
tests/SpecialImageTest.cpp
View File

@ -243,10 +243,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo)
desc.fWidth = kFullSize;
desc.fHeight = kFullSize;
SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc,
SkBudgeted::kNo,
bm.getPixels(),
0));
sk_sp<GrTexture> texture(context->textureProvider()->createTexture(desc,
SkBudgeted::kNo,
bm.getPixels(),
0));
if (!texture) {
return;
}
@ -255,7 +255,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo)
SkIRect::MakeWH(kFullSize,
kFullSize),
kNeedNewImageUniqueID_SpecialImage,
texture));
std::move(texture)));
{
sk_sp<SkSpecialImage> fromGPU(gpuImage->makeTextureImage(context));
@ -281,9 +281,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
desc.fWidth = kFullSize;
desc.fHeight = kFullSize;
SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc,
SkBudgeted::kNo,
bm.getPixels(), 0));
sk_sp<GrTexture> texture(context->textureProvider()->createTexture(desc,
SkBudgeted::kNo,
bm.getPixels(), 0));
if (!texture) {
return;
}

4
tests/SpecialSurfaceTest.cpp
View File

@ -98,12 +98,12 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SpecialSurface_Gpu2, reporter, ctxInfo) {
desc.fWidth = kFullSize;
desc.fHeight = kFullSize;
SkAutoTUnref<GrTexture> temp(ctxInfo.fGrContext->textureProvider()->createApproxTexture(desc));
sk_sp<GrTexture> temp(ctxInfo.fGrContext->textureProvider()->createApproxTexture(desc));
SkASSERT_RELEASE(temp);
const SkIRect subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
sk_sp<SkSpecialSurface> surf(SkSpecialSurface::MakeFromTexture(subset, temp));
sk_sp<SkSpecialSurface> surf(SkSpecialSurface::MakeFromTexture(subset, std::move(temp)));
test_surface(surf, reporter, kPad);