Rebase and fix chromium
Combine texture provider and resource provider
Largely mechanical. Only three places that were calling createApprox
via texture provider (ie without flags), so that was simple.
BUG=skia:
Change-Id: I876367bcdc6a8db736deedab1028de1972015509
Reviewed-on: https://skia-review.googlesource.com/9176
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/src/core/SkGpuBlurUtils.cpp b/src/core/SkGpuBlurUtils.cpp
index bc40c38..43f28cb 100644
--- a/src/core/SkGpuBlurUtils.cpp
+++ b/src/core/SkGpuBlurUtils.cpp
@@ -199,7 +199,7 @@
// Chrome is crashing with proxies when they need to be instantiated.
// Force an instantiation here (where, in olden days, we used to require a GrTexture)
// to see if the input is already un-instantiable.
- GrTexture* temp = srcProxy->instantiate(context->textureProvider());
+ GrTexture* temp = srcProxy->instantiate(context->resourceProvider());
if (!temp) {
return nullptr;
}
diff --git a/src/core/SkImageCacherator.cpp b/src/core/SkImageCacherator.cpp
index c33a008..b4f9e8b 100644
--- a/src/core/SkImageCacherator.cpp
+++ b/src/core/SkImageCacherator.cpp
@@ -21,8 +21,8 @@
#include "GrGpuResourcePriv.h"
#include "GrImageTextureMaker.h"
#include "GrResourceKey.h"
+#include "GrResourceProvider.h"
#include "GrSamplerParams.h"
-#include "GrTextureProvider.h"
#include "GrYUVProvider.h"
#include "SkGr.h"
#include "SkGrPriv.h"
@@ -467,7 +467,7 @@
}
desc.fConfig = config;
- return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, rawStart, 0);
+ return ctx->resourceProvider()->createTexture(desc, SkBudgeted::kYes, rawStart, 0);
}
#endif
@@ -486,10 +486,10 @@
}
};
-static GrTexture* set_key_and_return(GrTextureProvider* texProvider,
+static GrTexture* set_key_and_return(GrResourceProvider* resourceProvider,
GrTexture* tex, const GrUniqueKey& key) {
if (key.isValid()) {
- texProvider->assignUniqueKeyToTexture(key, tex);
+ resourceProvider->assignUniqueKeyToTexture(key, tex);
}
return tex;
}
@@ -538,7 +538,7 @@
// 1. Check the cache for a pre-existing one
if (key.isValid()) {
- if (GrTexture* tex = ctx->textureProvider()->findAndRefTextureByUniqueKey(key)) {
+ if (GrTexture* tex = ctx->resourceProvider()->findAndRefTextureByUniqueKey(key)) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath,
kLockTexturePathCount);
return tex;
@@ -556,9 +556,9 @@
if (sk_sp<GrTextureProxy> proxy = generator->generateTexture(ctx, cacheInfo, fOrigin)) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath,
kLockTexturePathCount);
- GrTexture* tex2 = proxy->instantiate(ctx->textureProvider());
+ GrTexture* tex2 = proxy->instantiate(ctx->resourceProvider());
if (tex2) {
- return set_key_and_return(ctx->textureProvider(), SkSafeRef(tex2), key);
+ return set_key_and_return(ctx->resourceProvider(), SkSafeRef(tex2), key);
}
}
}
@@ -586,7 +586,7 @@
if (tex) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath,
kLockTexturePathCount);
- return set_key_and_return(ctx->textureProvider(), tex.release(), key);
+ return set_key_and_return(ctx->resourceProvider(), tex.release(), key);
}
}
@@ -603,7 +603,7 @@
if (tex) {
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kRGBA_LockTexturePath,
kLockTexturePathCount);
- return set_key_and_return(ctx->textureProvider(), tex, key);
+ return set_key_and_return(ctx->resourceProvider(), tex, key);
}
}
SK_HISTOGRAM_ENUMERATION("LockTexturePath", kFailure_LockTexturePath,
diff --git a/src/core/SkMaskFilter.cpp b/src/core/SkMaskFilter.cpp
index 59dbe2e..e856058 100644
--- a/src/core/SkMaskFilter.cpp
+++ b/src/core/SkMaskFilter.cpp
@@ -314,7 +314,7 @@
return false;
}
-bool SkMaskFilter::directFilterMaskGPU(GrTextureProvider* texProvider,
+bool SkMaskFilter::directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* renderTargetContext,
GrPaint&&,
const GrClip&,
diff --git a/src/core/SkSpecialImage.cpp b/src/core/SkSpecialImage.cpp
index ad5ef4d..9ded6aa 100644
--- a/src/core/SkSpecialImage.cpp
+++ b/src/core/SkSpecialImage.cpp
@@ -349,7 +349,7 @@
static sk_sp<SkImage> wrap_proxy_in_image(GrContext* context, GrTextureProxy* proxy,
SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace) {
// TODO: add GrTextureProxy-backed SkImage_Gpus
- GrTexture* tex = proxy->instantiate(context->textureProvider());
+ GrTexture* tex = proxy->instantiate(context->resourceProvider());
if (!tex) {
return nullptr;
}
@@ -390,7 +390,7 @@
this->subset().width(), this->subset().height());
// TODO: add GrTextureProxy-backed SkImage_Gpus
- GrTexture* tex = fTextureProxy->instantiate(fContext->textureProvider());
+ GrTexture* tex = fTextureProxy->instantiate(fContext->resourceProvider());
if (!tex) {
return;
}
@@ -432,7 +432,7 @@
}
// Reading back to an SkBitmap ends deferral
- GrTexture* texture = fTextureProxy->instantiate(fContext->textureProvider());
+ GrTexture* texture = fTextureProxy->instantiate(fContext->resourceProvider());
if (!texture) {
return false;
}
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.cpp b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
index 464dc5e..897d447 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.cpp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
@@ -39,14 +39,14 @@
, fOuterThreshold(outerThreshold)
, fImageCoordTransform(context, SkMatrix::I(), proxy.get(),
GrSamplerParams::kNone_FilterMode)
- , fImageTextureSampler(context->textureProvider(), std::move(proxy))
+ , fImageTextureSampler(context->resourceProvider(), std::move(proxy))
, fColorSpaceXform(std::move(colorSpaceXform))
, fMaskCoordTransform(
context,
SkMatrix::MakeTrans(SkIntToScalar(-bounds.x()), SkIntToScalar(-bounds.y())),
maskProxy.get(),
GrSamplerParams::kNone_FilterMode)
- , fMaskTextureSampler(context->textureProvider(), maskProxy) {
+ , fMaskTextureSampler(context->resourceProvider(), maskProxy) {
this->initClassID<GrAlphaThresholdFragmentProcessor>();
this->addCoordTransform(&fImageCoordTransform);
this->addTextureSampler(&fImageTextureSampler);
diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
index de4bb58..f9f960c 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -10,7 +10,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
-#include "GrTextureProvider.h"
+#include "GrResourceProvider.h"
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
@@ -82,7 +82,7 @@
///////////////////////////////////////////////////////////////////////////////
-GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(GrTextureProvider* textureProvider,
+GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(GrResourceProvider* resourceProvider,
const SkRect& circle,
float textureRadius,
float solidRadius,
@@ -91,7 +91,7 @@
, fCircle(circle)
, fSolidRadius(solidRadius)
, fTextureRadius(textureRadius)
- , fBlurProfileSampler(textureProvider, std::move(blurProfile),
+ , fBlurProfileSampler(resourceProvider, std::move(blurProfile),
GrSamplerParams::kBilerp_FilterMode) {
this->initClassID<GrCircleBlurFragmentProcessor>();
this->addTextureSampler(&fBlurProfileSampler);
@@ -260,7 +260,7 @@
return profile;
}
-static sk_sp<GrTextureProxy> create_profile_texture(GrTextureProvider* textureProvider,
+static sk_sp<GrTextureProxy> create_profile_texture(GrResourceProvider* resourceProvider,
const SkRect& circle,
float sigma,
float* solidRadius, float* textureRadius) {
@@ -300,7 +300,7 @@
builder.finish();
// MDB TODO (caching): this side-steps the issue of texture proxies with unique IDs
- sk_sp<GrTexture> blurProfile(textureProvider->findAndRefTextureByUniqueKey(key));
+ sk_sp<GrTexture> blurProfile(resourceProvider->findAndRefTextureByUniqueKey(key));
if (!blurProfile) {
static constexpr int kProfileTextureWidth = 512;
GrSurfaceDesc texDesc;
@@ -318,13 +318,13 @@
kProfileTextureWidth));
}
- blurProfile.reset(textureProvider->createTexture(texDesc, SkBudgeted::kYes,
+ blurProfile.reset(resourceProvider->createTexture(texDesc, SkBudgeted::kYes,
profile.get(), 0));
if (!blurProfile) {
return nullptr;
}
- textureProvider->assignUniqueKeyToTexture(key, blurProfile.get());
+ resourceProvider->assignUniqueKeyToTexture(key, blurProfile.get());
}
return GrSurfaceProxy::MakeWrapped(std::move(blurProfile));
@@ -332,16 +332,16 @@
//////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(GrTextureProvider* textureProvider,
+sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(GrResourceProvider* resourceProvider,
const SkRect& circle, float sigma) {
float solidRadius;
float textureRadius;
- sk_sp<GrTextureProxy> profile(create_profile_texture(textureProvider, circle, sigma,
+ sk_sp<GrTextureProxy> profile(create_profile_texture(resourceProvider, circle, sigma,
&solidRadius, &textureRadius));
if (!profile) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(textureProvider,
+ return sk_sp<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(resourceProvider,
circle,
textureRadius, solidRadius,
std::move(profile)));
@@ -356,7 +356,7 @@
SkScalar wh = d->fRandom->nextRangeScalar(100.f, 1000.f);
SkScalar sigma = d->fRandom->nextRangeF(1.f,10.f);
SkRect circle = SkRect::MakeWH(wh, wh);
- return GrCircleBlurFragmentProcessor::Make(d->context()->textureProvider(), circle, sigma);
+ return GrCircleBlurFragmentProcessor::Make(d->context()->resourceProvider(), circle, sigma);
}
#endif
diff --git a/src/effects/GrCircleBlurFragmentProcessor.h b/src/effects/GrCircleBlurFragmentProcessor.h
index 9b1fdbf..c6cf3ba 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.h
+++ b/src/effects/GrCircleBlurFragmentProcessor.h
@@ -16,7 +16,7 @@
#include "GrFragmentProcessor.h"
#include "GrProcessorUnitTest.h"
-class GrTextureProvider;
+class GrResourceProvider;
// This FP handles the special case of a blurred circle. It uses a 1D
// profile that is just rotated about the origin of the circle.
@@ -34,7 +34,7 @@
return str;
}
- static sk_sp<GrFragmentProcessor> Make(GrTextureProvider*, const SkRect& circle, float sigma);
+ static sk_sp<GrFragmentProcessor> Make(GrResourceProvider*, const SkRect& circle, float sigma);
private:
// This nested GLSL processor implementation is defined in the cpp file.
@@ -45,7 +45,7 @@
* The x texture coord should map from 0 to 1 across the radius range of solidRadius to
* solidRadius + textureRadius.
*/
- GrCircleBlurFragmentProcessor(GrTextureProvider*, const SkRect& circle,
+ GrCircleBlurFragmentProcessor(GrResourceProvider*, const SkRect& circle,
float textureRadius, float innerRadius,
sk_sp<GrTextureProxy> blurProfile);
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 2ee942d..7ca7aa8 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -19,11 +19,11 @@
#include "GrCircleBlurFragmentProcessor.h"
#include "GrContext.h"
#include "GrRenderTargetContext.h"
+#include "GrResourceProvider.h"
#include "GrTexture.h"
#include "GrFragmentProcessor.h"
#include "GrShaderCaps.h"
#include "GrStyle.h"
-#include "GrTextureProvider.h"
#include "GrTextureProxy.h"
#include "effects/GrSimpleTextureEffect.h"
#include "glsl/GrGLSLFragmentProcessor.h"
@@ -50,7 +50,7 @@
const SkIRect& clipBounds,
const SkMatrix& ctm,
SkRect* maskRect) const override;
- bool directFilterMaskGPU(GrTextureProvider* texProvider,
+ bool directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* renderTargetContext,
GrPaint&&,
const GrClip&,
@@ -771,7 +771,7 @@
const char* name() const override { return "RectBlur"; }
- static sk_sp<GrFragmentProcessor> Make(GrTextureProvider* textureProvider,
+ static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
const SkRect& rect, float sigma) {
int doubleProfileSize = SkScalarCeilToInt(12*sigma);
@@ -781,7 +781,7 @@
return nullptr;
}
- sk_sp<GrTextureProxy> blurProfile(CreateBlurProfileTexture(textureProvider, sigma));
+ sk_sp<GrTextureProxy> blurProfile(CreateBlurProfileTexture(resourceProvider, sigma));
if (!blurProfile) {
return nullptr;
}
@@ -805,7 +805,7 @@
precision = kDefault_GrSLPrecision;
}
- return sk_sp<GrFragmentProcessor>(new GrRectBlurEffect(textureProvider, rect, sigma,
+ return sk_sp<GrFragmentProcessor>(new GrRectBlurEffect(resourceProvider, rect, sigma,
std::move(blurProfile), precision));
}
@@ -814,7 +814,7 @@
GrSLPrecision precision() const { return fPrecision; }
private:
- GrRectBlurEffect(GrTextureProvider*, const SkRect& rect, float sigma,
+ GrRectBlurEffect(GrResourceProvider*, const SkRect& rect, float sigma,
sk_sp<GrTextureProxy> blurProfile, GrSLPrecision fPrecision);
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
@@ -823,7 +823,7 @@
bool onIsEqual(const GrFragmentProcessor&) const override;
- static sk_sp<GrTextureProxy> CreateBlurProfileTexture(GrTextureProvider*, float sigma);
+ static sk_sp<GrTextureProxy> CreateBlurProfileTexture(GrResourceProvider*, float sigma);
SkRect fRect;
float fSigma;
@@ -942,8 +942,8 @@
}
// MDB TODO (caching): This side-steps the issue of texture proxies with unique IDs
-sk_sp<GrTextureProxy> GrRectBlurEffect::CreateBlurProfileTexture(GrTextureProvider* textureProvider,
- float sigma) {
+sk_sp<GrTextureProxy> GrRectBlurEffect::CreateBlurProfileTexture(
+ GrResourceProvider* resourceProvider, float sigma) {
GrSurfaceDesc texDesc;
unsigned int profileSize = SkScalarCeilToInt(6*sigma);
@@ -959,30 +959,30 @@
builder[0] = profileSize;
builder.finish();
- sk_sp<GrTexture> blurProfile(textureProvider->findAndRefTextureByUniqueKey(key));
+ sk_sp<GrTexture> blurProfile(resourceProvider->findAndRefTextureByUniqueKey(key));
if (!blurProfile) {
std::unique_ptr<uint8_t[]> profile(SkBlurMask::ComputeBlurProfile(sigma));
- blurProfile.reset(textureProvider->createTexture(texDesc, SkBudgeted::kYes,
+ blurProfile.reset(resourceProvider->createTexture(texDesc, SkBudgeted::kYes,
profile.get(), 0));
if (!blurProfile) {
return nullptr;
}
- textureProvider->assignUniqueKeyToTexture(key, blurProfile.get());
+ resourceProvider->assignUniqueKeyToTexture(key, blurProfile.get());
}
return GrSurfaceProxy::MakeWrapped(std::move(blurProfile));
}
-GrRectBlurEffect::GrRectBlurEffect(GrTextureProvider* textureProvider,
+GrRectBlurEffect::GrRectBlurEffect(GrResourceProvider* resourceProvider,
const SkRect& rect, float sigma,
sk_sp<GrTextureProxy> blurProfile,
GrSLPrecision precision)
: INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
, fRect(rect)
, fSigma(sigma)
- , fBlurProfileSampler(textureProvider, std::move(blurProfile))
+ , fBlurProfileSampler(resourceProvider, std::move(blurProfile))
, fPrecision(precision) {
this->initClassID<GrRectBlurEffect>();
this->addTextureSampler(&fBlurProfileSampler);
@@ -1009,12 +1009,12 @@
float sigma = d->fRandom->nextRangeF(3,8);
float width = d->fRandom->nextRangeF(200,300);
float height = d->fRandom->nextRangeF(200,300);
- return GrRectBlurEffect::Make(d->context()->textureProvider(), SkRect::MakeWH(width, height),
+ return GrRectBlurEffect::Make(d->context()->resourceProvider(), SkRect::MakeWH(width, height),
sigma);
}
#endif
-bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
+bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* renderTargetContext,
GrPaint&& paint,
const GrClip& clip,
@@ -1041,9 +1041,9 @@
SkScalar pad = 3.0f * xformedSigma;
rect.outset(pad, pad);
- fp = GrRectBlurEffect::Make(texProvider, rect, xformedSigma);
+ fp = GrRectBlurEffect::Make(resourceProvider, rect, xformedSigma);
} else if (path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height())) {
- fp = GrCircleBlurFragmentProcessor::Make(texProvider, rect, xformedSigma);
+ fp = GrCircleBlurFragmentProcessor::Make(resourceProvider, rect, xformedSigma);
// expand the rect for the coverage geometry
int pad = SkScalarCeilToInt(6*xformedSigma)/2;
@@ -1085,7 +1085,7 @@
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
- GrRRectBlurEffect(GrTextureProvider*, float sigma, const SkRRect&,
+ GrRRectBlurEffect(GrResourceProvider*, float sigma, const SkRRect&,
sk_sp<GrTextureProxy> profileProxy);
virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
@@ -1121,7 +1121,7 @@
}
builder.finish();
- sk_sp<GrTexture> mask(context->textureProvider()->findAndRefTextureByUniqueKey(key));
+ sk_sp<GrTexture> mask(context->resourceProvider()->findAndRefTextureByUniqueKey(key));
if (!mask) {
// TODO: this could be approx but the texture coords will need to be updated
sk_sp<GrRenderTargetContext> rtc(context->makeDeferredRenderTargetContextWithFallback(
@@ -1157,7 +1157,7 @@
if (!mask) {
return nullptr;
}
- context->textureProvider()->assignUniqueKeyToTexture(key, mask.get());
+ context->resourceProvider()->assignUniqueKeyToTexture(key, mask.get());
}
return GrSurfaceProxy::MakeWrapped(std::move(mask));
@@ -1200,19 +1200,19 @@
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(context->textureProvider(),
+ return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(context->resourceProvider(),
xformedSigma,
devRRect,
std::move(mask)));
}
-GrRRectBlurEffect::GrRRectBlurEffect(GrTextureProvider* textureProvider,
+GrRRectBlurEffect::GrRRectBlurEffect(GrResourceProvider* resourceProvider,
float sigma, const SkRRect& rrect,
sk_sp<GrTextureProxy> ninePatchProxy)
: INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
, fRRect(rrect)
, fSigma(sigma)
- , fNinePatchSampler(textureProvider, std::move(ninePatchProxy)) {
+ , fNinePatchSampler(resourceProvider, std::move(ninePatchProxy)) {
this->initClassID<GrRRectBlurEffect>();
this->addTextureSampler(&fNinePatchSampler);
}
@@ -1369,9 +1369,9 @@
SkScalar pad = 3.0f * xformedSigma;
const SkRect dstCoverageRect = devRRect.rect().makeOutset(pad, pad);
- fp = GrRectBlurEffect::Make(context->textureProvider(), dstCoverageRect, xformedSigma);
+ fp = GrRectBlurEffect::Make(context->resourceProvider(), dstCoverageRect, xformedSigma);
} else {
- fp = GrCircleBlurFragmentProcessor::Make(context->textureProvider(),
+ fp = GrCircleBlurFragmentProcessor::Make(context->resourceProvider(),
devRRect.rect(),
xformedSigma);
}
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 3c0a2d5..0005981 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -498,11 +498,11 @@
: kNone_OptimizationFlags)
, fDisplacementTransform(context, offsetMatrix, displacement.get(),
GrSamplerParams::kNone_FilterMode)
- , fDisplacementSampler(context->textureProvider(), displacement)
+ , fDisplacementSampler(context->resourceProvider(), displacement)
, fColorTransform(context, color.get(), GrSamplerParams::kNone_FilterMode)
, fDomain(color.get(), GrTextureDomain::MakeTexelDomain(SkIRect::MakeSize(colorDimensions)),
GrTextureDomain::kDecal_Mode)
- , fColorSampler(context->textureProvider(), color)
+ , fColorSampler(context->resourceProvider(), color)
, fColorSpaceXform(std::move(colorSpaceXform))
, fXChannelSelector(xChannelSelector)
, fYChannelSelector(yChannelSelector)
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index 5f8fe32..4ebf36a 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -486,7 +486,7 @@
class GrPerlinNoiseEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(GrTextureProvider* textureProvider,
+ static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
SkPerlinNoiseShader::Type type,
int numOctaves, bool stitchTiles,
SkPerlinNoiseShader::PaintingData* paintingData,
@@ -494,7 +494,7 @@
sk_sp<GrTextureProxy> noiseProxy,
const SkMatrix& matrix) {
return sk_sp<GrFragmentProcessor>(
- new GrPerlinNoiseEffect(textureProvider, type, numOctaves, stitchTiles, paintingData,
+ new GrPerlinNoiseEffect(resourceProvider, type, numOctaves, stitchTiles, paintingData,
std::move(permutationsProxy), std::move(noiseProxy), matrix));
}
@@ -528,7 +528,7 @@
fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
}
- GrPerlinNoiseEffect(GrTextureProvider* textureProvider,
+ GrPerlinNoiseEffect(GrResourceProvider* resourceProvider,
SkPerlinNoiseShader::Type type, int numOctaves, bool stitchTiles,
SkPerlinNoiseShader::PaintingData* paintingData,
sk_sp<GrTextureProxy> permutationsProxy, sk_sp<GrTextureProxy> noiseProxy,
@@ -538,8 +538,8 @@
, fCoordTransform(matrix)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
- , fPermutationsSampler(textureProvider, std::move(permutationsProxy))
- , fNoiseSampler(textureProvider, std::move(noiseProxy))
+ , fPermutationsSampler(resourceProvider, std::move(permutationsProxy))
+ , fNoiseSampler(resourceProvider, std::move(noiseProxy))
, fPaintingData(paintingData) {
this->initClassID<GrPerlinNoiseEffect>();
this->addTextureSampler(&fPermutationsSampler);
@@ -926,7 +926,7 @@
m.setTranslateY(-localMatrix.getTranslateY() + SK_Scalar1);
if (permutationsProxy && noiseProxy) {
sk_sp<GrFragmentProcessor> inner(
- GrPerlinNoiseEffect::Make(args.fContext->textureProvider(),
+ GrPerlinNoiseEffect::Make(args.fContext->resourceProvider(),
fType,
fNumOctaves,
fStitchTiles,
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index b63ed47..ba3f084 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -515,7 +515,7 @@
ColorTableEffect::ColorTableEffect(GrContext* context, sk_sp<GrTextureProxy> proxy,
GrTextureStripAtlas* atlas, int row, unsigned flags)
: INHERITED(kNone_OptimizationFlags) // Not bothering with table-specific optimizations.
- , fTextureSampler(context->textureProvider(), std::move(proxy))
+ , fTextureSampler(context->resourceProvider(), std::move(proxy))
, fAtlas(atlas)
, fRow(row) {
this->initClassID<ColorTableEffect>();
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index 32189c5..bba9f85 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -1702,7 +1702,7 @@
fCoordTransform.reset(args.fContext, *args.fMatrix,
fAtlas->asTextureProxyRef().get(),
params.filterMode(), false);
- fTextureSampler.reset(args.fContext->textureProvider(),
+ fTextureSampler.reset(args.fContext->resourceProvider(),
fAtlas->asTextureProxyRef(), params);
} else {
// In this instance we know the params are:
@@ -1719,7 +1719,7 @@
// This is 2/2 places where auto-normalization is disabled
fCoordTransform.reset(args.fContext, *args.fMatrix,
proxy.get(), params.filterMode(), false);
- fTextureSampler.reset(args.fContext->textureProvider(),
+ fTextureSampler.reset(args.fContext->resourceProvider(),
std::move(proxy), params);
fYCoord = SK_ScalarHalf;
}
diff --git a/src/effects/shadows/SkAmbientShadowMaskFilter.cpp b/src/effects/shadows/SkAmbientShadowMaskFilter.cpp
index b6f5392..561d77d 100644
--- a/src/effects/shadows/SkAmbientShadowMaskFilter.cpp
+++ b/src/effects/shadows/SkAmbientShadowMaskFilter.cpp
@@ -34,7 +34,7 @@
const SkIRect& clipBounds,
const SkMatrix& ctm,
SkRect* maskRect) const override;
- bool directFilterMaskGPU(GrTextureProvider* texProvider,
+ bool directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* drawContext,
GrPaint&&,
const GrClip&,
@@ -139,7 +139,7 @@
static const float kHeightFactor = 1.0f / 128.0f;
static const float kGeomFactor = 64.0f;
-bool SkAmbientShadowMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
+bool SkAmbientShadowMaskFilterImpl::directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* rtContext,
GrPaint&& paint,
const GrClip& clip,
diff --git a/src/effects/shadows/SkSpotShadowMaskFilter.cpp b/src/effects/shadows/SkSpotShadowMaskFilter.cpp
index 99a03db..0a97320 100644
--- a/src/effects/shadows/SkSpotShadowMaskFilter.cpp
+++ b/src/effects/shadows/SkSpotShadowMaskFilter.cpp
@@ -35,7 +35,7 @@
const SkIRect& clipBounds,
const SkMatrix& ctm,
SkRect* maskRect) const override;
- bool directFilterMaskGPU(GrTextureProvider* texProvider,
+ bool directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* drawContext,
GrPaint&&,
const GrClip&,
@@ -156,7 +156,7 @@
return true;
}
-bool SkSpotShadowMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
+bool SkSpotShadowMaskFilterImpl::directFilterMaskGPU(GrResourceProvider* resourceProvider,
GrRenderTargetContext* rtContext,
GrPaint&& paint,
const GrClip& clip,
diff --git a/src/gpu/GrBitmapTextureMaker.cpp b/src/gpu/GrBitmapTextureMaker.cpp
index cff052f..24cb05f 100644
--- a/src/gpu/GrBitmapTextureMaker.cpp
+++ b/src/gpu/GrBitmapTextureMaker.cpp
@@ -9,7 +9,7 @@
#include "GrContext.h"
#include "GrGpuResourcePriv.h"
-#include "GrTextureProvider.h"
+#include "GrResourceProvider.h"
#include "SkBitmap.h"
#include "SkGrPriv.h"
#include "SkPixelRef.h"
@@ -32,7 +32,7 @@
GrTexture* tex = nullptr;
if (fOriginalKey.isValid()) {
- tex = this->context()->textureProvider()->findAndRefTextureByUniqueKey(fOriginalKey);
+ tex = this->context()->resourceProvider()->findAndRefTextureByUniqueKey(fOriginalKey);
if (tex) {
return tex;
}
@@ -44,7 +44,7 @@
tex = GrUploadBitmapToTexture(this->context(), fBitmap);
}
if (tex && fOriginalKey.isValid()) {
- this->context()->textureProvider()->assignUniqueKeyToTexture(fOriginalKey, tex);
+ this->context()->resourceProvider()->assignUniqueKeyToTexture(fOriginalKey, tex);
GrInstallBitmapUniqueKeyInvalidator(fOriginalKey, fBitmap.pixelRef());
}
return tex;
diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp
index 091d776..6716fde 100644
--- a/src/gpu/GrBlurUtils.cpp
+++ b/src/gpu/GrBlurUtils.cpp
@@ -12,11 +12,11 @@
#include "GrContextPriv.h"
#include "GrFixedClip.h"
#include "GrRenderTargetContextPriv.h"
+#include "GrResourceProvider.h"
#include "effects/GrSimpleTextureEffect.h"
#include "GrStyle.h"
#include "GrTexture.h"
#include "GrTextureProxy.h"
-#include "GrTextureProvider.h"
#include "SkDraw.h"
#include "SkGrPriv.h"
#include "SkMaskFilter.h"
@@ -207,7 +207,7 @@
return;
}
- if (maskFilter->directFilterMaskGPU(context->textureProvider(),
+ if (maskFilter->directFilterMaskGPU(context->resourceProvider(),
renderTargetContext,
std::move(paint),
clip,
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index c69f79e..a0682f4 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -413,11 +413,11 @@
// MDB TODO (caching): this side-steps the issue of texture proxies cached by unique ID
sk_sp<GrTextureProxy> GrClipStackClip::createAlphaClipMask(GrContext* context,
const GrReducedClip& reducedClip) const {
- GrTextureProvider* texProvider = context->textureProvider();
+ GrResourceProvider* resourceProvider = context->resourceProvider();
GrUniqueKey key;
create_clip_mask_key(reducedClip.elementsGenID(), reducedClip.ibounds(), &key);
- sk_sp<GrTexture> texture(texProvider->findAndRefTextureByUniqueKey(key));
+ sk_sp<GrTexture> texture(resourceProvider->findAndRefTextureByUniqueKey(key));
if (texture) {
return GrSurfaceProxy::MakeWrapped(std::move(texture));
}
@@ -441,12 +441,12 @@
return nullptr;
}
- GrTexture* tex = result->instantiate(context->textureProvider());
+ GrTexture* tex = result->instantiate(context->resourceProvider());
if (!tex) {
return nullptr;
}
- context->textureProvider()->assignUniqueKeyToTexture(key, tex);
+ context->resourceProvider()->assignUniqueKeyToTexture(key, tex);
add_invalidate_on_pop_message(*fStack, reducedClip.elementsGenID(), key);
return result;
@@ -459,7 +459,7 @@
GrUniqueKey key;
create_clip_mask_key(reducedClip.elementsGenID(), reducedClip.ibounds(), &key);
- sk_sp<GrTexture> texture(context->textureProvider()->findAndRefTextureByUniqueKey(key));
+ sk_sp<GrTexture> texture(context->resourceProvider()->findAndRefTextureByUniqueKey(key));
if (texture) {
return GrSurfaceProxy::MakeWrapped(std::move(texture));
}
@@ -517,12 +517,12 @@
sk_sp<GrTextureProxy> result(helper.toTexture(context, SkBackingFit::kApprox));
- GrTexture* tex = result->instantiate(context->textureProvider());
+ GrTexture* tex = result->instantiate(context->resourceProvider());
if (!tex) {
return nullptr;
}
- context->textureProvider()->assignUniqueKeyToTexture(key, tex);
+ context->resourceProvider()->assignUniqueKeyToTexture(key, tex);
add_invalidate_on_pop_message(*fStack, reducedClip.elementsGenID(), key);
return result;
}
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index cc7cba0..49b8c96 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -295,7 +295,7 @@
sk_sp<GrTextureProxy> tempProxy;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
- tempProxy = GrSurfaceProxy::MakeDeferred(this->textureProvider(),
+ tempProxy = GrSurfaceProxy::MakeDeferred(this->resourceProvider(),
*this->caps(),
tempDrawInfo.fTempSurfaceDesc,
SkBackingFit::kApprox,
@@ -329,7 +329,7 @@
return false;
}
}
- GrTexture* texture = tempProxy->instantiate(this->textureProvider());
+ GrTexture* texture = tempProxy->instantiate(this->resourceProvider());
if (!texture) {
return false;
}
@@ -621,7 +621,7 @@
SkBackingFit fit,
SkBudgeted isDstBudgeted) {
- sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(fContext->textureProvider(),
+ sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(fContext->resourceProvider(),
*fContext->caps(), dstDesc,
fit, isDstBudgeted);
if (!proxy) {
@@ -636,7 +636,7 @@
GrWrapOwnership ownership) {
ASSERT_SINGLE_OWNER_PRIV
- sk_sp<GrSurface> surface(fContext->textureProvider()->wrapBackendTexture(desc, ownership));
+ sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTexture(desc, ownership));
if (!surface) {
return nullptr;
}
@@ -657,7 +657,7 @@
ASSERT_SINGLE_OWNER_PRIV
SkASSERT(desc.fFlags & kRenderTarget_GrBackendTextureFlag);
- sk_sp<GrSurface> surface(fContext->textureProvider()->wrapBackendTexture(desc, ownership));
+ sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTexture(desc, ownership));
if (!surface) {
return nullptr;
}
@@ -677,7 +677,7 @@
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
- sk_sp<GrRenderTarget> rt(fContext->textureProvider()->wrapBackendRenderTarget(desc));
+ sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(desc));
if (!rt) {
return nullptr;
}
@@ -786,9 +786,9 @@
sk_sp<GrTexture> tex;
if (SkBackingFit::kExact == fit) {
- tex.reset(this->textureProvider()->createTexture(desc, budgeted));
+ tex.reset(this->resourceProvider()->createTexture(desc, budgeted));
} else {
- tex.reset(this->textureProvider()->createApproxTexture(desc));
+ tex.reset(this->resourceProvider()->createApproxTexture(desc, 0));
}
if (!tex) {
return nullptr;
@@ -821,7 +821,7 @@
desc.fConfig = config;
desc.fSampleCnt = sampleCnt;
- sk_sp<GrTextureProxy> rtp = GrSurfaceProxy::MakeDeferred(this->textureProvider(),
+ sk_sp<GrTextureProxy> rtp = GrSurfaceProxy::MakeDeferred(this->resourceProvider(),
*this->caps(), desc, fit, budgeted);
if (!rtp) {
return nullptr;
diff --git a/src/gpu/GrCoordTransform.cpp b/src/gpu/GrCoordTransform.cpp
index 99b3a09..95f30c0 100644
--- a/src/gpu/GrCoordTransform.cpp
+++ b/src/gpu/GrCoordTransform.cpp
@@ -77,7 +77,7 @@
// MDB TODO: just GrCaps is needed for this method
// MDB TODO: once all the coord transforms take a proxy just store it here and
// instantiate later
- fTexture = proxy->instantiate(context->textureProvider());
+ fTexture = proxy->instantiate(context->resourceProvider());
fNormalize = normalize;
fReverseY = kBottomLeft_GrSurfaceOrigin == proxy->origin();
diff --git a/src/gpu/GrDrawOpAtlas.cpp b/src/gpu/GrDrawOpAtlas.cpp
index e9fd356..143bdd8 100644
--- a/src/gpu/GrDrawOpAtlas.cpp
+++ b/src/gpu/GrDrawOpAtlas.cpp
@@ -28,7 +28,7 @@
// guarantee we do not recieve a texture with pending IO
// TODO: Determine how to avoid having to do this. (https://bug.skia.org/4156)
static const uint32_t kFlags = GrResourceProvider::kNoPendingIO_Flag;
- sk_sp<GrTexture> texture(ctx->textureProvider()->createApproxTexture(desc, kFlags));
+ sk_sp<GrTexture> texture(ctx->resourceProvider()->createApproxTexture(desc, kFlags));
if (!texture) {
return nullptr;
}
@@ -210,7 +210,7 @@
// MDB TODO: this is currently fine since the atlas' proxy is always pre-instantiated.
// Once it is deferred more care must be taken upon instantiation failure.
- GrTexture* texture = fProxy->instantiate(fContext->textureProvider());
+ GrTexture* texture = fProxy->instantiate(fContext->resourceProvider());
if (!texture) {
return false;
}
@@ -289,7 +289,7 @@
sk_sp<Plot> plotsp(SkRef(newPlot.get()));
// MDB TODO: this is currently fine since the atlas' proxy is always pre-instantiated.
// Once it is deferred more care must be taken upon instantiation failure.
- GrTexture* texture = fProxy->instantiate(fContext->textureProvider());
+ GrTexture* texture = fProxy->instantiate(fContext->resourceProvider());
if (!texture) {
return false;
}
diff --git a/src/gpu/GrDrawingManager.cpp b/src/gpu/GrDrawingManager.cpp
index 3a7110e..d670e16 100644
--- a/src/gpu/GrDrawingManager.cpp
+++ b/src/gpu/GrDrawingManager.cpp
@@ -219,7 +219,7 @@
if (!pr && allowSW) {
if (!fSoftwarePathRenderer) {
fSoftwarePathRenderer =
- new GrSoftwarePathRenderer(fContext->textureProvider(),
+ new GrSoftwarePathRenderer(fContext->resourceProvider(),
fOptionsForPathRendererChain.fAllowPathMaskCaching);
}
if (fSoftwarePathRenderer->canDrawPath(args)) {
@@ -256,7 +256,7 @@
if (useDIF && fContext->caps()->shaderCaps()->pathRenderingSupport() &&
rtp->isStencilBufferMultisampled()) {
// TODO: defer stencil buffer attachment for PathRenderingDrawContext
- sk_sp<GrRenderTarget> rt(sk_ref_sp(rtp->instantiate(fContext->textureProvider())));
+ sk_sp<GrRenderTarget> rt(sk_ref_sp(rtp->instantiate(fContext->resourceProvider())));
if (!rt) {
return nullptr;
}
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 201b22c..3abe8f8 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -122,17 +122,17 @@
}
/**
- * Implements GrTextureProvider::wrapBackendTexture
+ * Implements GrResourceProvider::wrapBackendTexture
*/
sk_sp<GrTexture> wrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership);
/**
- * Implements GrTextureProvider::wrapBackendRenderTarget
+ * Implements GrResourceProvider::wrapBackendRenderTarget
*/
sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTargetDesc&,GrWrapOwnership);
/**
- * Implements GrTextureProvider::wrapBackendTextureAsRenderTarget
+ * Implements GrResourceProvider::wrapBackendTextureAsRenderTarget
*/
sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&);
@@ -480,14 +480,14 @@
// Determines whether a texture will need to be rescaled in order to be used with the
// GrSamplerParams. This variation is called when the caller will create a new texture using the
- // texture provider from a non-texture src (cpu-backed image, ...).
+ // resource provider from a non-texture src (cpu-backed image, ...).
bool makeCopyForTextureParams(int width, int height, const GrSamplerParams&,
GrTextureProducer::CopyParams*, SkScalar scaleAdjust[2]) const;
// Like the above but this variation should be called when the caller is not creating the
// original texture but rather was handed the original texture. It adds additional checks
// relevant to original textures that were created external to Skia via
- // GrTextureProvider::wrap methods.
+ // GrResourceProvider::wrap methods.
bool makeCopyForTextureParams(GrTexture* texture, const GrSamplerParams& params,
GrTextureProducer::CopyParams* copyParams,
SkScalar scaleAdjust[2]) const {
diff --git a/src/gpu/GrProcessor.cpp b/src/gpu/GrProcessor.cpp
index 8214d2c..2365c21 100644
--- a/src/gpu/GrProcessor.cpp
+++ b/src/gpu/GrProcessor.cpp
@@ -208,18 +208,18 @@
this->reset(texture, filterMode, tileXAndY, visibility);
}
-GrProcessor::TextureSampler::TextureSampler(GrTextureProvider* texProvider,
+GrProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
sk_sp<GrTextureProxy> proxy,
const GrSamplerParams& params) {
- this->reset(texProvider, std::move(proxy), params);
+ this->reset(resourceProvider, std::move(proxy), params);
}
-GrProcessor::TextureSampler::TextureSampler(GrTextureProvider* texProvider,
+GrProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
sk_sp<GrTextureProxy> proxy,
GrSamplerParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
- this->reset(texProvider, std::move(proxy), filterMode, tileXAndY, visibility);
+ this->reset(resourceProvider, std::move(proxy), filterMode, tileXAndY, visibility);
}
void GrProcessor::TextureSampler::reset(GrTexture* texture,
@@ -243,13 +243,13 @@
fVisibility = visibility;
}
-void GrProcessor::TextureSampler::reset(GrTextureProvider* texProvider,
+void GrProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
sk_sp<GrTextureProxy> proxy,
const GrSamplerParams& params,
GrShaderFlags visibility) {
// For now, end the deferral at this time. Once all the TextureSamplers are swapped over
// to taking a GrSurfaceProxy just use the IORefs on the proxy
- GrTexture* texture = proxy->instantiate(texProvider);
+ GrTexture* texture = proxy->instantiate(resourceProvider);
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
fParams = params;
@@ -257,14 +257,14 @@
fVisibility = visibility;
}
-void GrProcessor::TextureSampler::reset(GrTextureProvider* texProvider,
+void GrProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
sk_sp<GrTextureProxy> proxy,
GrSamplerParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
// For now, end the deferral at this time. Once all the TextureSamplers are swapped over
// to taking a GrSurfaceProxy just use the IORefs on the proxy
- GrTexture* texture = proxy->instantiate(texProvider);
+ GrTexture* texture = proxy->instantiate(resourceProvider);
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
filterMode = SkTMin(filterMode, texture->texturePriv().highestFilterMode());
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 8b6de51..1ddf8df 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -112,7 +112,7 @@
}
GrRenderTarget* GrRenderTargetContext::instantiate() {
- return fRenderTargetProxy->instantiate(fContext->textureProvider());
+ return fRenderTargetProxy->instantiate(fContext->resourceProvider());
}
GrTextureProxy* GrRenderTargetContext::asTextureProxy() {
@@ -144,14 +144,14 @@
GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrRenderTargetContext::copy");
// TODO: defer instantiation until flush time
- sk_sp<GrSurface> src(sk_ref_sp(srcProxy->instantiate(fContext->textureProvider())));
+ sk_sp<GrSurface> src(sk_ref_sp(srcProxy->instantiate(fContext->resourceProvider())));
if (!src) {
return false;
}
// TODO: This needs to be fixed up since it ends the deferral of the GrRenderTarget.
sk_sp<GrRenderTarget> rt(
- sk_ref_sp(fRenderTargetProxy->instantiate(fContext->textureProvider())));
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
if (!rt) {
return false;
}
@@ -175,7 +175,7 @@
// Deferral of the VRAM resources must end in this instance anyway
sk_sp<GrRenderTarget> rt(
- sk_ref_sp(fRenderTargetProxy->instantiate(fContext->textureProvider())));
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
if (!rt) {
return false;
}
@@ -198,7 +198,7 @@
// Deferral of the VRAM resources must end in this instance anyway
sk_sp<GrRenderTarget> rt(
- sk_ref_sp(fRenderTargetProxy->instantiate(fContext->textureProvider())));
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
if (!rt) {
return false;
}
@@ -261,7 +261,7 @@
// TODO: This needs to be fixed up since it ends the deferral of the GrRenderTarget.
sk_sp<GrRenderTarget> rt(
- sk_ref_sp(fRenderTargetProxy->instantiate(fContext->textureProvider())));
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
if (!rt) {
return;
}
@@ -1313,7 +1313,7 @@
// Deferral of the VRAM resources must end in this instance anyway
sk_sp<GrRenderTarget> rt(
- sk_ref_sp(fRenderTargetProxy->instantiate(fContext->textureProvider())));
+ sk_ref_sp(fRenderTargetProxy->instantiate(fContext->resourceProvider())));
if (!rt) {
return;
}
diff --git a/src/gpu/GrRenderTargetProxy.cpp b/src/gpu/GrRenderTargetProxy.cpp
index 34d67be..44f23d4 100644
--- a/src/gpu/GrRenderTargetProxy.cpp
+++ b/src/gpu/GrRenderTargetProxy.cpp
@@ -11,7 +11,7 @@
#include "GrGpuResourcePriv.h"
#include "GrRenderTargetOpList.h"
#include "GrRenderTargetPriv.h"
-#include "GrTextureProvider.h"
+#include "GrResourceProvider.h"
#include "GrTextureRenderTargetProxy.h"
// Deferred version
@@ -43,10 +43,10 @@
: 0;
}
-GrRenderTarget* GrRenderTargetProxy::instantiate(GrTextureProvider* texProvider) {
+GrRenderTarget* GrRenderTargetProxy::instantiate(GrResourceProvider* resourceProvider) {
SkASSERT(fDesc.fFlags & GrSurfaceFlags::kRenderTarget_GrSurfaceFlag);
- GrSurface* surf = INHERITED::instantiate(texProvider);
+ GrSurface* surf = INHERITED::instantiate(resourceProvider);
if (!surf || !surf->asRenderTarget()) {
return nullptr;
}
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index 272c6a6..636f16c 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -16,16 +16,198 @@
#include "GrResourceCache.h"
#include "GrResourceKey.h"
#include "GrStencilAttachment.h"
+#include "GrTexturePriv.h"
+#include "../private/GrSingleOwner.h"
#include "SkMathPriv.h"
GR_DECLARE_STATIC_UNIQUE_KEY(gQuadIndexBufferKey);
+const int GrResourceProvider::kMinScratchTextureSize = 16;
+
+#define ASSERT_SINGLE_OWNER \
+ SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fSingleOwner);)
+
GrResourceProvider::GrResourceProvider(GrGpu* gpu, GrResourceCache* cache, GrSingleOwner* owner)
- : INHERITED(gpu, cache, owner) {
+ : fCache(cache)
+ , fGpu(gpu)
+#ifdef SK_DEBUG
+ , fSingleOwner(owner)
+#endif
+ {
GR_DEFINE_STATIC_UNIQUE_KEY(gQuadIndexBufferKey);
fQuadIndexBufferKey = gQuadIndexBufferKey;
}
+
+GrTexture* GrResourceProvider::createMipMappedTexture(const GrSurfaceDesc& desc,
+ SkBudgeted budgeted, const GrMipLevel* texels,
+ int mipLevelCount, uint32_t flags) {
+ ASSERT_SINGLE_OWNER
+
+ if (this->isAbandoned()) {
+ return nullptr;
+ }
+ if (mipLevelCount && !texels) {
+ return nullptr;
+ }
+ for (int i = 0; i < mipLevelCount; ++i) {
+ if (!texels[i].fPixels) {
+ return nullptr;
+ }
+ }
+ if (mipLevelCount > 1 && GrPixelConfigIsSint(desc.fConfig)) {
+ return nullptr;
+ }
+ if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
+ !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+ return nullptr;
+ }
+ if (!GrPixelConfigIsCompressed(desc.fConfig)) {
+ if (mipLevelCount < 2) {
+ flags |= kExact_Flag | kNoCreate_Flag;
+ if (GrTexture* texture = this->refScratchTexture(desc, flags)) {
+ if (!mipLevelCount ||
+ texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+ texels[0].fPixels, texels[0].fRowBytes)) {
+ if (SkBudgeted::kNo == budgeted) {
+ texture->resourcePriv().makeUnbudgeted();
+ }
+ return texture;
+ }
+ texture->unref();
+ }
+ }
+ }
+
+ SkTArray<GrMipLevel> texelsShallowCopy(mipLevelCount);
+ for (int i = 0; i < mipLevelCount; ++i) {
+ texelsShallowCopy.push_back(texels[i]);
+ }
+ return fGpu->createTexture(desc, budgeted, texelsShallowCopy);
+}
+
+GrTexture* GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+ const void* srcData, size_t rowBytes, uint32_t flags) {
+ GrMipLevel tempTexels;
+ GrMipLevel* texels = nullptr;
+ int levelCount = 0;
+ if (srcData) {
+ tempTexels.fPixels = srcData;
+ tempTexels.fRowBytes = rowBytes;
+ texels = &tempTexels;
+ levelCount = 1;
+ }
+ return this->createMipMappedTexture(desc, budgeted, texels, levelCount, flags);
+}
+
+GrTexture* GrResourceProvider::createApproxTexture(const GrSurfaceDesc& desc, uint32_t flags) {
+ ASSERT_SINGLE_OWNER
+ SkASSERT(0 == flags || kNoPendingIO_Flag == flags);
+ return this->internalCreateApproxTexture(desc, flags);
+}
+
+GrTexture* GrResourceProvider::internalCreateApproxTexture(const GrSurfaceDesc& desc,
+ uint32_t scratchFlags) {
+ ASSERT_SINGLE_OWNER
+ if (this->isAbandoned()) {
+ return nullptr;
+ }
+ // Currently we don't recycle compressed textures as scratch.
+ if (GrPixelConfigIsCompressed(desc.fConfig)) {
+ return nullptr;
+ } else {
+ return this->refScratchTexture(desc, scratchFlags);
+ }
+}
+
+GrTexture* GrResourceProvider::refScratchTexture(const GrSurfaceDesc& inDesc,
+ uint32_t flags) {
+ ASSERT_SINGLE_OWNER
+ SkASSERT(!this->isAbandoned());
+ SkASSERT(!GrPixelConfigIsCompressed(inDesc.fConfig));
+
+ SkTCopyOnFirstWrite<GrSurfaceDesc> desc(inDesc);
+
+ if (fGpu->caps()->reuseScratchTextures() || (desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
+ if (!(kExact_Flag & flags)) {
+ // bin by pow2 with a reasonable min
+ GrSurfaceDesc* wdesc = desc.writable();
+ wdesc->fWidth = SkTMax(kMinScratchTextureSize, GrNextPow2(desc->fWidth));
+ wdesc->fHeight = SkTMax(kMinScratchTextureSize, GrNextPow2(desc->fHeight));
+ }
+
+ GrScratchKey key;
+ GrTexturePriv::ComputeScratchKey(*desc, &key);
+ uint32_t scratchFlags = 0;
+ if (kNoPendingIO_Flag & flags) {
+ scratchFlags = GrResourceCache::kRequireNoPendingIO_ScratchFlag;
+ } else if (!(desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
+ // If it is not a render target then it will most likely be populated by
+ // writePixels() which will trigger a flush if the texture has pending IO.
+ scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
+ }
+ GrGpuResource* resource = fCache->findAndRefScratchResource(key,
+ GrSurface::WorstCaseSize(*desc),
+ scratchFlags);
+ if (resource) {
+ GrSurface* surface = static_cast<GrSurface*>(resource);
+ GrRenderTarget* rt = surface->asRenderTarget();
+ if (rt && fGpu->caps()->discardRenderTargetSupport()) {
+ rt->discard();
+ }
+ return surface->asTexture();
+ }
+ }
+
+ if (!(kNoCreate_Flag & flags)) {
+ return fGpu->createTexture(*desc, SkBudgeted::kYes);
+ }
+
+ return nullptr;
+}
+
+sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTextureDesc& desc,
+ GrWrapOwnership ownership) {
+ ASSERT_SINGLE_OWNER
+ if (this->isAbandoned()) {
+ return nullptr;
+ }
+ return fGpu->wrapBackendTexture(desc, ownership);
+}
+
+sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendRenderTarget(
+ const GrBackendRenderTargetDesc& desc)
+{
+ ASSERT_SINGLE_OWNER
+ return this->isAbandoned() ? nullptr
+ : fGpu->wrapBackendRenderTarget(desc, kBorrow_GrWrapOwnership);
+}
+
+void GrResourceProvider::assignUniqueKeyToResource(const GrUniqueKey& key,
+ GrGpuResource* resource) {
+ ASSERT_SINGLE_OWNER
+ if (this->isAbandoned() || !resource) {
+ return;
+ }
+ resource->resourcePriv().setUniqueKey(key);
+}
+
+GrGpuResource* GrResourceProvider::findAndRefResourceByUniqueKey(const GrUniqueKey& key) {
+ ASSERT_SINGLE_OWNER
+ return this->isAbandoned() ? nullptr : fCache->findAndRefUniqueResource(key);
+}
+
+GrTexture* GrResourceProvider::findAndRefTextureByUniqueKey(const GrUniqueKey& key) {
+ ASSERT_SINGLE_OWNER
+ GrGpuResource* resource = this->findAndRefResourceByUniqueKey(key);
+ if (resource) {
+ GrTexture* texture = static_cast<GrSurface*>(resource)->asTexture();
+ SkASSERT(texture);
+ return texture;
+ }
+ return NULL;
+}
+
const GrBuffer* GrResourceProvider::createInstancedIndexBuffer(const uint16_t* pattern,
int patternSize,
int reps,
diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h
index c0d1a50..5ecaac3 100644
--- a/src/gpu/GrResourceProvider.h
+++ b/src/gpu/GrResourceProvider.h
@@ -9,12 +9,9 @@
#define GrResourceProvider_DEFINED
#include "GrBuffer.h"
-#include "GrDrawOpAtlas.h"
#include "GrGpu.h"
#include "GrPathRange.h"
-#include "GrTextureProvider.h"
-class GrDrawOpAtlas;
class GrPath;
class GrRenderTarget;
class GrSingleOwner;
@@ -25,15 +22,12 @@
class SkTypeface;
/**
- * An extension of the texture provider for arbitrary resource types. This class is intended for
- * use within the Gr code base, not by clients or extensions (e.g. third party GrProcessor
- * derivatives).
+ * A factory for arbitrary resource types. This class is intended for use within the Gr code base.
*
- * This currently inherits from GrTextureProvider non-publically to force callers to provider
- * make a flags (pendingIO) decision and not use the GrTP methods that don't take flags. This
- * can be relaxed once https://bug.skia.org/4156 is fixed.
+ * Some members force callers to make a flags (pendingIO) decision. This can be relaxed once
+ * https://bug.skia.org/4156 is fixed.
*/
-class GrResourceProvider : protected GrTextureProvider {
+class GrResourceProvider {
public:
GrResourceProvider(GrGpu* gpu, GrResourceCache* cache, GrSingleOwner* owner);
@@ -41,6 +35,85 @@
return static_cast<T*>(this->findAndRefResourceByUniqueKey(key));
}
+ ///////////////////////////////////////////////////////////////////////////
+ // Textures
+
+ /**
+ * Creates a new texture in the resource cache and returns it. The caller owns a
+ * ref on the returned texture which must be balanced by a call to unref.
+ *
+ * @param desc Description of the texture properties.
+ * @param budgeted Does the texture count against the resource cache budget?
+ * @param texels A contiguous array of mipmap levels
+ * @param mipLevelCount The amount of elements in the texels array
+ */
+ GrTexture* createMipMappedTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+ const GrMipLevel* texels, int mipLevelCount,
+ uint32_t flags = 0);
+
+ /**
+ * This function is a shim which creates a SkTArray<GrMipLevel> of size 1.
+ * It then calls createTexture with that SkTArray.
+ *
+ * @param srcData Pointer to the pixel values (optional).
+ * @param rowBytes The number of bytes between rows of the texture. Zero
+ * implies tightly packed rows. For compressed pixel configs, this
+ * field is ignored.
+ */
+ GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, const void* srcData,
+ size_t rowBytes, uint32_t flags = 0);
+
+ /** Shortcut for creating a texture with no initial data to upload. */
+ GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, uint32_t flags = 0) {
+ return this->createTexture(desc, budgeted, nullptr, 0, flags);
+ }
+
+ /** Assigns a unique key to the texture. The texture will be findable via this key using
+ findTextureByUniqueKey(). If an existing texture has this key, it's key will be removed. */
+ void assignUniqueKeyToTexture(const GrUniqueKey& key, GrTexture* texture) {
+ SkASSERT(key.isValid());
+ this->assignUniqueKeyToResource(key, texture);
+ }
+
+ /** Finds a texture by unique key. If the texture is found it is ref'ed and returned. */
+ GrTexture* findAndRefTextureByUniqueKey(const GrUniqueKey& key);
+
+ /**
+ * Finds a texture that approximately matches the descriptor. Will be at least as large in width
+ * and height as desc specifies. If desc specifies that the texture should be a render target
+ * then result will be a render target. Format and sample count will always match the request.
+ * The contents of the texture are undefined. The caller owns a ref on the returned texture and
+ * must balance with a call to unref.
+ */
+ GrTexture* createApproxTexture(const GrSurfaceDesc&, uint32_t flags);
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Wrapped Backend Surfaces
+
+ /**
+ * Wraps an existing texture with a GrTexture object.
+ *
+ * OpenGL: if the object is a texture Gr may change its GL texture params
+ * when it is drawn.
+ *
+ * @return GrTexture object or NULL on failure.
+ */
+ sk_sp<GrTexture> wrapBackendTexture(const GrBackendTextureDesc& desc,
+ GrWrapOwnership = kBorrow_GrWrapOwnership);
+
+ /**
+ * Wraps an existing render target with a GrRenderTarget object. It is
+ * similar to wrapBackendTexture but can be used to draw into surfaces
+ * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
+ * the client will resolve to a texture). Currently wrapped render targets
+ * always use the kBorrow_GrWrapOwnership semantics.
+ *
+ * @return GrRenderTarget object or NULL on failure.
+ */
+ sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
+
+ static const int kMinScratchTextureSize;
+
/**
* Either finds and refs, or creates an index buffer for instanced drawing with a specific
* pattern if the index buffer is not found. If the return is non-null, the caller owns
@@ -89,26 +162,24 @@
GrPathRange* createGlyphs(const SkTypeface*, const SkScalerContextEffects&,
const SkDescriptor*, const GrStyle&);
- using GrTextureProvider::createTexture;
- using GrTextureProvider::assignUniqueKeyToResource;
- using GrTextureProvider::findAndRefResourceByUniqueKey;
- using GrTextureProvider::findAndRefTextureByUniqueKey;
- using GrTextureProvider::abandon;
-
- /** These flags alias/extend GrTextureProvider::ScratchTextureFlags */
+ /** These flags govern which scratch resources we are allowed to return */
enum Flags {
+ kExact_Flag = 0x1,
+
/** If the caller intends to do direct reads/writes to/from the CPU then this flag must be
* set when accessing resources during a GrOpList flush. This includes the execution of
* GrOp objects. The reason is that these memory operations are done immediately and
* will occur out of order WRT the operations being flushed.
* Make this automatic: https://bug.skia.org/4156
*/
- kNoPendingIO_Flag = GrTextureProvider::kNoPendingIO_ScratchTextureFlag,
+ kNoPendingIO_Flag = 0x2,
+
+ kNoCreate_Flag = 0x4,
/** Normally the caps may indicate a preference for client-side buffers. Set this flag when
* creating a buffer to guarantee it resides in GPU memory.
*/
- kRequireGpuMemory_Flag = GrTextureProvider::kLastScratchTextureFlag << 1,
+ kRequireGpuMemory_Flag = 0x8,
};
/**
@@ -125,10 +196,6 @@
GrBuffer* createBuffer(size_t size, GrBufferType intendedType, GrAccessPattern, uint32_t flags,
const void* data = nullptr);
- GrTexture* createApproxTexture(const GrSurfaceDesc& desc, uint32_t flags) {
- SkASSERT(0 == flags || kNoPendingIO_Flag == flags);
- return this->internalCreateApproxTexture(desc, flags);
- }
/**
* If passed in render target already has a stencil buffer, return it. Otherwise attempt to
@@ -136,9 +203,6 @@
*/
GrStencilAttachment* attachStencilAttachment(GrRenderTarget* rt);
- GrContext* context() { return this->gpu()->getContext(); }
- const GrCaps* caps() { return this->gpu()->caps(); }
-
/**
* Wraps an existing texture with a GrRenderTarget object. This is useful when the provided
* texture has a format that cannot be textured from by Skia, but we want to raster to it.
@@ -150,7 +214,40 @@
*/
sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTextureDesc& desc);
+ /**
+ * Assigns a unique key to a resource. If the key is associated with another resource that
+ * association is removed and replaced by this resource.
+ */
+ void assignUniqueKeyToResource(const GrUniqueKey&, GrGpuResource*);
+
+ /**
+ * Finds a resource in the cache, based on the specified key. This is intended for use in
+ * conjunction with addResourceToCache(). The return value will be NULL if not found. The
+ * caller must balance with a call to unref().
+ */
+ GrGpuResource* findAndRefResourceByUniqueKey(const GrUniqueKey&);
+
+ void abandon() {
+ fCache = NULL;
+ fGpu = NULL;
+ }
+
private:
+ GrTexture* internalCreateApproxTexture(const GrSurfaceDesc& desc, uint32_t scratchTextureFlags);
+
+ GrTexture* refScratchTexture(const GrSurfaceDesc&, uint32_t scratchTextureFlags);
+
+ GrResourceCache* cache() { return fCache; }
+ const GrResourceCache* cache() const { return fCache; }
+
+ GrGpu* gpu() { return fGpu; }
+ const GrGpu* gpu() const { return fGpu; }
+
+ bool isAbandoned() const {
+ SkASSERT(SkToBool(fGpu) == SkToBool(fCache));
+ return !SkToBool(fCache);
+ }
+
const GrBuffer* createInstancedIndexBuffer(const uint16_t* pattern,
int patternSize,
int reps,
@@ -159,9 +256,12 @@
const GrBuffer* createQuadIndexBuffer();
+ GrResourceCache* fCache;
+ GrGpu* fGpu;
GrUniqueKey fQuadIndexBufferKey;
- typedef GrTextureProvider INHERITED;
+ // In debug builds we guard against improper thread handling
+ SkDEBUGCODE(mutable GrSingleOwner* fSingleOwner;)
};
#endif
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index 073aec4..f7e518b 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -151,7 +151,7 @@
return nullptr;
}
- return sk_ref_sp(tProxy->instantiate(context->textureProvider()));
+ return sk_ref_sp(tProxy->instantiate(context->resourceProvider()));
}
void GrSWMaskHelper::DrawToTargetWithShapeMask(GrTexture* texture,
diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index 89d8842..4c744fd 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -10,7 +10,6 @@
#include "GrColor.h"
#include "GrRenderTargetContext.h"
-#include "GrTextureProvider.h"
#include "SkAutoPixmapStorage.h"
#include "SkBitmap.h"
#include "SkDraw.h"
@@ -22,7 +21,6 @@
class GrClip;
class GrPaint;
class GrShape;
-class GrTextureProvider;
class GrStyle;
class GrTexture;
struct GrUserStencilSettings;
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index b51ce63..eb5495c 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -10,16 +10,16 @@
#include "GrClip.h"
#include "GrGpuResourcePriv.h"
#include "GrPipelineBuilder.h"
+#include "GrResourceProvider.h"
#include "GrSWMaskHelper.h"
#include "GrSurfaceContextPriv.h"
-#include "GrTextureProvider.h"
#include "ops/GrRectOpFactory.h"
////////////////////////////////////////////////////////////////////////////////
bool GrSoftwarePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
// Pass on any style that applies. The caller will apply the style if a suitable renderer is
// not found and try again with the new GrShape.
- return !args.fShape->style().applies() && SkToBool(fTexProvider) &&
+ return !args.fShape->style().applies() && SkToBool(fResourceProvider) &&
(args.fAAType == GrAAType::kCoverage || args.fAAType == GrAAType::kNone);
}
@@ -129,7 +129,7 @@
bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrSoftwarePathRenderer::onDrawPath");
- if (!fTexProvider) {
+ if (!fResourceProvider) {
return false;
}
@@ -206,7 +206,7 @@
sk_sp<GrTexture> texture;
if (useCache) {
- texture.reset(fTexProvider->findAndRefTextureByUniqueKey(maskKey));
+ texture.reset(fResourceProvider->findAndRefTextureByUniqueKey(maskKey));
}
if (!texture) {
SkBackingFit fit = useCache ? SkBackingFit::kExact : SkBackingFit::kApprox;
@@ -219,7 +219,7 @@
return false;
}
if (useCache) {
- fTexProvider->assignUniqueKeyToTexture(maskKey, texture.get());
+ fResourceProvider->assignUniqueKeyToTexture(maskKey, texture.get());
}
}
if (inverseFilled) {
diff --git a/src/gpu/GrSoftwarePathRenderer.h b/src/gpu/GrSoftwarePathRenderer.h
index 7dec4be..c8d2f8b 100644
--- a/src/gpu/GrSoftwarePathRenderer.h
+++ b/src/gpu/GrSoftwarePathRenderer.h
@@ -10,7 +10,7 @@
#include "GrPathRenderer.h"
-class GrTextureProvider;
+class GrResourceProvider;
/**
* This class uses the software side to render a path to an SkBitmap and
@@ -18,8 +18,8 @@
*/
class GrSoftwarePathRenderer : public GrPathRenderer {
public:
- GrSoftwarePathRenderer(GrTextureProvider* texProvider, bool allowCaching)
- : fTexProvider(texProvider)
+ GrSoftwarePathRenderer(GrResourceProvider* resourceProvider, bool allowCaching)
+ : fResourceProvider(resourceProvider)
, fAllowCaching(allowCaching) {}
private:
static void DrawNonAARect(GrRenderTargetContext* renderTargetContext,
@@ -46,7 +46,7 @@
bool onDrawPath(const DrawPathArgs&) override;
private:
- GrTextureProvider* fTexProvider;
+ GrResourceProvider* fResourceProvider;
bool fAllowCaching;
typedef GrPathRenderer INHERITED;
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index b8fc56d..f95c312 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -12,8 +12,8 @@
#include "GrContextPriv.h"
#include "GrGpuResourcePriv.h"
#include "GrOpList.h"
+#include "GrResourceProvider.h"
#include "GrSurfaceContext.h"
-#include "GrTextureProvider.h"
#include "GrTextureRenderTargetProxy.h"
#include "SkMathPriv.h"
@@ -36,15 +36,15 @@
SkSafeUnref(fLastOpList);
}
-GrSurface* GrSurfaceProxy::instantiate(GrTextureProvider* texProvider) {
+GrSurface* GrSurfaceProxy::instantiate(GrResourceProvider* resourceProvider) {
if (fTarget) {
return fTarget;
}
if (SkBackingFit::kApprox == fFit) {
- fTarget = texProvider->createApproxTexture(fDesc, fFlags);
+ fTarget = resourceProvider->createApproxTexture(fDesc, fFlags);
} else {
- fTarget = texProvider->createTexture(fDesc, fBudgeted, fFlags);
+ fTarget = resourceProvider->createTexture(fDesc, fBudgeted, fFlags);
}
if (!fTarget) {
return nullptr;
@@ -71,7 +71,7 @@
}
if (caps.reuseScratchTextures() || fDesc.fFlags & kRenderTarget_GrSurfaceFlag) {
- return SkTMax(GrTextureProvider::kMinScratchTextureSize, GrNextPow2(fDesc.fWidth));
+ return SkTMax(GrResourceProvider::kMinScratchTextureSize, GrNextPow2(fDesc.fWidth));
}
return fDesc.fWidth;
@@ -87,7 +87,7 @@
}
if (caps.reuseScratchTextures() || fDesc.fFlags & kRenderTarget_GrSurfaceFlag) {
- return SkTMax(GrTextureProvider::kMinScratchTextureSize, GrNextPow2(fDesc.fHeight));
+ return SkTMax(GrResourceProvider::kMinScratchTextureSize, GrNextPow2(fDesc.fHeight));
}
return fDesc.fHeight;
@@ -146,7 +146,7 @@
#include "GrResourceProvider.h"
-sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrTextureProvider* texProvider,
+sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrResourceProvider* resourceProvider,
const GrCaps& caps,
const GrSurfaceDesc& desc,
SkBackingFit fit,
@@ -199,9 +199,9 @@
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
- tex.reset(texProvider->createApproxTexture(copyDesc));
+ tex.reset(resourceProvider->createApproxTexture(copyDesc, 0));
} else {
- tex.reset(texProvider->createTexture(copyDesc, budgeted));
+ tex.reset(resourceProvider->createTexture(copyDesc, budgeted));
}
if (!tex) {
@@ -222,24 +222,25 @@
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(const GrCaps& caps,
- GrTextureProvider* texProvider,
+ GrResourceProvider* resourceProvider,
const GrSurfaceDesc& desc,
SkBudgeted budgeted,
const void* srcData,
size_t rowBytes) {
if (srcData) {
// If we have srcData, for now, we create a wrapped GrTextureProxy
- sk_sp<GrTexture> tex(texProvider->createTexture(desc, budgeted, srcData, rowBytes));
+ sk_sp<GrTexture> tex(resourceProvider->createTexture(desc, budgeted, srcData, rowBytes));
return GrSurfaceProxy::MakeWrapped(std::move(tex));
}
- return GrSurfaceProxy::MakeDeferred(texProvider, caps, desc, SkBackingFit::kExact, budgeted);
+ return GrSurfaceProxy::MakeDeferred(resourceProvider, caps, desc, SkBackingFit::kExact,
+ budgeted);
}
sk_sp<GrSurfaceProxy> GrSurfaceProxy::MakeWrappedBackend(GrContext* context,
GrBackendTextureDesc& desc,
GrWrapOwnership ownership) {
- sk_sp<GrTexture> tex(context->textureProvider()->wrapBackendTexture(desc, ownership));
+ sk_sp<GrTexture> tex(context->resourceProvider()->wrapBackendTexture(desc, ownership));
return GrSurfaceProxy::MakeWrapped(std::move(tex));
}
diff --git a/src/gpu/GrTextureAdjuster.cpp b/src/gpu/GrTextureAdjuster.cpp
index 27f8d6d..63d9a11 100644
--- a/src/gpu/GrTextureAdjuster.cpp
+++ b/src/gpu/GrTextureAdjuster.cpp
@@ -10,8 +10,8 @@
#include "GrContext.h"
#include "GrGpu.h"
#include "GrGpuResourcePriv.h"
+#include "GrResourceProvider.h"
#include "GrTexture.h"
-#include "GrTextureProvider.h"
#include "SkGrPriv.h"
GrTextureAdjuster::GrTextureAdjuster(GrTexture* original, SkAlphaType alphaType,
@@ -49,7 +49,7 @@
GrUniqueKey key;
this->makeCopyKey(copyParams, &key, nullptr);
if (key.isValid()) {
- GrTexture* cachedCopy = context->textureProvider()->findAndRefTextureByUniqueKey(key);
+ GrTexture* cachedCopy = context->resourceProvider()->findAndRefTextureByUniqueKey(key);
if (cachedCopy) {
return cachedCopy;
}
@@ -57,7 +57,7 @@
GrTexture* copy = CopyOnGpu(texture, contentArea, copyParams);
if (copy) {
if (key.isValid()) {
- context->textureProvider()->assignUniqueKeyToTexture(key, copy);
+ context->resourceProvider()->assignUniqueKeyToTexture(key, copy);
this->didCacheCopy(key);
}
}
diff --git a/src/gpu/GrTextureContext.cpp b/src/gpu/GrTextureContext.cpp
index 75c9e30..ffcddbc 100644
--- a/src/gpu/GrTextureContext.cpp
+++ b/src/gpu/GrTextureContext.cpp
@@ -77,7 +77,7 @@
GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrTextureContext::copy");
// TODO: defer instantiation until flush time
- sk_sp<GrSurface> src(sk_ref_sp(srcProxy->instantiate(fContext->textureProvider())));
+ sk_sp<GrSurface> src(sk_ref_sp(srcProxy->instantiate(fContext->resourceProvider())));
if (!src) {
return false;
}
@@ -89,7 +89,7 @@
#endif
// TODO: this needs to be fixed up since it ends the deferrable of the GrTexture
- sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->textureProvider())));
+ sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->resourceProvider())));
if (!tex) {
return false;
}
@@ -122,7 +122,7 @@
}
// Deferral of the VRAM resources must end in this instance anyway
- sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->textureProvider())));
+ sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->resourceProvider())));
if (!tex) {
return false;
}
@@ -145,7 +145,7 @@
}
// Deferral of the VRAM resources must end in this instance anyway
- sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->textureProvider())));
+ sk_sp<GrTexture> tex(sk_ref_sp(fTextureProxy->instantiate(fContext->resourceProvider())));
if (!tex) {
return false;
}
diff --git a/src/gpu/GrTextureMaker.cpp b/src/gpu/GrTextureMaker.cpp
index ac89af7..bd0840b 100644
--- a/src/gpu/GrTextureMaker.cpp
+++ b/src/gpu/GrTextureMaker.cpp
@@ -9,7 +9,7 @@
#include "GrContext.h"
#include "GrGpu.h"
-#include "GrTextureProvider.h"
+#include "GrResourceProvider.h"
GrTexture* GrTextureMaker::refTextureForParams(const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
@@ -33,7 +33,7 @@
GrUniqueKey copyKey;
this->makeCopyKey(copyParams, ©Key, dstColorSpace);
if (copyKey.isValid()) {
- GrTexture* result = fContext->textureProvider()->findAndRefTextureByUniqueKey(copyKey);
+ GrTexture* result = fContext->resourceProvider()->findAndRefTextureByUniqueKey(copyKey);
if (result) {
return result;
}
@@ -45,7 +45,7 @@
}
if (copyKey.isValid()) {
- fContext->textureProvider()->assignUniqueKeyToTexture(copyKey, result);
+ fContext->resourceProvider()->assignUniqueKeyToTexture(copyKey, result);
this->didCacheCopy(copyKey);
}
return result;
diff --git a/src/gpu/GrTextureProvider.cpp b/src/gpu/GrTextureProvider.cpp
deleted file mode 100644
index 3790f27..0000000
--- a/src/gpu/GrTextureProvider.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrTextureProvider.h"
-
-#include "GrCaps.h"
-#include "GrTexturePriv.h"
-#include "GrResourceCache.h"
-#include "GrGpu.h"
-#include "../private/GrSingleOwner.h"
-#include "SkMathPriv.h"
-#include "SkTArray.h"
-#include "SkTLazy.h"
-
-const int GrTextureProvider::kMinScratchTextureSize = 16;
-
-#define ASSERT_SINGLE_OWNER \
- SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fSingleOwner);)
-
-GrTextureProvider::GrTextureProvider(GrGpu* gpu, GrResourceCache* cache, GrSingleOwner* singleOwner)
- : fCache(cache)
- , fGpu(gpu)
-#ifdef SK_DEBUG
- , fSingleOwner(singleOwner)
-#endif
- {
-}
-
-GrTexture* GrTextureProvider::createMipMappedTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
- const GrMipLevel* texels, int mipLevelCount,
- uint32_t flags) {
- ASSERT_SINGLE_OWNER
-
- if (this->isAbandoned()) {
- return nullptr;
- }
- if (mipLevelCount && !texels) {
- return nullptr;
- }
- for (int i = 0; i < mipLevelCount; ++i) {
- if (!texels[i].fPixels) {
- return nullptr;
- }
- }
- if (mipLevelCount > 1 && GrPixelConfigIsSint(desc.fConfig)) {
- return nullptr;
- }
- if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
- !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
- return nullptr;
- }
- if (!GrPixelConfigIsCompressed(desc.fConfig)) {
- if (mipLevelCount < 2) {
- flags |= kExact_ScratchTextureFlag | kNoCreate_ScratchTextureFlag;
- if (GrTexture* texture = this->refScratchTexture(desc, flags)) {
- if (!mipLevelCount ||
- texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
- texels[0].fPixels, texels[0].fRowBytes)) {
- if (SkBudgeted::kNo == budgeted) {
- texture->resourcePriv().makeUnbudgeted();
- }
- return texture;
- }
- texture->unref();
- }
- }
- }
-
- SkTArray<GrMipLevel> texelsShallowCopy(mipLevelCount);
- for (int i = 0; i < mipLevelCount; ++i) {
- texelsShallowCopy.push_back(texels[i]);
- }
- return fGpu->createTexture(desc, budgeted, texelsShallowCopy);
-}
-
-GrTexture* GrTextureProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
- const void* srcData, size_t rowBytes, uint32_t flags) {
- GrMipLevel tempTexels;
- GrMipLevel* texels = nullptr;
- int levelCount = 0;
- if (srcData) {
- tempTexels.fPixels = srcData;
- tempTexels.fRowBytes = rowBytes;
- texels = &tempTexels;
- levelCount = 1;
- }
- return this->createMipMappedTexture(desc, budgeted, texels, levelCount, flags);
-}
-
-GrTexture* GrTextureProvider::createApproxTexture(const GrSurfaceDesc& desc, uint32_t flags) {
- ASSERT_SINGLE_OWNER
- return this->internalCreateApproxTexture(desc, flags);
-}
-
-GrTexture* GrTextureProvider::internalCreateApproxTexture(const GrSurfaceDesc& desc,
- uint32_t scratchFlags) {
- ASSERT_SINGLE_OWNER
- if (this->isAbandoned()) {
- return nullptr;
- }
- // Currently we don't recycle compressed textures as scratch.
- if (GrPixelConfigIsCompressed(desc.fConfig)) {
- return nullptr;
- } else {
- return this->refScratchTexture(desc, scratchFlags);
- }
-}
-
-GrTexture* GrTextureProvider::refScratchTexture(const GrSurfaceDesc& inDesc,
- uint32_t flags) {
- ASSERT_SINGLE_OWNER
- SkASSERT(!this->isAbandoned());
- SkASSERT(!GrPixelConfigIsCompressed(inDesc.fConfig));
-
- SkTCopyOnFirstWrite<GrSurfaceDesc> desc(inDesc);
-
- if (fGpu->caps()->reuseScratchTextures() || (desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
- if (!(kExact_ScratchTextureFlag & flags)) {
- // bin by pow2 with a reasonable min
- GrSurfaceDesc* wdesc = desc.writable();
- wdesc->fWidth = SkTMax(kMinScratchTextureSize, GrNextPow2(desc->fWidth));
- wdesc->fHeight = SkTMax(kMinScratchTextureSize, GrNextPow2(desc->fHeight));
- }
-
- GrScratchKey key;
- GrTexturePriv::ComputeScratchKey(*desc, &key);
- uint32_t scratchFlags = 0;
- if (kNoPendingIO_ScratchTextureFlag & flags) {
- scratchFlags = GrResourceCache::kRequireNoPendingIO_ScratchFlag;
- } else if (!(desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
- // If it is not a render target then it will most likely be populated by
- // writePixels() which will trigger a flush if the texture has pending IO.
- scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
- }
- GrGpuResource* resource = fCache->findAndRefScratchResource(key,
- GrSurface::WorstCaseSize(*desc),
- scratchFlags);
- if (resource) {
- GrSurface* surface = static_cast<GrSurface*>(resource);
- GrRenderTarget* rt = surface->asRenderTarget();
- if (rt && fGpu->caps()->discardRenderTargetSupport()) {
- rt->discard();
- }
- return surface->asTexture();
- }
- }
-
- if (!(kNoCreate_ScratchTextureFlag & flags)) {
- return fGpu->createTexture(*desc, SkBudgeted::kYes);
- }
-
- return nullptr;
-}
-
-sk_sp<GrTexture> GrTextureProvider::wrapBackendTexture(const GrBackendTextureDesc& desc,
- GrWrapOwnership ownership) {
- ASSERT_SINGLE_OWNER
- if (this->isAbandoned()) {
- return nullptr;
- }
- return fGpu->wrapBackendTexture(desc, ownership);
-}
-
-sk_sp<GrRenderTarget> GrTextureProvider::wrapBackendRenderTarget(
- const GrBackendRenderTargetDesc& desc)
-{
- ASSERT_SINGLE_OWNER
- return this->isAbandoned() ? nullptr
- : fGpu->wrapBackendRenderTarget(desc, kBorrow_GrWrapOwnership);
-}
-
-void GrTextureProvider::assignUniqueKeyToResource(const GrUniqueKey& key, GrGpuResource* resource) {
- ASSERT_SINGLE_OWNER
- if (this->isAbandoned() || !resource) {
- return;
- }
- resource->resourcePriv().setUniqueKey(key);
-}
-
-bool GrTextureProvider::existsResourceWithUniqueKey(const GrUniqueKey& key) const {
- ASSERT_SINGLE_OWNER
- return this->isAbandoned() ? false : fCache->hasUniqueKey(key);
-}
-
-GrGpuResource* GrTextureProvider::findAndRefResourceByUniqueKey(const GrUniqueKey& key) {
- ASSERT_SINGLE_OWNER
- return this->isAbandoned() ? nullptr : fCache->findAndRefUniqueResource(key);
-}
-
-GrTexture* GrTextureProvider::findAndRefTextureByUniqueKey(const GrUniqueKey& key) {
- ASSERT_SINGLE_OWNER
- GrGpuResource* resource = this->findAndRefResourceByUniqueKey(key);
- if (resource) {
- GrTexture* texture = static_cast<GrSurface*>(resource)->asTexture();
- SkASSERT(texture);
- return texture;
- }
- return NULL;
-}
diff --git a/src/gpu/GrTextureProvider.h b/src/gpu/GrTextureProvider.h
deleted file mode 100644
index dd139cc..0000000
--- a/src/gpu/GrTextureProvider.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrTextureProvider_DEFINED
-#define GrTextureProvider_DEFINED
-
-#include "GrTexture.h"
-#include "GrTypes.h"
-
-class GrSingleOwner;
-
-class SK_API GrTextureProvider {
-public:
- ///////////////////////////////////////////////////////////////////////////
- // Textures
-
- /**
- * Creates a new texture in the resource cache and returns it. The caller owns a
- * ref on the returned texture which must be balanced by a call to unref.
- *
- * @param desc Description of the texture properties.
- * @param budgeted Does the texture count against the resource cache budget?
- * @param texels A contiguous array of mipmap levels
- * @param mipLevelCount The amount of elements in the texels array
- */
- GrTexture* createMipMappedTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
- const GrMipLevel* texels, int mipLevelCount,
- uint32_t flags = 0);
-
- /**
- * This function is a shim which creates a SkTArray<GrMipLevel> of size 1.
- * It then calls createTexture with that SkTArray.
- *
- * @param srcData Pointer to the pixel values (optional).
- * @param rowBytes The number of bytes between rows of the texture. Zero
- * implies tightly packed rows. For compressed pixel configs, this
- * field is ignored.
- */
- GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, const void* srcData,
- size_t rowBytes, uint32_t flags = 0);
-
- /** Shortcut for creating a texture with no initial data to upload. */
- GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, uint32_t flags = 0) {
- return this->createTexture(desc, budgeted, nullptr, 0, flags);
- }
-
- /** Assigns a unique key to the texture. The texture will be findable via this key using
- findTextureByUniqueKey(). If an existing texture has this key, it's key will be removed. */
- void assignUniqueKeyToTexture(const GrUniqueKey& key, GrTexture* texture) {
- SkASSERT(key.isValid());
- this->assignUniqueKeyToResource(key, texture);
- }
-
- /** Finds a texture by unique key. If the texture is found it is ref'ed and returned. */
- GrTexture* findAndRefTextureByUniqueKey(const GrUniqueKey& key);
-
- /**
- * Determines whether a texture is associated with the unique key. If the texture is found it
- * will not be locked or returned. This call does not affect the priority of the resource for
- * deletion.
- */
- bool existsTextureWithUniqueKey(const GrUniqueKey& key) const {
- return this->existsResourceWithUniqueKey(key);
- }
-
- /**
- * Finds a texture that approximately matches the descriptor. Will be at least as large in width
- * and height as desc specifies. If desc specifies that the texture should be a render target
- * then result will be a render target. Format and sample count will always match the request.
- * The contents of the texture are undefined. The caller owns a ref on the returned texture and
- * must balance with a call to unref.
- */
- GrTexture* createApproxTexture(const GrSurfaceDesc&, uint32_t flags = 0);
-
- /** Legacy function that no longer should be used. */
- enum ScratchTexMatch {
- kExact_ScratchTexMatch,
- kApprox_ScratchTexMatch
- };
- GrTexture* refScratchTexture(const GrSurfaceDesc& desc, ScratchTexMatch match, uint32_t flags) {
- if (kApprox_ScratchTexMatch == match) {
- return this->createApproxTexture(desc, flags);
- } else {
- return this->createTexture(desc, SkBudgeted::kYes, flags);
- }
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // Wrapped Backend Surfaces
-
- /**
- * Wraps an existing texture with a GrTexture object.
- *
- * OpenGL: if the object is a texture Gr may change its GL texture params
- * when it is drawn.
- *
- * @return GrTexture object or NULL on failure.
- */
- sk_sp<GrTexture> wrapBackendTexture(const GrBackendTextureDesc& desc,
- GrWrapOwnership = kBorrow_GrWrapOwnership);
-
- /**
- * Wraps an existing render target with a GrRenderTarget object. It is
- * similar to wrapBackendTexture but can be used to draw into surfaces
- * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
- * the client will resolve to a texture). Currently wrapped render targets
- * always use the kBorrow_GrWrapOwnership semantics.
- *
- * @return GrRenderTarget object or NULL on failure.
- */
- sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
-
- static const int kMinScratchTextureSize;
-
-protected:
- GrTextureProvider(GrGpu* gpu, GrResourceCache* cache, GrSingleOwner* singleOwner);
-
- /**
- * Assigns a unique key to a resource. If the key is associated with another resource that
- * association is removed and replaced by this resource.
- */
- void assignUniqueKeyToResource(const GrUniqueKey&, GrGpuResource*);
-
- /**
- * Finds a resource in the cache, based on the specified key. This is intended for use in
- * conjunction with addResourceToCache(). The return value will be NULL if not found. The
- * caller must balance with a call to unref().
- */
- GrGpuResource* findAndRefResourceByUniqueKey(const GrUniqueKey&);
-
- /**
- * Determines whether a resource is in the cache. If the resource is found it
- * will not be locked or returned. This call does not affect the priority of
- * the resource for deletion.
- */
- bool existsResourceWithUniqueKey(const GrUniqueKey& key) const;
-
- enum ScratchTextureFlags {
- kExact_ScratchTextureFlag = 0x1,
- kNoPendingIO_ScratchTextureFlag = 0x2, // (http://skbug.com/4156)
- kNoCreate_ScratchTextureFlag = 0x4,
- kLastScratchTextureFlag = kNoCreate_ScratchTextureFlag
- };
-
- /** A common impl for GrTextureProvider and GrResourceProvider variants. */
- GrTexture* internalCreateApproxTexture(const GrSurfaceDesc& desc, uint32_t scratchTextureFlags);
-
- GrTexture* refScratchTexture(const GrSurfaceDesc&, uint32_t scratchTextureFlags);
-
- void abandon() {
- fCache = NULL;
- fGpu = NULL;
- }
-
- GrResourceCache* cache() { return fCache; }
- const GrResourceCache* cache() const { return fCache; }
-
- GrGpu* gpu() { return fGpu; }
- const GrGpu* gpu() const { return fGpu; }
-
- bool isAbandoned() const {
- SkASSERT(SkToBool(fGpu) == SkToBool(fCache));
- return !SkToBool(fCache);
- }
-
-private:
- GrResourceCache* fCache;
- GrGpu* fGpu;
-
- // In debug builds we guard against improper thread handling
- SkDEBUGCODE(mutable GrSingleOwner* fSingleOwner;)
-};
-
-#endif
diff --git a/src/gpu/GrTextureProxy.cpp b/src/gpu/GrTextureProxy.cpp
index 9a65140..0b34309 100644
--- a/src/gpu/GrTextureProxy.cpp
+++ b/src/gpu/GrTextureProxy.cpp
@@ -7,7 +7,7 @@
#include "GrTextureProxy.h"
-#include "GrTextureProvider.h"
+#include "GrResourceProvider.h"
GrTextureProxy::GrTextureProxy(const GrSurfaceDesc& srcDesc, SkBackingFit fit, SkBudgeted budgeted,
const void* srcData, size_t /*rowBytes*/, uint32_t flags)
@@ -19,8 +19,8 @@
: INHERITED(std::move(surf), SkBackingFit::kExact) {
}
-GrTexture* GrTextureProxy::instantiate(GrTextureProvider* texProvider) {
- GrSurface* surf = this->INHERITED::instantiate(texProvider);
+GrTexture* GrTextureProxy::instantiate(GrResourceProvider* resourceProvider) {
+ GrSurface* surf = this->INHERITED::instantiate(resourceProvider);
if (!surf) {
return nullptr;
}
diff --git a/src/gpu/GrTextureToYUVPlanes.cpp b/src/gpu/GrTextureToYUVPlanes.cpp
index 132b680..683bd63 100644
--- a/src/gpu/GrTextureToYUVPlanes.cpp
+++ b/src/gpu/GrTextureToYUVPlanes.cpp
@@ -10,9 +10,9 @@
#include "effects/GrYUVEffect.h"
#include "GrClip.h"
#include "GrContext.h"
-#include "GrRenderTargetContext.h"
#include "GrPaint.h"
-#include "GrTextureProvider.h"
+#include "GrRenderTargetContext.h"
+#include "GrResourceProvider.h"
namespace {
using MakeFPProc = sk_sp<GrFragmentProcessor> (*)(sk_sp<GrFragmentProcessor>,
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 6eaba4c..c3d197e 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -13,8 +13,8 @@
#include "GrContext.h"
#include "GrGpuResourcePriv.h"
#include "GrRenderTargetContext.h"
+#include "GrResourceProvider.h"
#include "GrTexturePriv.h"
-#include "GrTextureProvider.h"
#include "GrTextureProxy.h"
#include "GrTypes.h"
#include "GrXferProcessor.h"
@@ -162,7 +162,7 @@
desc = GrImageInfoToSurfaceDesc(pmap->info(), *caps);
}
- return ctx->textureProvider()->createTexture(desc, budgeted, pmap->addr(),
+ return ctx->resourceProvider()->createTexture(desc, budgeted, pmap->addr(),
pmap->rowBytes());
}
@@ -240,10 +240,10 @@
}
{
- GrTexture* texture = ctx->textureProvider()->createMipMappedTexture(desc,
- SkBudgeted::kYes,
- texels.get(),
- mipLevelCount);
+ GrTexture* texture = ctx->resourceProvider()->createMipMappedTexture(desc,
+ SkBudgeted::kYes,
+ texels.get(),
+ mipLevelCount);
if (texture) {
texture->texturePriv().setMipColorMode(colorMode);
}
@@ -258,8 +258,8 @@
}
const GrCaps* caps = ctx->caps();
- return ctx->textureProvider()->createMipMappedTexture(GrImageInfoToSurfaceDesc(info, *caps),
- SkBudgeted::kYes, texels,
+ return ctx->resourceProvider()->createMipMappedTexture(GrImageInfoToSurfaceDesc(info, *caps),
+ SkBudgeted::kYes, texels,
mipLevelCount);
}
@@ -284,12 +284,12 @@
sk_sp<GrTexture> tex;
if (originalKey.isValid()) {
- tex.reset(context->textureProvider()->findAndRefTextureByUniqueKey(originalKey));
+ tex.reset(context->resourceProvider()->findAndRefTextureByUniqueKey(originalKey));
}
if (!tex) {
tex.reset(GrUploadBitmapToTexture(context, bitmap));
if (tex && originalKey.isValid()) {
- context->textureProvider()->assignUniqueKeyToTexture(originalKey, tex.get());
+ context->resourceProvider()->assignUniqueKeyToTexture(originalKey, tex.get());
GrInstallBitmapUniqueKeyInvalidator(originalKey, bitmap.pixelRef());
}
}
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp
index bbce742..8283910 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -127,7 +127,7 @@
: fColor(color)
, fLocalMatrix(localMatrix)
, fUsesLocalCoords(usesLocalCoords)
- , fTextureSampler(context->textureProvider(), std::move(proxy), params)
+ , fTextureSampler(context->resourceProvider(), std::move(proxy), params)
, fInColor(nullptr)
, fMaskFormat(format) {
this->initClassID<GrBitmapTextGeoProc>();
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 6a4cca5..d629902 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -219,7 +219,7 @@
desc.fConfig = kConfig;
sk_sp<GrTextureProxy> dataProxy = GrSurfaceProxy::MakeDeferred(*context->caps(),
- context->textureProvider(),
+ context->resourceProvider(),
desc, SkBudgeted::kYes, data, 0);
if (!dataProxy) {
return;
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
index 19f5e2a..a5f68d9 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -234,7 +234,7 @@
bool usesLocalCoords)
: fColor(color)
, fViewMatrix(viewMatrix)
- , fTextureSampler(context->textureProvider(), std::move(proxy), params)
+ , fTextureSampler(context->resourceProvider(), std::move(proxy), params)
#ifdef SK_GAMMA_APPLY_TO_A8
, fDistanceAdjust(distanceAdjust)
#endif
@@ -481,7 +481,7 @@
bool usesLocalCoords)
: fColor(color)
, fViewMatrix(viewMatrix)
- , fTextureSampler(context->textureProvider(), std::move(proxy), params)
+ , fTextureSampler(context->resourceProvider(), std::move(proxy), params)
, fFlags(flags & kNonLCD_DistanceFieldEffectMask)
, fInColor(nullptr)
, fUsesLocalCoords(usesLocalCoords) {
@@ -785,7 +785,7 @@
uint32_t flags, bool usesLocalCoords)
: fColor(color)
, fViewMatrix(viewMatrix)
- , fTextureSampler(context->textureProvider(), std::move(proxy), params)
+ , fTextureSampler(context->resourceProvider(), std::move(proxy), params)
, fDistanceAdjust(distanceAdjust)
, fFlags(flags & kLCD_DistanceFieldEffectMask)
, fUsesLocalCoords(usesLocalCoords) {
diff --git a/src/gpu/effects/GrSingleTextureEffect.cpp b/src/gpu/effects/GrSingleTextureEffect.cpp
index acfc0d1..01cad66 100644
--- a/src/gpu/effects/GrSingleTextureEffect.cpp
+++ b/src/gpu/effects/GrSingleTextureEffect.cpp
@@ -52,7 +52,7 @@
const SkMatrix& m)
: INHERITED(optFlags)
, fCoordTransform(ctx, m, proxy.get(), GrSamplerParams::kNone_FilterMode)
- , fTextureSampler(ctx->textureProvider(), std::move(proxy))
+ , fTextureSampler(ctx->resourceProvider(), std::move(proxy))
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
@@ -65,7 +65,7 @@
GrSamplerParams::FilterMode filterMode)
: INHERITED(optFlags)
, fCoordTransform(ctx, m, proxy.get(), filterMode)
- , fTextureSampler(ctx->textureProvider(), std::move(proxy), filterMode)
+ , fTextureSampler(ctx->resourceProvider(), std::move(proxy), filterMode)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
@@ -77,7 +77,7 @@
const SkMatrix& m, const GrSamplerParams& params)
: INHERITED(optFlags)
, fCoordTransform(ctx, m, proxy.get(), params.filterMode())
- , fTextureSampler(ctx->textureProvider(), std::move(proxy), params)
+ , fTextureSampler(ctx->resourceProvider(), std::move(proxy), params)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp
index 39bc3cc..2ac6af8 100644
--- a/src/gpu/effects/GrTextureDomain.cpp
+++ b/src/gpu/effects/GrTextureDomain.cpp
@@ -423,7 +423,7 @@
const SkIRect& subset,
const SkIPoint& deviceSpaceOffset)
: INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
- , fTextureSampler(context->textureProvider(), proxy, GrSamplerParams::ClampNoFilter())
+ , fTextureSampler(context->resourceProvider(), proxy, GrSamplerParams::ClampNoFilter())
, fTextureDomain(proxy.get(), GrTextureDomain::MakeTexelDomain(subset),
GrTextureDomain::kDecal_Mode) {
this->addTextureSampler(&fTextureSampler);
diff --git a/src/gpu/effects/GrTextureStripAtlas.cpp b/src/gpu/effects/GrTextureStripAtlas.cpp
index 1791b20..df36e65 100644
--- a/src/gpu/effects/GrTextureStripAtlas.cpp
+++ b/src/gpu/effects/GrTextureStripAtlas.cpp
@@ -10,7 +10,6 @@
#include "GrContextPriv.h"
#include "GrResourceProvider.h"
#include "GrSurfaceContext.h"
-#include "GrTextureProvider.h"
#include "SkGr.h"
#include "SkPixelRef.h"
#include "SkTSearch.h"
@@ -209,9 +208,9 @@
builder.finish();
// MDB TODO (caching): this side-steps the issue of proxies with unique IDs
- sk_sp<GrTexture> texture(fDesc.fContext->textureProvider()->findAndRefTextureByUniqueKey(key));
+ sk_sp<GrTexture> texture(fDesc.fContext->resourceProvider()->findAndRefTextureByUniqueKey(key));
if (!texture) {
- texture.reset(fDesc.fContext->textureProvider()->createTexture(
+ texture.reset(fDesc.fContext->resourceProvider()->createTexture(
texDesc, SkBudgeted::kYes,
nullptr, 0,
GrResourceProvider::kNoPendingIO_Flag));
@@ -219,7 +218,7 @@
return;
}
- fDesc.fContext->textureProvider()->assignUniqueKeyToTexture(key, texture.get());
+ fDesc.fContext->resourceProvider()->assignUniqueKeyToTexture(key, texture.get());
// This is a new texture, so all of our cache info is now invalid
this->initLRU();
fKeyTable.rewind();
diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp
index e09e185..78ac9ba 100644
--- a/src/gpu/effects/GrYUVEffect.cpp
+++ b/src/gpu/effects/GrYUVEffect.cpp
@@ -159,10 +159,10 @@
GrSamplerParams::FilterMode uvFilterMode, SkYUVColorSpace colorSpace, bool nv12)
: INHERITED(kPreservesOpaqueInput_OptimizationFlag)
, fYTransform(ctx, yuvMatrix[0], yProxy.get(), GrSamplerParams::kNone_FilterMode)
- , fYSampler(ctx->textureProvider(), std::move(yProxy))
+ , fYSampler(ctx->resourceProvider(), std::move(yProxy))
, fUTransform(ctx, yuvMatrix[1], uProxy.get(), uvFilterMode)
- , fUSampler(ctx->textureProvider(), std::move(uProxy), uvFilterMode)
- , fVSampler(ctx->textureProvider(), vProxy, uvFilterMode)
+ , fUSampler(ctx->resourceProvider(), std::move(uProxy), uvFilterMode)
+ , fVSampler(ctx->resourceProvider(), vProxy, uvFilterMode)
, fColorSpace(colorSpace)
, fNV12(nv12) {
this->initClassID<YUVtoRGBEffect>();
diff --git a/src/gpu/effects/GrYUVEffect.h b/src/gpu/effects/GrYUVEffect.h
index 6af442e..524928b 100644
--- a/src/gpu/effects/GrYUVEffect.h
+++ b/src/gpu/effects/GrYUVEffect.h
@@ -12,7 +12,6 @@
class GrContext;
class GrFragmentProcessor;
-class GrTextureProvider;
class GrTextureProxy;
namespace GrYUVEffect {
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index 37a9193..ced5447 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -17,10 +17,10 @@
#include "GrGpu.h"
#include "GrImageTextureMaker.h"
#include "GrRenderTargetContext.h"
+#include "GrResourceProvider.h"
#include "GrSemaphore.h"
#include "GrTextureAdjuster.h"
#include "GrTexturePriv.h"
-#include "GrTextureProvider.h"
#include "GrTextureProxy.h"
#include "effects/GrYUVEffect.h"
#include "SkCanvas.h"
@@ -195,7 +195,7 @@
}
// TODO: make gpu images be proxy-backed so we don't need to do this
- GrSurface* subTx = sContext->asSurfaceProxy()->instantiate(ctx->textureProvider());
+ GrSurface* subTx = sContext->asSurfaceProxy()->instantiate(ctx->resourceProvider());
if (!subTx) {
return nullptr;
}
@@ -215,7 +215,7 @@
if (desc.fWidth <= 0 || desc.fHeight <= 0) {
return nullptr;
}
- sk_sp<GrTexture> tex = ctx->textureProvider()->wrapBackendTexture(desc, ownership);
+ sk_sp<GrTexture> tex = ctx->resourceProvider()->wrapBackendTexture(desc, ownership);
if (!tex) {
return nullptr;
}
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index cf127e5..9fe813f 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -114,7 +114,7 @@
}
// TODO: add proxy-backed SkImage_Gpu
- GrTexture* tex = srcProxy->instantiate(ctx->textureProvider())->asTexture();
+ GrTexture* tex = srcProxy->instantiate(ctx->resourceProvider())->asTexture();
const SkImageInfo info = fDevice->imageInfo();
sk_sp<SkImage> image;