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

Create updateResourceLabel method.

Browse Source 
In this CL, the GrSurfaceProxy's and GrDrawOpAtlas's label strings
are plumbed so that it can be stored in the label string of
GrGpuResource. updateResourceLabel method, which is called from
setLabel method, will add labels to Skia OpenGL backend using ANGLE's
labeling API.

Bug: chromium:1164111
Change-Id: I370715d186357e920d260d624d77586cdddd11e8
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/541230
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
This commit is contained in:
Aditya Kushwah 2022-05-19 15:05:37 -07:00 committed by SkCQ
parent 70e432e727
commit 605f92c7d7
34 changed files with 93 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/gpu/ganesh/BaseDevice.cpp
View File

@ -86,7 +86,8 @@ bool BaseDevice::replaceBackingProxy(SkSurface::ContentChangeMode mode) {
oldView.mipmapped(),
SkBackingFit::kExact,
oldRTP->isBudgeted(),
GrProtected::kNo);
GrProtected::kNo,
/*label=*/{});
if (!proxy) {
return false;
}

15
src/gpu/ganesh/GrDrawOpAtlas.cpp
View File

@ -477,10 +477,17 @@ bool GrDrawOpAtlas::createPages(
if (GrColorTypeIsAlphaOnly(grColorType)) {
swizzle = skgpu::Swizzle::Concat(swizzle, skgpu::Swizzle("aaaa"));
}
sk_sp<GrSurfaceProxy> proxy = proxyProvider->createProxy(
fFormat, dims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kExact,
SkBudgeted::kYes, GrProtected::kNo, GrInternalSurfaceFlags::kNone,
GrSurfaceProxy::UseAllocator::kNo);
sk_sp<GrSurfaceProxy> proxy = proxyProvider->createProxy(fFormat,
dims,
GrRenderable::kNo,
1,
GrMipmapped::kNo,
SkBackingFit::kExact,
SkBudgeted::kYes,
GrProtected::kNo,
fLabel,
GrInternalSurfaceFlags::kNone,
GrSurfaceProxy::UseAllocator::kNo);
if (!proxy) {
return false;
}

2
src/gpu/ganesh/GrGpu.cpp
View File

@ -48,6 +48,8 @@ void GrGpu::initCapsAndCompiler(sk_sp<const GrCaps> caps) {
void GrGpu::disconnect(DisconnectType type) {}
void GrGpu::updateResourceLabel(GrGpuResource* gpu) {}
////////////////////////////////////////////////////////////////////////////////
static bool validate_texel_levels(SkISize dimensions, GrColorType texelColorType,

2
src/gpu/ganesh/GrGpu.h
View File

@ -88,6 +88,8 @@ public:
// into an unrecoverable, lost state.
virtual bool isDeviceLost() const { return false; }
virtual void updateResourceLabel(GrGpuResource*);
/**
* The GrGpu object normally assumes that no outsider is setting state
* within the underlying 3D API's context/device/whatever. This call informs

5
src/gpu/ganesh/GrGpuResource.cpp
View File

@ -67,6 +67,11 @@ void GrGpuResource::abandon() {
fGpuMemorySize = 0;
}
void GrGpuResource::setLabel(std::string_view label) {
fLabel = label;
this->getGpu()->updateResourceLabel(this);
}
void GrGpuResource::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
if (this->fRefsWrappedObjects && !traceMemoryDump->shouldDumpWrappedObjects()) {
return;

4
src/gpu/ganesh/GrGpuResource.h
View File

@ -174,9 +174,9 @@ public:
associated unique key. */
const skgpu::UniqueKey& getUniqueKey() const { return fUniqueKey; }
std::string_view getLabel() const { return fLabel; }
std::string getLabel() const { return fLabel; }
void setLabel(std::string_view label) { fLabel = label; }
void setLabel(std::string_view label);
/**
* Internal-only helper class used for manipulations of the resource by the cache.

5
src/gpu/ganesh/GrProxyProvider.cpp
View File

@ -443,6 +443,7 @@ sk_sp<GrTextureProxy> GrProxyProvider::createProxy(const GrBackendFormat& format
SkBackingFit fit,
SkBudgeted budgeted,
GrProtected isProtected,
std::string_view label,
GrInternalSurfaceFlags surfaceFlags,
GrSurfaceProxy::UseAllocator useAllocator) {
ASSERT_SINGLE_OWNER
@ -494,7 +495,7 @@ sk_sp<GrTextureProxy> GrProxyProvider::createProxy(const GrBackendFormat& format
surfaceFlags | extraFlags,
useAllocator,
this->isDDLProvider(),
{}));
label));
}
return sk_sp<GrTextureProxy>(new GrTextureProxy(format,
@ -507,7 +508,7 @@ sk_sp<GrTextureProxy> GrProxyProvider::createProxy(const GrBackendFormat& format
surfaceFlags,
useAllocator,
this->isDDLProvider(),
{}));
label));
}
sk_sp<GrTextureProxy> GrProxyProvider::createCompressedTextureProxy(

1
src/gpu/ganesh/GrProxyProvider.h
View File

@ -91,6 +91,7 @@ public:
SkBackingFit,
SkBudgeted,
GrProtected,
std::string_view label,
GrInternalSurfaceFlags = GrInternalSurfaceFlags::kNone,
UseAllocator useAllocator = UseAllocator::kYes);

9
src/gpu/ganesh/GrRecordingContextPriv.cpp
View File

@ -135,7 +135,8 @@ std::unique_ptr<skgpu::SurfaceContext> GrRecordingContextPriv::makeSC(const GrIm
mipmapped,
fit,
budgeted,
isProtected);
isProtected,
/*label=*/{});
if (!proxy) {
return nullptr;
}
@ -181,7 +182,8 @@ std::unique_ptr<skgpu::SurfaceFillContext> GrRecordingContextPriv::makeSFC(GrIma
mipmapped,
fit,
budgeted,
isProtected);
isProtected,
/*label=*/{});
if (!proxy) {
return nullptr;
}
@ -243,7 +245,8 @@ std::unique_ptr<skgpu::SurfaceFillContext> GrRecordingContextPriv::makeSFC(
mipmapped,
fit,
budgeted,
isProtected);
isProtected,
/*label=*/{});
if (!proxy) {
return nullptr;
}

