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

Revert of skia: Add support for CHROMIUM_image backed textures. (patchset #14 id:260001 of https://codereview.chromium.org/1623653002/ )

Browse Source 
Reason for revert:
Seems to causing the DEPS roll to fail:

   https://codereview.chromium.org/1668293002/

Original issue's description:
> skia: Add support for CHROMIUM_image backed textures.
>
> I created a new abstract base class TextureStorageAllocator that consumers of
> Skia can subclass and pass back to Skia. When a surface is created with a
> pointer to a TextureStorageAllocator, any textures it creates, or that are
> derived from the original surface, will allocate and deallocate storage using
> the methods on TextureStorageAllocator.
>
> BUG=https://code.google.com/p/chromium/issues/detail?id=579664
> GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1623653002
>
> Committed: https://skia.googlesource.com/skia/+/92098e691f10a010e7421125ba4d44c02506bb55

TBR=bsalomon@chromium.org,cblume@chromium.org,bsalomon@google.com,robertphillips@google.com,egdaniel@google.com,reed@google.com,erikchen@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=https://code.google.com/p/chromium/issues/detail?id=579664

Review URL: https://codereview.chromium.org/1669213002
This commit is contained in:
jcgregorio 2016-02-04 19:51:25 -08:00 committed by Commit bot
parent a87d6de6a5
commit e7d7f90b59
12 changed files with 80 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/core/SkSurface.h
View File

@ -120,16 +120,12 @@ public:
/**
* Return a new surface whose contents will be drawn to an offscreen
* render target, allocated by the surface.
*
* The GrTextureStorageAllocator will be reused if SkImage snapshots create
* additional textures.
*/
static SkSurface* NewRenderTarget(
GrContext*, Budgeted, const SkImageInfo&, int sampleCount, const SkSurfaceProps* = NULL,
GrTextureStorageAllocator = GrTextureStorageAllocator());
static SkSurface* NewRenderTarget(GrContext*, Budgeted, const SkImageInfo&, int sampleCount,
const SkSurfaceProps* = NULL);
static SkSurface* NewRenderTarget(GrContext* gr, Budgeted b, const SkImageInfo& info) {
return NewRenderTarget(gr, b, info, 0);
return NewRenderTarget(gr, b, info, 0, NULL);
}
int width() const { return fWidth; }

64
include/gpu/GrTypes.h
View File

@ -409,9 +409,6 @@ enum GrSurfaceFlags {
GR_MAKE_BITFIELD_OPS(GrSurfaceFlags)
// opaque type for 3D API object handles
typedef intptr_t GrBackendObject;
/**
* Some textures will be stored such that the upper and left edges of the content meet at the
* the origin (in texture coord space) and for other textures the lower and left edges meet at
@ -425,58 +422,6 @@ enum GrSurfaceOrigin {
kBottomLeft_GrSurfaceOrigin,
};
/**
* An container of function pointers which consumers of Skia can fill in and
* pass to Skia. Skia will use these function pointers in place of its backend
* API texture creation function. Either all of the function pointers should be
* filled in, or they should all be nullptr.
*/
struct GrTextureStorageAllocator {
GrTextureStorageAllocator()
: fAllocateTextureStorage(nullptr)
, fDeallocateTextureStorage(nullptr) {
}
enum class Result {
kSucceededAndUploaded,
kSucceededWithoutUpload,
kFailed
};
typedef Result (*AllocateTextureStorageProc)(
void* ctx, GrBackendObject texture, unsigned width,
unsigned height, GrPixelConfig config, const void* srcData, GrSurfaceOrigin);
typedef void (*DeallocateTextureStorageProc)(void* ctx, GrBackendObject texture);
/*
* Generates and binds a texture to |textureStorageTarget()|. Allocates
* storage for the texture.
*
* In OpenGL, the MIN and MAX filters for the created texture must be
* GL_LINEAR. The WRAP_S and WRAP_T must be GL_CLAMP_TO_EDGE.
*
* If |srcData| is not nullptr, then the implementation of this function
* may attempt to upload the data into the texture. On successful upload,
* or if |srcData| is nullptr, returns kSucceededAndUploaded.
*/
AllocateTextureStorageProc fAllocateTextureStorage;
/*
* Deallocate the storage for the given texture.
*
* Skia does not always destroy its outstanding textures. See
* GrContext::abandonContext() for more details. The consumer of Skia is
* responsible for making sure that all textures are destroyed, even if this
* callback is not invoked.
*/
DeallocateTextureStorageProc fDeallocateTextureStorage;
/*
* The context to use when invoking fAllocateTextureStorage and
* fDeallocateTextureStorage.
*/
void* fCtx;
};
/**
* Describes a surface to be created.
*/
@ -509,12 +454,6 @@ struct GrSurfaceDesc {
* max supported count.
*/
int fSampleCnt;
/**
* A custom platform-specific allocator to use in place of the backend APIs
* usual texture creation method (e.g. TexImage2D in OpenGL).
*/
GrTextureStorageAllocator fTextureStorageAllocator;
};
// Legacy alias
@ -530,6 +469,9 @@ enum GrClipType {
///////////////////////////////////////////////////////////////////////////////
// opaque type for 3D API object handles
typedef intptr_t GrBackendObject;
/** Ownership rules for external GPU resources imported into Skia. */
enum GrWrapOwnership {

3
src/gpu/GrTexture.cpp
View File

@ -85,8 +85,7 @@ GrTexture::GrTexture(GrGpu* gpu, LifeCycle lifeCycle, const GrSurfaceDesc& desc)
: INHERITED(gpu, lifeCycle, desc)
, fMipMapsStatus(kNotAllocated_MipMapsStatus) {
if (!this->isExternal() && !GrPixelConfigIsCompressed(desc.fConfig) &&
!desc.fTextureStorageAllocator.fAllocateTextureStorage) {
if (!this->isExternal() && !GrPixelConfigIsCompressed(desc.fConfig)) {
GrScratchKey key;
GrTexturePriv::ComputeScratchKey(desc, &key);
this->setScratchKey(key);

3
src/gpu/GrTextureProvider.cpp
View File

@ -39,8 +39,7 @@ GrTexture* GrTextureProvider::createTexture(const GrSurfaceDesc& desc, bool budg
!fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
return nullptr;
}
if (!GrPixelConfigIsCompressed(desc.fConfig) &&
!desc.fTextureStorageAllocator.fAllocateTextureStorage) {
if (!GrPixelConfigIsCompressed(desc.fConfig)) {
static const uint32_t kFlags = kExact_ScratchTextureFlag |
kNoCreate_ScratchTextureFlag;
if (GrTexture* texture = this->refScratchTexture(desc, kFlags)) {

17
src/gpu/SkGpuDevice.cpp
View File

@ -156,15 +156,13 @@ SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, int width, int height,
SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkSurface::Budgeted budgeted,
const SkImageInfo& info, int sampleCount,
const SkSurfaceProps* props, InitContents init,
GrTextureStorageAllocator customAllocator) {
const SkSurfaceProps* props, InitContents init) {
unsigned flags;
if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
return nullptr;
}
SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(
context, budgeted, info, sampleCount, customAllocator));
SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(context, budgeted, info, sampleCount));
if (nullptr == rt) {
return nullptr;
}
@ -189,9 +187,8 @@ SkGpuDevice::SkGpuDevice(GrRenderTarget* rt, int width, int height,
fDrawContext.reset(this->context()->drawContext(rt, &this->surfaceProps()));
}
GrRenderTarget* SkGpuDevice::CreateRenderTarget(
GrContext* context, SkSurface::Budgeted budgeted, const SkImageInfo& origInfo,
int sampleCount, GrTextureStorageAllocator textureStorageAllocator) {
GrRenderTarget* SkGpuDevice::CreateRenderTarget(GrContext* context, SkSurface::Budgeted budgeted,
const SkImageInfo& origInfo, int sampleCount) {
if (kUnknown_SkColorType == origInfo.colorType() ||
origInfo.width() < 0 || origInfo.height() < 0) {
return nullptr;
@ -220,7 +217,6 @@ GrRenderTarget* SkGpuDevice::CreateRenderTarget(
desc.fHeight = info.height();
desc.fConfig = SkImageInfo2GrPixelConfig(info);
desc.fSampleCnt = sampleCount;
desc.fTextureStorageAllocator = textureStorageAllocator;
GrTexture* texture = context->textureProvider()->createTexture(
desc, SkToBool(budgeted), nullptr, 0);
if (nullptr == texture) {
@ -340,8 +336,7 @@ void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) {
: SkSurface::kNo_Budgeted;
SkAutoTUnref<GrRenderTarget> newRT(CreateRenderTarget(
this->context(), budgeted, this->imageInfo(), fRenderTarget->desc().fSampleCnt,
fRenderTarget->desc().fTextureStorageAllocator));
this->context(), budgeted, this->imageInfo(), fRenderTarget->desc().fSampleCnt));
if (nullptr == newRT) {
return;
@ -1493,7 +1488,7 @@ void SkGpuDevice::drawProducerNine(const SkDraw& draw, GrTextureProducer* produc
SkRect srcR, dstR;
while (iter.next(&srcR, &dstR)) {
this->drawTextureProducer(producer, &srcR, &dstR, SkCanvas::kStrict_SrcRectConstraint,
this->drawTextureProducer(producer, &srcR, &dstR, SkCanvas::kStrict_SrcRectConstraint,
*draw.fMatrix, fClip, paint);
}
return;

6
src/gpu/SkGpuDevice.h
View File

@ -18,7 +18,6 @@
#include "GrDrawContext.h"
#include "GrContext.h"
#include "GrSurfacePriv.h"
#include "GrTypes.h"
class GrAccelData;
class GrTextureProducer;
@ -53,8 +52,7 @@ public:
* the resource cache budget. On failure, returns nullptr.
*/
static SkGpuDevice* Create(GrContext*, SkSurface::Budgeted, const SkImageInfo&,
int sampleCount, const SkSurfaceProps*,
InitContents, GrTextureStorageAllocator = GrTextureStorageAllocator());
int sampleCount, const SkSurfaceProps*, InitContents);
~SkGpuDevice() override {}
@ -258,7 +256,7 @@ private:
bool drawDashLine(const SkPoint pts[2], const SkPaint& paint);
static GrRenderTarget* CreateRenderTarget(GrContext*, SkSurface::Budgeted, const SkImageInfo&,
int sampleCount, GrTextureStorageAllocator);
int sampleCount);
friend class GrAtlasTextContext;
friend class SkSurface_Gpu; // for access to surfaceProps

1
src/gpu/SkGrPixelRef.cpp
View File

@ -76,7 +76,6 @@ static SkGrPixelRef* copy_to_new_texture_pixelref(GrTexture* texture, SkColorTyp
}
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fConfig = SkImageInfo2GrPixelConfig(dstCT, kPremul_SkAlphaType, dstPT);
desc.fTextureStorageAllocator = texture->desc().fTextureStorageAllocator;
GrTexture* dst = context->textureProvider()->createTexture(desc, false, nullptr, 0);
if (nullptr == dst) {

170
src/gpu/gl/GrGLGpu.cpp
View File

@ -755,11 +755,8 @@ bool GrGLGpu::onWritePixels(GrSurface* surface,
success = this->uploadCompressedTexData(glTex->desc(), glTex->target(), buffer,
kWrite_UploadType, left, top, width, height);
} else {
success = this->uploadTexData(
glTex->desc(),
reinterpret_cast<GrGLTextureInfo*>(glTex->getTextureHandle()),
kWrite_UploadType, left, top, width, height, config, buffer,
rowBytes);
success = this->uploadTexData(glTex->desc(), glTex->target(), kWrite_UploadType,
left, top, width, height, config, buffer, rowBytes);
}
if (success) {
@ -796,11 +793,8 @@ bool GrGLGpu::onTransferPixels(GrSurface* surface,
GL_CALL(BindBuffer(glBuffer->bufferType(), glBuffer->bufferID()));
bool success = false;
success = this->uploadTexData(
glTex->desc(),
reinterpret_cast<GrGLTextureInfo*>(glTex->getTextureHandle()),
kTransfer_UploadType, left, top, width, height, config, buffer,
rowBytes);
success = this->uploadTexData(glTex->desc(), glTex->target(), kTransfer_UploadType,
left, top, width, height, config, buffer, rowBytes);
if (success) {
glTex->texturePriv().dirtyMipMaps(true);
@ -841,7 +835,7 @@ static inline GrGLenum check_alloc_error(const GrSurfaceDesc& desc,
}
bool GrGLGpu::uploadTexData(const GrSurfaceDesc& desc,
GrGLTextureInfo* info,
GrGLenum target,
UploadType uploadType,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
@ -938,30 +932,20 @@ bool GrGLGpu::uploadTexData(const GrSurfaceDesc& desc,
!(0 == left && 0 == top && desc.fWidth == width && desc.fHeight == height)) {
succeeded = false;
} else {
if (desc.fTextureStorageAllocator.fAllocateTextureStorage) {
if (dataOrOffset) {
GL_CALL(TexSubImage2D(info->fTarget,
0, // level
left, top,
width, height,
externalFormat, externalType, dataOrOffset));
}
} else {
CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
GL_ALLOC_CALL(this->glInterface(), TexImage2D(
info->fTarget, 0, internalFormat, desc.fWidth, desc.fHeight, 0, externalFormat,
externalType, dataOrOffset));
GrGLenum error = check_alloc_error(desc, this->glInterface());
if (error != GR_GL_NO_ERROR) {
succeeded = false;
}
}
CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
GL_ALLOC_CALL(this->glInterface(), TexImage2D(target, 0, internalFormat, desc.fWidth,
desc.fHeight, 0, externalFormat,
externalType, dataOrOffset));
GrGLenum error = check_alloc_error(desc, this->glInterface());
if (error != GR_GL_NO_ERROR) {
succeeded = false;
}
}
} else {
if (swFlipY || glFlipY) {
top = desc.fHeight - (top + height);
}
GL_CALL(TexSubImage2D(info->fTarget,
GL_CALL(TexSubImage2D(target,
0, // level
left, top,
width, height,
@ -1224,10 +1208,52 @@ GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc,
bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
GrGLTexture::IDDesc idDesc;
idDesc.fInfo.fID = 0;
GL_CALL(GenTextures(1, &idDesc.fInfo.fID));
idDesc.fLifeCycle = lifeCycle;
// We only support GL_TEXTURE_2D at the moment.
idDesc.fInfo.fTarget = GR_GL_TEXTURE_2D;
if (!idDesc.fInfo.fID) {
return return_null_texture();
}
this->setScratchTextureUnit();
GL_CALL(BindTexture(idDesc.fInfo.fTarget, idDesc.fInfo.fID));
if (renderTarget && this->glCaps().textureUsageSupport()) {
// provides a hint about how this texture will be used
GL_CALL(TexParameteri(idDesc.fInfo.fTarget,
GR_GL_TEXTURE_USAGE,
GR_GL_FRAMEBUFFER_ATTACHMENT));
}
// Some drivers like to know filter/wrap before seeing glTexImage2D. Some
// drivers have a bug where an FBO won't be complete if it includes a
// texture that is not mipmap complete (considering the filter in use).
GrGLTexture::TexParams initialTexParams;
if (!this->createTextureImpl(desc, &idDesc.fInfo, renderTarget, srcData,
&initialTexParams, rowBytes)) {
// we only set a subset here so invalidate first
initialTexParams.invalidate();
initialTexParams.fMinFilter = GR_GL_NEAREST;
initialTexParams.fMagFilter = GR_GL_NEAREST;
initialTexParams.fWrapS = GR_GL_CLAMP_TO_EDGE;
initialTexParams.fWrapT = GR_GL_CLAMP_TO_EDGE;
GL_CALL(TexParameteri(idDesc.fInfo.fTarget,
GR_GL_TEXTURE_MAG_FILTER,
initialTexParams.fMagFilter));
GL_CALL(TexParameteri(idDesc.fInfo.fTarget,
GR_GL_TEXTURE_MIN_FILTER,
initialTexParams.fMinFilter));
GL_CALL(TexParameteri(idDesc.fInfo.fTarget,
GR_GL_TEXTURE_WRAP_S,
initialTexParams.fWrapS));
GL_CALL(TexParameteri(idDesc.fInfo.fTarget,
GR_GL_TEXTURE_WRAP_T,
initialTexParams.fWrapT));
if (!this->uploadTexData(desc, idDesc.fInfo.fTarget, kNewTexture_UploadType, 0, 0,
desc.fWidth, desc.fHeight,
desc.fConfig, srcData, rowBytes)) {
GL_CALL(DeleteTextures(1, &idDesc.fInfo.fID));
return return_null_texture();
}
@ -1450,86 +1476,6 @@ int GrGLGpu::getCompatibleStencilIndex(GrPixelConfig config) {
return this->glCaps().getStencilFormatIndexForConfig(config);
}
bool GrGLGpu::createTextureImpl(const GrSurfaceDesc& desc, GrGLTextureInfo* info,
bool renderTarget, const void* srcData,
GrGLTexture::TexParams* initialTexParams, size_t rowBytes) {
// Some drivers like to know filter/wrap before seeing glTexImage2D. Some
// drivers have a bug where an FBO won't be complete if it includes a
// texture that is not mipmap complete (considering the filter in use).
// we only set a subset here so invalidate first
initialTexParams->invalidate();
initialTexParams->fMinFilter = GR_GL_NEAREST;
initialTexParams->fMagFilter = GR_GL_NEAREST;
initialTexParams->fWrapS = GR_GL_CLAMP_TO_EDGE;
initialTexParams->fWrapT = GR_GL_CLAMP_TO_EDGE;
if (desc.fTextureStorageAllocator.fAllocateTextureStorage) {
return this->createTextureExternalAllocatorImpl(desc, info, srcData, rowBytes);
}
info->fID = 0;
info->fTarget = GR_GL_TEXTURE_2D;
GL_CALL(GenTextures(1, &(info->fID)));
if (!info->fID) {
return false;
}
this->setScratchTextureUnit();
GL_CALL(BindTexture(info->fTarget, info->fID));
if (renderTarget && this->glCaps().textureUsageSupport()) {
// provides a hint about how this texture will be used
GL_CALL(TexParameteri(info->fTarget,
GR_GL_TEXTURE_USAGE,
GR_GL_FRAMEBUFFER_ATTACHMENT));
}
GL_CALL(TexParameteri(info->fTarget,
GR_GL_TEXTURE_MAG_FILTER,
initialTexParams->fMagFilter));
GL_CALL(TexParameteri(info->fTarget,
GR_GL_TEXTURE_MIN_FILTER,
initialTexParams->fMinFilter));
GL_CALL(TexParameteri(info->fTarget,
GR_GL_TEXTURE_WRAP_S,
initialTexParams->fWrapS));
GL_CALL(TexParameteri(info->fTarget,
GR_GL_TEXTURE_WRAP_T,
initialTexParams->fWrapT));
if (!this->uploadTexData(desc, info, kNewTexture_UploadType, 0, 0,
desc.fWidth, desc.fHeight,
desc.fConfig, srcData, rowBytes)) {
GL_CALL(DeleteTextures(1, &(info->fID)));
return false;
}
return true;
}
bool GrGLGpu::createTextureExternalAllocatorImpl(
const GrSurfaceDesc& desc, GrGLTextureInfo* info, const void* srcData, size_t rowBytes) {
switch (desc.fTextureStorageAllocator.fAllocateTextureStorage(
desc.fTextureStorageAllocator.fCtx, reinterpret_cast<GrBackendObject>(info),
desc.fWidth, desc.fHeight, desc.fConfig, srcData, desc.fOrigin)) {
case GrTextureStorageAllocator::Result::kSucceededAndUploaded:
return true;
case GrTextureStorageAllocator::Result::kFailed:
return false;
case GrTextureStorageAllocator::Result::kSucceededWithoutUpload:
break;
}
if (!this->uploadTexData(desc, info, kNewTexture_UploadType, 0, 0,
desc.fWidth, desc.fHeight,
desc.fConfig, srcData, rowBytes)) {
desc.fTextureStorageAllocator.fDeallocateTextureStorage(
desc.fTextureStorageAllocator.fCtx, reinterpret_cast<GrBackendObject>(info));
return false;
}
return true;
}
GrStencilAttachment* GrGLGpu::createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
int width,
int height) {

14
src/gpu/gl/GrGLGpu.h
View File

@ -159,18 +159,6 @@ private:
// compatible stencil format, or negative if there is no compatible stencil format.
int getCompatibleStencilIndex(GrPixelConfig config);
// If |desc.fTextureStorageAllocator| exists, use that to create the
// texture. Otherwise, create the texture directly.
// Returns whether the texture is successfully created. On success, the
// result is stored in |info|.
// The texture is populated with |srcData|, if it exists.
// The texture parameters are cached in |initialTexParams|.
bool createTextureImpl(const GrSurfaceDesc& desc, GrGLTextureInfo* info,
bool renderTarget, const void* srcData,
GrGLTexture::TexParams* initialTexParams, size_t rowBytes);
bool createTextureExternalAllocatorImpl(const GrSurfaceDesc& desc, GrGLTextureInfo* info,
const void* srcData, size_t rowBytes);
void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) override;
void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override;
@ -331,7 +319,7 @@ private:
kTransfer_UploadType, // we are using a transfer buffer to copy data
};
bool uploadTexData(const GrSurfaceDesc& desc,
GrGLTextureInfo* info,
GrGLenum target,
UploadType uploadType,
int left, int top, int width, int height,
GrPixelConfig dataConfig,

8
src/gpu/gl/GrGLTexture.cpp
View File

@ -37,13 +37,7 @@ void GrGLTexture::init(const GrSurfaceDesc& desc, const IDDesc& idDesc) {
void GrGLTexture::onRelease() {
if (fInfo.fID) {
if (GrGpuResource::kBorrowed_LifeCycle != fTextureIDLifecycle) {
if (this->desc().fTextureStorageAllocator.fDeallocateTextureStorage) {
this->desc().fTextureStorageAllocator.fDeallocateTextureStorage(
this->desc().fTextureStorageAllocator.fCtx,
reinterpret_cast<GrBackendObject>(&fInfo));
} else {
GL_CALL(DeleteTextures(1, &fInfo.fID));
}
GL_CALL(DeleteTextures(1, &fInfo.fID));
}
fInfo.fID = 0;
}

2
src/image/SkSurface.cpp
View File

@ -204,7 +204,7 @@ SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget*, const SkSurfaceProp
}
SkSurface* SkSurface::NewRenderTarget(GrContext*, Budgeted, const SkImageInfo&, int,
const SkSurfaceProps*, GrTextureStorageAllocator) {
const SkSurfaceProps*) {
return nullptr;
}

8
src/image/SkSurface_Gpu.cpp
View File

@ -121,11 +121,9 @@ SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget* target, const SkSurf
}
SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, Budgeted budgeted, const SkImageInfo& info,
int sampleCount, const SkSurfaceProps* props,
GrTextureStorageAllocator customAllocator) {
SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(
ctx, budgeted, info, sampleCount, props, SkGpuDevice::kClear_InitContents,
customAllocator));
int sampleCount, const SkSurfaceProps* props) {
SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(ctx, budgeted, info, sampleCount, props,
SkGpuDevice::kClear_InitContents));
if (!device) {
return nullptr;
}