8
src/gpu/ganesh/GrResourceProvider.cpp
View File

@ -111,7 +111,7 @@ sk_sp<GrTexture> GrResourceProvider::createTexture(SkISize dimensions,
tempColorType,
tmpTexels.get(),
numMipLevels,
/*label=*/{});
/*label=*/label);
}
sk_sp<GrTexture> GrResourceProvider::getExactScratch(SkISize dimensions,
@ -168,7 +168,7 @@ sk_sp<GrTexture> GrResourceProvider::createTexture(SkISize dimensions,
renderable,
renderTargetSampleCnt,
isProtected,
/*label=*/{});
/*label=*/label);
if (!tex) {
return nullptr;
}
@ -184,7 +184,7 @@ sk_sp<GrTexture> GrResourceProvider::createTexture(SkISize dimensions,
GrMipmapped::kNo,
isProtected,
&mipLevel,
/*label=*/{});
/*label=*/label);
}
}
@ -323,7 +323,7 @@ sk_sp<GrTexture> GrResourceProvider::createApproxTexture(SkISize dimensions,
GrMipmapped::kNo,
SkBudgeted::kYes,
isProtected,
/*label=*/{});
/*label=*/label);
}
sk_sp<GrTexture> GrResourceProvider::findAndRefScratchTexture(const skgpu::ScratchKey& key,

4
src/gpu/ganesh/GrSurfaceProxy.cpp
View File

@ -124,7 +124,7 @@ sk_sp<GrSurface> GrSurfaceProxy::createSurfaceImpl(GrResourceProvider* resourceP
renderable,
sampleCnt,
fIsProtected,
/*label=*/{});
/*label=*/fLabel);
} else {
surface = resourceProvider->createTexture(fDimensions,
fFormat,
@ -134,7 +134,7 @@ sk_sp<GrSurface> GrSurfaceProxy::createSurfaceImpl(GrResourceProvider* resourceP
mipmapped,
fBudgeted,
fIsProtected,
/*label=*/{});
/*label=*/fLabel);
}
if (!surface) {
return nullptr;

3
src/gpu/ganesh/SurfaceContext.cpp
View File

@ -425,7 +425,8 @@ bool SurfaceContext::internalWritePixels(GrDirectContext* dContext,
GrMipmapped::kNo,
SkBackingFit::kApprox,
SkBudgeted::kYes,
GrProtected::kNo);
GrProtected::kNo,
/*label=*/{});
if (!tempProxy) {
return false;
}

7
src/gpu/ganesh/gl/GrGLGpu.cpp
View File

@ -511,6 +511,13 @@ void GrGLGpu::disconnect(DisconnectType type) {
fFinishCallbacks.callAll(/* doDelete */ DisconnectType::kCleanup == type);
}
void GrGLGpu::updateResourceLabel(GrGpuResource* gpu) {
const std::string label = "Skia_" + gpu->getLabel();
GrGLuint id = 0;
GL_CALL(GenTextures(1, &id));
GR_GL_CALL(this->glInterface(), ObjectLabel(GR_GL_TEXTURE, id, -1, label.c_str()));
}
GrThreadSafePipelineBuilder* GrGLGpu::pipelineBuilder() {
return fProgramCache.get();
}

2
src/gpu/ganesh/gl/GrGLGpu.h
View File

@ -40,6 +40,8 @@ public:
void disconnect(DisconnectType) override;
void updateResourceLabel(GrGpuResource*) override;
GrThreadSafePipelineBuilder* pipelineBuilder() override;
sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;

3
src/gpu/ganesh/ops/LatticeOp.cpp
View File

@ -477,7 +477,8 @@ GR_DRAW_OP_TEST_DEFINE(NonAALatticeOp) {
GrMipmapped::kNo,
SkBackingFit::kExact,
SkBudgeted::kYes,
GrProtected::kNo);
GrProtected::kNo,
/*label=*/{});
do {
if (random->nextBool()) {

2
src/gpu/ganesh/ops/SoftwarePathRenderer.cpp
View File

@ -94,7 +94,7 @@ GrSurfaceProxyView make_deferred_mask_texture_view(GrRecordingContext* rContext,
auto proxy =
proxyProvider->createProxy(format, dimensions, GrRenderable::kNo, 1, GrMipmapped::kNo,
fit, SkBudgeted::kYes, GrProtected::kNo);
fit, SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
}

13
src/gpu/ganesh/ops/TextureOp.cpp
View File

@ -1402,9 +1402,16 @@ GR_DRAW_OP_TEST_DEFINE(TextureOpImpl) {
context->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
GrRenderable::kNo);
GrProxyProvider* proxyProvider = context->priv().proxyProvider();
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, dims, GrRenderable::kNo, 1, mipmapped, fit, SkBudgeted::kNo, GrProtected::kNo,
GrInternalSurfaceFlags::kNone);
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(format,
dims,
GrRenderable::kNo,
1,
mipmapped,
fit,
SkBudgeted::kNo,
GrProtected::kNo,
/*label=*/{},
GrInternalSurfaceFlags::kNone);
SkRect rect = GrTest::TestRect(random);
SkRect srcRect;

2
src/gpu/ganesh/v1/ClipStack.cpp
View File

@ -328,7 +328,7 @@ GrSurfaceProxyView render_sw_mask(GrRecordingContext* context,
GrColorType::kAlpha_8);
auto proxy = proxyProvider->createProxy(format, bounds.size(), GrRenderable::kNo, 1,
GrMipmapped::kNo, SkBackingFit::kApprox,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Since this will be rendered on another thread, make a copy of the elements in case
// the clip stack is modified on the main thread

6
src/gpu/ganesh/v1/SurfaceDrawContext.cpp
View File

@ -181,7 +181,8 @@ std::unique_ptr<SurfaceDrawContext> SurfaceDrawContext::Make(
mipmapped,
fit,
budgeted,
isProtected);
isProtected,
/*label=*/{});
if (!proxy) {
return nullptr;
}
@ -226,7 +227,8 @@ std::unique_ptr<SurfaceDrawContext> SurfaceDrawContext::Make(
mipmapped,
fit,
budgeted,
isProtected);
isProtected,
/*label=*/{});
if (!proxy) {
return nullptr;
}

2
tests/BulkRectTest.cpp
View File

@ -31,7 +31,7 @@ static sk_sp<GrSurfaceProxy> create_proxy(GrRecordingContext* rContext) {
GrRenderable::kYes);
return rContext->priv().proxyProvider()->createProxy(
format, kDimensions, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kExact,
SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
SkBudgeted::kNo, GrProtected::kNo, /*label=*/{}, GrInternalSurfaceFlags::kNone);
}
typedef GrQuadAAFlags (*PerQuadAAFunc)(int i);

5
tests/GrMipMappedTest.cpp
View File

@ -383,7 +383,8 @@ static std::unique_ptr<skgpu::v1::SurfaceDrawContext> draw_mipmap_into_new_rende
GrMipmapped::kNo,
SkBackingFit::kApprox,
SkBudgeted::kYes,
GrProtected::kNo);
GrProtected::kNo,
/*label=*/{});
auto sdc = skgpu::v1::SurfaceDrawContext::Make(rContext,
colorType,
@ -439,7 +440,7 @@ DEF_GPUTEST(GrManyDependentsMipMappedTest, reporter, /* options */) {
sk_sp<GrTextureProxy> mipmapProxy = proxyProvider->createProxy(
format, {4, 4}, GrRenderable::kYes, 1, GrMipmapped::kYes, SkBackingFit::kExact,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Mark the mipmaps clean to ensure things still work properly when they won't be marked
// dirty again until GrRenderTask::makeClosed().

2
tests/GrSurfaceTest.cpp
View File

@ -167,7 +167,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(GrSurfaceRenderability, reporter, ctxInfo) {
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
combo.fFormat, kDims, GrRenderable::kNo, 1, GrMipmapped::kYes,
SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo);
SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo, /*label=*/{});
REPORTER_ASSERT(reporter, SkToBool(proxy.get()) == expectedMipMapability,
"ct:%s format:%s, tex:%d, expectedMipMapability:%d",
GrColorTypeToStr(combo.fColorType), combo.fFormat.toStr().c_str(),

2
tests/OpChainTest.cpp
View File

@ -183,7 +183,7 @@ DEF_GPUTEST(OpChainTest, reporter, /*ctxInfo*/) {
static const GrSurfaceOrigin kOrigin = kTopLeft_GrSurfaceOrigin;
auto proxy = dContext->priv().proxyProvider()->createProxy(
format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kExact,
SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
SkBudgeted::kNo, GrProtected::kNo, /*label=*/{}, GrInternalSurfaceFlags::kNone);
SkASSERT(proxy);
proxy->instantiate(dContext->priv().resourceProvider());

2
tests/ProcessorTest.cpp
View File

@ -163,7 +163,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
{
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, kDims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kExact,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
{
SkTArray<GrSurfaceProxyView> views;

4
tests/ProgramsTest.cpp
View File

@ -254,7 +254,7 @@ bool GrDrawingManager::ProgramUnitTest(GrDirectContext* direct, int maxStages, i
GrRenderable::kYes);
auto proxy = proxyProvider->createProxy(format, kDims, GrRenderable::kYes, 1,
mipmapped, SkBackingFit::kExact, SkBudgeted::kNo,
GrProtected::kNo, GrInternalSurfaceFlags::kNone);
GrProtected::kNo,/*label=*/{}, GrInternalSurfaceFlags::kNone);
skgpu::Swizzle swizzle = caps->getReadSwizzle(format, GrColorType::kRGBA_8888);
views[0] = {{std::move(proxy), kBottomLeft_GrSurfaceOrigin, swizzle},
GrColorType::kRGBA_8888, kPremul_SkAlphaType};
@ -265,7 +265,7 @@ bool GrDrawingManager::ProgramUnitTest(GrDirectContext* direct, int maxStages, i
GrRenderable::kNo);
auto proxy = proxyProvider->createProxy(format, kDims, GrRenderable::kNo, 1, mipmapped,
SkBackingFit::kExact, SkBudgeted::kNo,
GrProtected::kNo, GrInternalSurfaceFlags::kNone);
GrProtected::kNo, /*label=*/{}, GrInternalSurfaceFlags::kNone);
skgpu::Swizzle swizzle = caps->getReadSwizzle(format, GrColorType::kAlpha_8);
views[1] = {{std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle},
GrColorType::kAlpha_8, kPremul_SkAlphaType};

6
tests/ProxyConversionTest.cpp
View File

@ -134,7 +134,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
{
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Both RenderTarget and Texture
GrRenderTargetProxy* rtProxy = proxy->asRenderTargetProxy();
@ -148,7 +148,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
{
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Both RenderTarget and Texture - but via GrTextureProxy
GrTextureProxy* tProxy = proxy->asTextureProxy();
@ -162,7 +162,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
{
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, kDims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Texture-only
GrTextureProxy* tProxy = proxy->asTextureProxy();
REPORTER_ASSERT(reporter, tProxy);

2
tests/ProxyRefTest.cpp
View File

@ -30,7 +30,7 @@ static sk_sp<GrTextureProxy> make_deferred(GrRecordingContext* rContext) {
GrRenderable::kYes);
return proxyProvider->createProxy(format, {kWidthHeight, kWidthHeight}, GrRenderable::kYes, 1,
GrMipmapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes,
GrProtected::kNo);
GrProtected::kNo, /*label=*/{});
}
static sk_sp<GrTextureProxy> make_wrapped(GrRecordingContext* rContext) {

6
tests/ProxyTest.cpp
View File

@ -155,7 +155,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, dims, GrRenderable::kYes, numSamples, GrMipmapped::kNo,
fit, budgeted, GrProtected::kNo);
fit, budgeted, GrProtected::kNo, /*label=*/{});
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
@ -201,7 +201,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
format, dims, GrRenderable::kNo, numSamples, GrMipmapped::kNo,
fit, budgeted, GrProtected::kNo));
fit, budgeted, GrProtected::kNo, /*label=*/{}));
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
// This forces the proxy to compute and cache its
@ -357,7 +357,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ZeroSizedProxyTest, reporter, ctxInfo) {
sk_sp<GrTextureProxy> proxy = provider->createProxy(
format, {width, height}, renderable, 1, GrMipmapped::kNo, fit,
SkBudgeted::kNo, GrProtected::kNo);
SkBudgeted::kNo, GrProtected::kNo, /*label=*/{});
REPORTER_ASSERT(reporter, !proxy);
}
}

2
tests/ResourceAllocatorTest.cpp
View File

@ -63,7 +63,7 @@ static sk_sp<GrSurfaceProxy> make_deferred(GrProxyProvider* proxyProvider, const
const ProxyParams& p) {
const GrBackendFormat format = caps->getDefaultBackendFormat(p.fColorType, p.fRenderable);
return proxyProvider->createProxy(format, {p.fSize, p.fSize}, p.fRenderable, p.fSampleCnt,
GrMipmapped::kNo, p.fFit, p.fBudgeted, GrProtected::kNo);
GrMipmapped::kNo, p.fFit, p.fBudgeted, GrProtected::kNo, /*label=*/{});
}
static sk_sp<GrSurfaceProxy> make_backend(GrDirectContext* dContext, const ProxyParams& p) {

2
tests/ResourceCacheTest.cpp
View File

@ -1705,7 +1705,7 @@ static sk_sp<GrTextureProxy> make_mipmap_proxy(GrRecordingContext* rContext,
GrRenderable::kNo);
return proxyProvider->createProxy(format, dims, renderable, sampleCnt, GrMipmapped::kYes,
SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
}
// Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,

2
tests/TextureOpTest.cpp
View File

@ -46,7 +46,7 @@ static sk_sp<GrSurfaceProxy> create_proxy(GrRecordingContext* rContext) {
GrRenderable::kYes);
return rContext->priv().proxyProvider()->createProxy(
format, kDimensions, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kExact,
SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
SkBudgeted::kNo, GrProtected::kNo, /*label=*/{}, GrInternalSurfaceFlags::kNone);
}
static GrOp::Owner create_op(GrDirectContext* dContext, SkRect rect,

4
tests/TextureProxyTest.cpp
View File

@ -47,7 +47,7 @@ static sk_sp<GrTextureProxy> deferred_tex(skiatest::Reporter* reporter,
sk_sp<GrTextureProxy> proxy =
proxyProvider->createProxy(format, kSize, GrRenderable::kNo, 1, GrMipmapped::kNo, fit,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Only budgeted & wrapped external proxies get to carry uniqueKeys
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
@ -63,7 +63,7 @@ static sk_sp<GrTextureProxy> deferred_texRT(skiatest::Reporter* reporter,
sk_sp<GrTextureProxy> proxy =
proxyProvider->createProxy(format, kSize, GrRenderable::kYes, 1, GrMipmapped::kNo, fit,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
// Only budgeted & wrapped external proxies get to carry uniqueKeys
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;

2
tests/WritePixelsTest.cpp
View File

@ -535,7 +535,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixelsPendingIO, reporter, ctxInfo) {
sk_sp<GrTextureProxy> temp = proxyProvider->createProxy(
format, kDims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
SkBudgeted::kYes, GrProtected::kNo);
SkBudgeted::kYes, GrProtected::kNo, /*label=*/{});
temp->instantiate(context->priv().resourceProvider());
}

3
tools/gpu/ProxyUtils.cpp
View File

@ -76,7 +76,8 @@ GrSurfaceProxyView MakeTextureProxyViewFromData(GrDirectContext* dContext,
GrMipmapped::kNo,
SkBackingFit::kExact,
SkBudgeted::kYes,
GrProtected::kNo);
GrProtected::kNo,
/*label=*/{});
if (!proxy) {
return {};
}