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

Funnel most proxy creation through GrProxyProvider

Browse Source 
This is to provide a choke point for DDL to create Lazy Proxies.

Change-Id: If178da13bc6447b31b7601810236d34502d9efbd
Reviewed-on: https://skia-review.googlesource.com/93303
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
This commit is contained in:
Robert Phillips 2018-01-16 08:06:32 -05:00 committed by Skia Commit-Bot
parent 3167aa0c9c
commit 0bd24dc41f
52 changed files with 652 additions and 655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gm/flippity.cpp
View File

@ -13,6 +13,7 @@
#if SK_SUPPORT_GPU
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "SkImage_Gpu.h"
static const int kNumMatrices = 6;
@ -93,6 +94,7 @@ static SkColor swap_red_and_blue(SkColor c) {
static sk_sp<SkImage> make_reference_image(GrContext* context,
const SkTArray<sk_sp<SkImage>>& labels,
bool bottomLeftOrigin) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkASSERT(kNumLabels == labels.count());
SkImageInfo ii = SkImageInfo::Make(kImageSize, kImageSize,
@ -130,10 +132,8 @@ static sk_sp<SkImage> make_reference_image(GrContext* context,
}
}
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(
context->contextPriv().proxyProvider(),
desc, SkBudgeted::kYes,
bm.getPixels(), bm.rowBytes());
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
bm.getPixels(), bm.rowBytes());
if (!proxy) {
return nullptr;
}

8
gm/texdata.cpp
View File

@ -12,6 +12,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrTextureContext.h"
#include "GrFixedClip.h"
@ -76,6 +77,7 @@ DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) {
return;
}
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
const SkImageInfo ii = SkImageInfo::Make(S, S, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
@ -91,10 +93,8 @@ DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) {
desc.fHeight = 2 * S;
desc.fConfig = SkImageInfo2GrPixelConfig(ii, *context->caps());
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(
context->contextPriv().proxyProvider(),
desc, SkBudgeted::kNo,
gTextureData.get(), 0);
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
gTextureData.get(), 0);
if (!proxy) {
return;
}

10
gm/texturedomaineffect.cpp
View File

@ -13,6 +13,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContextPriv.h"
#include "SkBitmap.h"
#include "SkGr.h"
@ -86,17 +87,16 @@ protected:
return;
}
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
desc.fWidth = fBmp.width();
desc.fHeight = fBmp.height();
desc.fConfig = SkImageInfo2GrPixelConfig(fBmp.info(), *context->caps());
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
context->contextPriv().proxyProvider(),
desc, SkBudgeted::kYes,
fBmp.getPixels(),
fBmp.rowBytes()));
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
fBmp.getPixels(),
fBmp.rowBytes());
if (!proxy) {
return;
}

16
gm/yuvtorgbeffect.cpp
View File

@ -13,6 +13,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContextPriv.h"
#include "GrTextureProxy.h"
#include "SkBitmap.h"
@ -82,6 +83,7 @@ protected:
return;
}
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> proxy[3];
{
@ -93,9 +95,9 @@ protected:
desc.fHeight = fBmp[i].height();
desc.fConfig = SkImageInfo2GrPixelConfig(fBmp[i].info(), *context->caps());
proxy[i] = GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
desc, SkBudgeted::kYes,
fBmp[i].getPixels(), fBmp[i].rowBytes());
proxy[i] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
fBmp[i].getPixels(),
fBmp[i].rowBytes());
if (!proxy[i]) {
return;
}
@ -210,6 +212,7 @@ protected:
return;
}
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> proxy[3];
{
@ -223,10 +226,9 @@ protected:
desc.fHeight = fBmp[index].height();
desc.fConfig = SkImageInfo2GrPixelConfig(fBmp[index].info(), *context->caps());
proxy[i] = GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
desc, SkBudgeted::kYes,
fBmp[index].getPixels(),
fBmp[index].rowBytes());
proxy[i] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
fBmp[index].getPixels(),
fBmp[index].rowBytes());
if (!proxy[i]) {
return;
}

2
include/private/GrRenderTargetProxy.h
View File

@ -61,7 +61,7 @@ public:
bool refsWrappedObjects() const;
protected:
friend class GrSurfaceProxy; // for ctors
friend class GrProxyProvider; // for ctors
// Deferred version
GrRenderTargetProxy(const GrCaps&, const GrSurfaceDesc&,

39
include/private/GrSurfaceProxy.h
View File

@ -182,45 +182,9 @@ private:
class GrSurfaceProxy : public GrIORefProxy {
public:
static sk_sp<GrSurfaceProxy> MakeWrapped(sk_sp<GrSurface>, GrSurfaceOrigin);
// DDL TODO: remove this entry point
static sk_sp<GrTextureProxy> MakeWrapped(sk_sp<GrTexture>, GrSurfaceOrigin);
static sk_sp<GrTextureProxy> MakeDeferred(GrProxyProvider*,
const GrSurfaceDesc&, SkBackingFit,
SkBudgeted, uint32_t flags = 0);
/**
* Creates a proxy that will be mipmapped.
*
* @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
*/
static sk_sp<GrTextureProxy> MakeDeferredMipMap(GrProxyProvider*,
const GrSurfaceDesc& desc, SkBudgeted budgeted,
const GrMipLevel texels[], int mipLevelCount,
SkDestinationSurfaceColorMode mipColorMode =
SkDestinationSurfaceColorMode::kLegacy);
/**
* Like the call above but there are no texels to upload. A texture proxy is returned that
* simply has space allocated for the mips. We will allocated the full amount of mip levels
* based on the width and height in the GrSurfaceDesc.
*/
static sk_sp<GrTextureProxy> MakeDeferredMipMap(GrProxyProvider*,
const GrSurfaceDesc& desc, SkBudgeted budgeted);
// TODO: need to refine ownership semantics of 'srcData' if we're in completely
// deferred mode
static sk_sp<GrTextureProxy> MakeDeferred(GrProxyProvider*,
const GrSurfaceDesc&, SkBudgeted,
const void* srcData, size_t rowBytes);
static sk_sp<GrTextureProxy> MakeWrappedBackend(GrContext*, const GrBackendTexture&,
GrSurfaceOrigin);
using LazyInstantiateCallback = std::function<sk_sp<GrTexture>(GrResourceProvider*,
GrSurfaceOrigin* outOrigin)>;
@ -234,6 +198,7 @@ public:
* (Stencil is not supported by this method.) The width and height must either both be greater
* than 0 or both less than or equal to zero. A non-positive value is a signal that the width
* and height are currently unknown.
* DDL TODO: remove this entry point
*/
static sk_sp<GrTextureProxy> MakeLazy(LazyInstantiateCallback&&, const GrSurfaceDesc& desc,
GrMipMapped, SkBackingFit fit, SkBudgeted budgeted);

2
include/private/GrTextureProxy.h
View File

@ -61,7 +61,9 @@ public:
const GrTextureProxyPriv texPriv() const;
protected:
// DDL TODO: rm the GrSurfaceProxy friending
friend class GrSurfaceProxy; // for ctors
friend class GrProxyProvider; // for ctors
friend class GrTextureProxyPriv;
// Deferred version

5
src/effects/GrCircleBlurFragmentProcessor.cpp
View File

@ -227,8 +227,9 @@ static sk_sp<GrTextureProxy> create_profile_texture(GrProxyProvider* proxyProvid
create_circle_profile(sigma * scale, circleR * scale, kProfileTextureWidth));
}
blurProfile = GrSurfaceProxy::MakeDeferred(proxyProvider, texDesc, SkBudgeted::kYes,
profile.get(), 0);
// This will be an exact match texture
blurProfile = proxyProvider->createTextureProxy(texDesc, SkBudgeted::kYes,
profile.get(), 0);
if (!blurProfile) {
return nullptr;
}

3
src/gpu/GrBitmapTextureMaker.cpp
View File

@ -49,8 +49,7 @@ sk_sp<GrTextureProxy> GrBitmapTextureMaker::refOriginalTextureProxy(bool willBeM
if (!proxy) {
if (willBeMipped) {
proxy = GrGenerateMipMapsAndUploadToTextureProxy(this->context(), fBitmap,
dstColorSpace);
proxy = GrGenerateMipMapsAndUploadToTextureProxy(proxyProvider, fBitmap, dstColorSpace);
}
if (!proxy) {
proxy = GrUploadBitmapToTextureProxy(proxyProvider, fBitmap, dstColorSpace);

5
src/gpu/GrClipStackClip.cpp
View File

@ -464,9 +464,8 @@ sk_sp<GrTextureProxy> GrClipStackClip::createSoftwareClipMask(
desc.fConfig = kAlpha_8_GrPixelConfig;
// MDB TODO: We're going to fill this proxy with an ASAP upload (which is out of order wrt
// to ops), so it can't have any pending IO.
proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
SkBackingFit::kApprox, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
auto uploader = skstd::make_unique<GrTDeferredProxyUploader<ClipMaskData>>(reducedClip);
GrTDeferredProxyUploader<ClipMaskData>* uploaderRaw = uploader.get();

55
src/gpu/GrContext.cpp
View File

@ -530,10 +530,9 @@ bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst,
sk_sp<GrTextureProxy> tempProxy;
if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
tempProxy = GrSurfaceProxy::MakeDeferred(this->proxyProvider(),
tempDrawInfo.fTempSurfaceDesc,
SkBackingFit::kApprox,
SkBudgeted::kYes);
tempProxy = this->proxyProvider()->createProxy(tempDrawInfo.fTempSurfaceDesc,
SkBackingFit::kApprox,
SkBudgeted::kYes);
if (!tempProxy && GrGpu::kRequireDraw_DrawPreference == drawPreference) {
return false;
}
@ -821,12 +820,10 @@ sk_sp<GrSurfaceContext> GrContextPriv::makeDeferredSurfaceContext(const GrSurfac
sk_sp<GrTextureProxy> proxy;
if (GrMipMapped::kNo == mipMapped) {
proxy = GrSurfaceProxy::MakeDeferred(this->proxyProvider(), dstDesc, fit,
isDstBudgeted);
proxy = this->proxyProvider()->createProxy(dstDesc, fit, isDstBudgeted);
} else {
SkASSERT(SkBackingFit::kExact == fit);
proxy = GrSurfaceProxy::MakeDeferredMipMap(this->proxyProvider(), dstDesc,
isDstBudgeted);
proxy = this->proxyProvider()->createMipMapProxy(dstDesc, isDstBudgeted);
}
if (!proxy) {
return nullptr;
@ -840,12 +837,7 @@ sk_sp<GrTextureContext> GrContextPriv::makeBackendTextureContext(const GrBackend
sk_sp<SkColorSpace> colorSpace) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTexture(tex));
if (!surface) {
return nullptr;
}
sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(surface), origin));
sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedTextureProxy(tex, origin);
if (!proxy) {
return nullptr;
}
@ -861,13 +853,8 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureRenderTargetContex
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrSurface> surface(
fContext->resourceProvider()->wrapRenderableBackendTexture(tex, sampleCnt));
if (!surface) {
return nullptr;
}
sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(surface), origin));
sk_sp<GrTextureProxy> proxy(this->proxyProvider()->createWrappedTextureProxy(tex, origin,
sampleCnt));
if (!proxy) {
return nullptr;
}
@ -883,12 +870,8 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendRenderTargetRenderTargetC
const SkSurfaceProps* surfaceProps) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrRenderTarget> rt(fContext->resourceProvider()->wrapBackendRenderTarget(backendRT));
if (!rt) {
return nullptr;
}
sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(rt), origin));
sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedRenderTargetProxy(backendRT,
origin);
if (!proxy) {
return nullptr;
}
@ -903,24 +886,18 @@ sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureAsRenderTargetRend
GrSurfaceOrigin origin,
int sampleCnt,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps) {
const SkSurfaceProps* props) {
ASSERT_SINGLE_OWNER_PRIV
sk_sp<GrSurface> surface(fContext->resourceProvider()->wrapBackendTextureAsRenderTarget(
tex,
sampleCnt));
if (!surface) {
return nullptr;
}
sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(surface), origin));
sk_sp<GrSurfaceProxy> proxy(this->proxyProvider()->createWrappedRenderTargetProxy(tex, origin,
sampleCnt));
if (!proxy) {
return nullptr;
}
return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace),
surfaceProps);
props);
}
void GrContextPriv::addOnFlushCallbackObject(GrOnFlushCallbackObject* onFlushCBObject) {
@ -987,9 +964,9 @@ sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContext(
sk_sp<GrTextureProxy> rtp;
if (GrMipMapped::kNo == mipMapped) {
rtp = GrSurfaceProxy::MakeDeferred(fProxyProvider, desc, fit, budgeted);
rtp = fProxyProvider->createProxy(desc, fit, budgeted);
} else {
rtp = GrSurfaceProxy::MakeDeferredMipMap(fProxyProvider, desc, budgeted);
rtp = fProxyProvider->createMipMapProxy(desc, budgeted);
}
if (!rtp) {
return nullptr;

22
src/gpu/GrDrawOpAtlas.cpp
View File

@ -8,8 +8,10 @@
#include "GrDrawOpAtlas.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrOpFlushState.h"
#include "GrRectanizer.h"
#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
#include "GrTracing.h"
@ -452,6 +454,8 @@ bool GrDrawOpAtlas::createNewPage() {
return false;
}
GrProxyProvider* proxyProvider = fContext->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
@ -463,16 +467,14 @@ bool GrDrawOpAtlas::createNewPage() {
// 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(fContext->resourceProvider()->createApproxTexture(desc, kFlags));
if (texture) {
// MDB TODO: for now, wrap an instantiated texture. Having the deferred instantiation
// possess the correct properties (e.g., no pendingIO) should fall out of the system but
// should receive special attention.
// Note: When switching over to the deferred proxy, use the kExact flag to create
// the atlas and assert that the width & height are powers of 2.
fProxies[fNumPages] = GrSurfaceProxy::MakeWrapped(std::move(texture),
kTopLeft_GrSurfaceOrigin);
}
// MDB TODO: for now, wrap an instantiated texture. Having the deferred instantiation
// possess the correct properties (e.g., no pendingIO) should fall out of the system but
// should receive special attention.
// Note: When switching over to the deferred proxy, use the kExact flag to create
// the atlas and assert that the width & height are powers of 2.
// DDL TODO: remove this use of createInstantitateProxy & convert it to a testing-only method.
fProxies[fNumPages] = proxyProvider->createInstantiatedProxy(desc, SkBackingFit::kApprox,
SkBudgeted::kYes, kFlags);
if (!fProxies[fNumPages]) {
return false;
}

11
src/gpu/GrOnFlushResourceProvider.cpp
View File

@ -9,6 +9,7 @@
#include "GrContextPriv.h"
#include "GrDrawingManager.h"
#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
sk_sp<GrRenderTargetContext> GrOnFlushResourceProvider::makeRenderTargetContext(
@ -21,12 +22,10 @@ sk_sp<GrRenderTargetContext> GrOnFlushResourceProvider::makeRenderTargetContext(
// Because this is being allocated at the start of a flush we must ensure the proxy
// will, when instantiated, have no pending IO.
// TODO: fold the kNoPendingIO_Flag into GrSurfaceFlags?
sk_sp<GrSurfaceProxy> proxy = GrSurfaceProxy::MakeDeferred(
fDrawingMgr->getContext()->contextPriv().proxyProvider(),
tmpDesc,
SkBackingFit::kExact,
SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
GrProxyProvider* proxyProvider = fDrawingMgr->getContext()->contextPriv().proxyProvider();
sk_sp<GrSurfaceProxy> proxy = proxyProvider->createProxy(tmpDesc, SkBackingFit::kExact,
SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
if (!proxy->asRenderTargetProxy()) {
return nullptr;
}

208
src/gpu/GrProxyProvider.cpp
View File

@ -8,13 +8,16 @@
#include "GrProxyProvider.h"
#include "GrCaps.h"
#include "GrRenderTarget.h"
#include "GrResourceKey.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
#include "GrSurfaceProxyPriv.h"
#include "GrTexture.h"
#include "GrTextureProxyCacheAccess.h"
#include "GrTextureRenderTargetProxy.h"
#include "../private/GrSingleOwner.h"
#include "SkMipMap.h"
#define ASSERT_SINGLE_OWNER \
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fSingleOwner);)
@ -126,24 +129,54 @@ sk_sp<GrTextureProxy> GrProxyProvider::findOrCreateProxyByUniqueKey(const GrUniq
return result;
}
sk_sp<GrTextureProxy> GrProxyProvider::createInstantiatedProxy(const GrSurfaceDesc& desc,
SkBackingFit fit,
SkBudgeted budgeted,
uint32_t flags) {
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = fResourceProvider->createApproxTexture(desc, flags);
} else {
tex = fResourceProvider->createTexture(desc, budgeted, flags);
}
if (!tex) {
return nullptr;
}
SkASSERT(!tex->getUniqueKey().isValid());
if (tex->asRenderTarget()) {
return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), desc.fOrigin));
}
return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), desc.fOrigin));
}
sk_sp<GrTextureProxy> GrProxyProvider::createTextureProxy(const GrSurfaceDesc& desc,
SkBudgeted budgeted,
const GrMipLevel& mipLevel) {
const void* srcData, size_t rowBytes) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
sk_sp<GrTexture> tex = fResourceProvider->createTexture(desc, budgeted, mipLevel);
if (!tex) {
return nullptr;
if (srcData) {
GrMipLevel mipLevel = { srcData, rowBytes };
sk_sp<GrTexture> tex = fResourceProvider->createTexture(desc, budgeted, mipLevel);
if (!tex) {
return nullptr;
}
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
}
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
return this->createProxy(desc, SkBackingFit::kExact, budgeted);
}
sk_sp<GrTextureProxy> GrProxyProvider::createTextureProxy(
sk_sp<GrTextureProxy> GrProxyProvider::createMipMapProxy(
const GrSurfaceDesc& desc, SkBudgeted budgeted,
const GrMipLevel texels[], int mipLevelCount,
SkDestinationSurfaceColorMode mipColorMode) {
@ -153,6 +186,38 @@ sk_sp<GrTextureProxy> GrProxyProvider::createTextureProxy(
return nullptr;
}
if (!mipLevelCount) {
if (texels) {
return nullptr;
}
return this->createProxy(desc, SkBackingFit::kExact, budgeted);
}
if (!texels) {
return nullptr;
}
if (1 == mipLevelCount) {
return this->createTextureProxy(desc, budgeted, texels[0].fPixels, texels[0].fRowBytes);
}
#ifdef SK_DEBUG
// There are only three states we want to be in when uploading data to a mipped surface.
// 1) We have data to upload to all layers
// 2) We are not uploading data to any layers
// 3) We are only uploading data to the base layer
// We check here to make sure we do not have any other state.
bool firstLevelHasData = SkToBool(texels[0].fPixels);
bool allOtherLevelsHaveData = true, allOtherLevelsLackData = true;
for (int i = 1; i < mipLevelCount; ++i) {
if (texels[i].fPixels) {
allOtherLevelsLackData = false;
} else {
allOtherLevelsHaveData = false;
}
}
SkASSERT((firstLevelHasData && allOtherLevelsHaveData) || allOtherLevelsLackData);
#endif
sk_sp<GrTexture> tex(fResourceProvider->createTexture(desc, budgeted,
texels, mipLevelCount,
mipColorMode));
@ -163,6 +228,137 @@ sk_sp<GrTextureProxy> GrProxyProvider::createTextureProxy(
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
}
sk_sp<GrTextureProxy> GrProxyProvider::createMipMapProxy(const GrSurfaceDesc& desc,
SkBudgeted budgeted) {
// SkMipMap doesn't include the base level in the level count so we have to add 1
int mipCount = SkMipMap::ComputeLevelCount(desc.fWidth, desc.fHeight) + 1;
std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipCount]);
// We don't want to upload any texel data
for (int i = 0; i < mipCount; i++) {
texels[i].fPixels = nullptr;
texels[i].fRowBytes = 0;
}
return this->createMipMapProxy(desc, budgeted, texels.get(), mipCount,
SkDestinationSurfaceColorMode::kLegacy);
}
sk_sp<GrTextureProxy> GrProxyProvider::createProxy(const GrSurfaceDesc& desc,
SkBackingFit fit,
SkBudgeted budgeted,
uint32_t flags) {
SkASSERT(0 == flags || GrResourceProvider::kNoPendingIO_Flag == flags);
const GrCaps* caps = this->caps();
// TODO: move this logic into GrResourceProvider!
// TODO: share this testing code with check_texture_creation_params
if (!caps->isConfigTexturable(desc.fConfig)) {
return nullptr;
}
bool willBeRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
if (willBeRT && !caps->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
return nullptr;
}
// We currently do not support multisampled textures
if (!willBeRT && desc.fSampleCnt > 0) {
return nullptr;
}
int maxSize;
if (willBeRT) {
maxSize = caps->maxRenderTargetSize();
} else {
maxSize = caps->maxTextureSize();
}
if (desc.fWidth > maxSize || desc.fHeight > maxSize || desc.fWidth <= 0 || desc.fHeight <= 0) {
return nullptr;
}
GrSurfaceDesc copyDesc = desc;
copyDesc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig);
#ifdef SK_DISABLE_DEFERRED_PROXIES
// Temporarily force instantiation for crbug.com/769760 and crbug.com/769898
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = resourceProvider->createApproxTexture(copyDesc, flags);
} else {
tex = resourceProvider->createTexture(copyDesc, budgeted, flags);
}
if (!tex) {
return nullptr;
}
return GrSurfaceProxy::MakeWrapped(std::move(tex), copyDesc.fOrigin);
#else
if (willBeRT) {
// We know anything we instantiate later from this deferred path will be
// both texturable and renderable
return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(*caps, copyDesc, fit,
budgeted, flags));
}
return sk_sp<GrTextureProxy>(new GrTextureProxy(copyDesc, fit, budgeted, nullptr, 0, flags));
#endif
}
sk_sp<GrTextureProxy> GrProxyProvider::createWrappedTextureProxy(const GrBackendTexture& backendTex,
GrSurfaceOrigin origin) {
sk_sp<GrTexture> texture(fResourceProvider->wrapBackendTexture(backendTex));
if (!texture) {
return nullptr;
}
SkASSERT(!texture->asRenderTarget()); // Strictly a GrTexture
return GrSurfaceProxy::MakeWrapped(std::move(texture), origin);
}
sk_sp<GrTextureProxy> GrProxyProvider::createWrappedTextureProxy(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt) {
sk_sp<GrTexture> texture(fResourceProvider->wrapRenderableBackendTexture(tex, sampleCnt));
if (!texture) {
return nullptr;
}
SkASSERT(texture->asRenderTarget()); // A GrTextureRenderTarget
return GrSurfaceProxy::MakeWrapped(std::move(texture), origin);
}
sk_sp<GrSurfaceProxy> GrProxyProvider::createWrappedRenderTargetProxy(
const GrBackendRenderTarget& backendRT,
GrSurfaceOrigin origin) {
sk_sp<GrRenderTarget> rt(fResourceProvider->wrapBackendRenderTarget(backendRT));
if (!rt) {
return nullptr;
}
SkASSERT(!rt->asTexture()); // Strictly a GrRenderTarget
SkASSERT(!rt->getUniqueKey().isValid());
return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin));
}
sk_sp<GrSurfaceProxy> GrProxyProvider::createWrappedRenderTargetProxy(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt) {
sk_sp<GrRenderTarget> rt(fResourceProvider->wrapBackendTextureAsRenderTarget(tex, sampleCnt));
if (!rt) {
return nullptr;
}
SkASSERT(!rt->asTexture()); // Strictly a GrRenderTarget
SkASSERT(!rt->getUniqueKey().isValid());
return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin));
}
bool GrProxyProvider::IsFunctionallyExact(GrSurfaceProxy* proxy) {
return proxy->priv().isExact() || (SkIsPow2(proxy->width()) && SkIsPow2(proxy->height()));
}

70
src/gpu/GrProxyProvider.h
View File

@ -17,6 +17,7 @@
class GrCaps;
class GrResourceProvider;
class GrSingleOwner;
class GrBackendRenderTarget;
/*
* A factory for creating GrSurfaceProxy-derived objects.
@ -57,16 +58,75 @@ public:
sk_sp<GrTextureProxy> findOrCreateProxyByUniqueKey(const GrUniqueKey&, GrSurfaceOrigin);
/*
* Create an un-mipmapped texture proxy with data.
* Create a texture proxy that is backed by an instantiated GrSurface. This is almost entirely
* used by Skia's testing code.
* DDL TODO: remove the remaining Skia-internal use of this method and make it truly
* testing-only.
*/
sk_sp<GrTextureProxy> createTextureProxy(const GrSurfaceDesc&, SkBudgeted, const GrMipLevel&);
sk_sp<GrTextureProxy> createInstantiatedProxy(const GrSurfaceDesc&, SkBackingFit, SkBudgeted,
uint32_t flags = 0);
/*
* Create an un-mipmapped texture proxy with data.
* DDL TODO: need to refine ownership semantics of 'srcData' if we're in completely
* deferred mode
*/
sk_sp<GrTextureProxy> createTextureProxy(const GrSurfaceDesc&, SkBudgeted,
const void* srcData, size_t rowBytes);
/*
* Create a mipmapped texture proxy with data.
*
* @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
*/
sk_sp<GrTextureProxy> createTextureProxy(const GrSurfaceDesc&, SkBudgeted,
const GrMipLevel texels[], int mipLevelCount,
SkDestinationSurfaceColorMode mipColorMode);
sk_sp<GrTextureProxy> createMipMapProxy(const GrSurfaceDesc&, SkBudgeted,
const GrMipLevel texels[], int mipLevelCount,
SkDestinationSurfaceColorMode mipColorMode =
SkDestinationSurfaceColorMode::kLegacy);
/*
* Create a mipmapped texture proxy without any data.
*
* Like the call above but there are no texels to upload. A texture proxy is returned that
* simply has space allocated for the mips. We will allocated the full amount of mip levels
* based on the width and height in the GrSurfaceDesc.
*/
sk_sp<GrTextureProxy> createMipMapProxy(const GrSurfaceDesc&, SkBudgeted);
/*
* Create a GrSurfaceProxy without any data.
*/
sk_sp<GrTextureProxy> createProxy(const GrSurfaceDesc&, SkBackingFit, SkBudgeted,
uint32_t flags = 0);
/*
* Create a texture proxy that wraps a (non-renderable) backend texture.
*/
sk_sp<GrTextureProxy> createWrappedTextureProxy(const GrBackendTexture&, GrSurfaceOrigin);
/*
* Create a texture proxy that wraps a backend texture and is both texture-able and renderable
*/
sk_sp<GrTextureProxy> createWrappedTextureProxy(const GrBackendTexture&,
GrSurfaceOrigin,
int sampleCnt);
/*
* Create a render target proxy that wraps a backend rendertarget
*/
sk_sp<GrSurfaceProxy> createWrappedRenderTargetProxy(const GrBackendRenderTarget&,
GrSurfaceOrigin);
/*
* Create a render target proxy that wraps a backend texture?
*/
sk_sp<GrSurfaceProxy> createWrappedRenderTargetProxy(const GrBackendTexture& tex,
GrSurfaceOrigin origin,
int sampleCnt);
// 'proxy' is about to be used as a texture src or drawn to. This query can be used to
// determine if it is going to need a texture domain or a full clear.

14
src/gpu/GrResourceProvider.cpp
View File

@ -15,6 +15,7 @@
#include "GrGpu.h"
#include "GrPath.h"
#include "GrPathRendering.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetPriv.h"
#include "GrResourceCache.h"
#include "GrResourceKey.h"
@ -128,19 +129,22 @@ sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc,
}
GrContext* context = fGpu->getContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkImageInfo srcInfo;
if (make_info(desc.fWidth, desc.fHeight, desc.fConfig, &srcInfo)) {
sk_sp<GrTexture> tex = this->getExactScratch(desc, budgeted, 0);
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex, desc.fOrigin);
// DDL TODO: remove this use of createInstantiatedProxy and convert it to a testing-only
// method.
sk_sp<GrTextureProxy> proxy = proxyProvider->createInstantiatedProxy(desc,
SkBackingFit::kExact,
budgeted);
if (proxy) {
sk_sp<GrSurfaceContext> sContext =
context->contextPriv().makeWrappedSurfaceContext(std::move(proxy), nullptr);
if (sContext) {
if (sContext->writePixels(srcInfo, mipLevel.fPixels, mipLevel.fRowBytes, 0, 0)) {
SkASSERT(sContext->asTextureProxy()->priv().peekTexture() == tex.get());
return tex;
return sk_ref_sp(sContext->asTextureProxy()->priv().peekTexture());
}
}
}
@ -464,7 +468,7 @@ sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendTextureAsRenderTarget(
if (this->isAbandoned()) {
return nullptr;
}
return this->gpu()->wrapBackendTextureAsRenderTarget(tex, sampleCnt);
return fGpu->wrapBackendTextureAsRenderTarget(tex, sampleCnt);
}
sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT GrResourceProvider::makeSemaphore(bool isOwned) {

7
src/gpu/GrSoftwarePathRenderer.cpp
View File

@ -169,15 +169,18 @@ void GrSoftwarePathRenderer::DrawToTargetWithShapeMask(
static sk_sp<GrTextureProxy> make_deferred_mask_texture_proxy(GrContext* context, SkBackingFit fit,
int width, int height) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = kAlpha_8_GrPixelConfig;
// MDB TODO: We're going to fill this proxy with an ASAP upload (which is out of order wrt to
// ops), so it can't have any pending IO.
return GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(), desc, fit,
SkBudgeted::kYes, GrResourceProvider::kNoPendingIO_Flag);
return proxyProvider->createProxy(desc, fit, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
}
namespace {

175
src/gpu/GrSurfaceProxy.cpp
View File

@ -223,35 +223,6 @@ GrTextureOpList* GrSurfaceProxy::getLastTextureOpList() {
return fLastOpList ? fLastOpList->asTextureOpList() : nullptr;
}
sk_sp<GrSurfaceProxy> GrSurfaceProxy::MakeWrapped(sk_sp<GrSurface> surf, GrSurfaceOrigin origin) {
if (!surf) {
return nullptr;
}
if (surf->getUniqueKey().isValid()) {
// The proxy may already be in the hash. Thus we need to look for it first before creating
// new one.
GrProxyProvider* provider = surf->getContext()->contextPriv().proxyProvider();
sk_sp<GrSurfaceProxy> proxy = provider->findProxyByUniqueKey(surf->getUniqueKey(), origin);
if (proxy) {
return proxy;
}
}
if (surf->asTexture()) {
if (surf->asRenderTarget()) {
return sk_sp<GrSurfaceProxy>(new GrTextureRenderTargetProxy(std::move(surf), origin));
} else {
return sk_sp<GrSurfaceProxy>(new GrTextureProxy(std::move(surf), origin));
}
} else {
SkASSERT(surf->asRenderTarget());
// Not texturable
return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(surf), origin));
}
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeWrapped(sk_sp<GrTexture> tex, GrSurfaceOrigin origin) {
if (!tex) {
return nullptr;
@ -274,152 +245,6 @@ sk_sp<GrTextureProxy> GrSurfaceProxy::MakeWrapped(sk_sp<GrTexture> tex, GrSurfac
}
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrProxyProvider* proxyProvider,
const GrSurfaceDesc& desc,
SkBackingFit fit,
SkBudgeted budgeted,
uint32_t flags) {
SkASSERT(0 == flags || GrResourceProvider::kNoPendingIO_Flag == flags);
const GrCaps* caps = proxyProvider->caps();
// TODO: move this logic into GrResourceProvider!
// TODO: share this testing code with check_texture_creation_params
if (!caps->isConfigTexturable(desc.fConfig)) {
return nullptr;
}
bool willBeRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
if (willBeRT && !caps->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
return nullptr;
}
// We currently do not support multisampled textures
if (!willBeRT && desc.fSampleCnt > 0) {
return nullptr;
}
int maxSize;
if (willBeRT) {
maxSize = caps->maxRenderTargetSize();
} else {
maxSize = caps->maxTextureSize();
}
if (desc.fWidth > maxSize || desc.fHeight > maxSize || desc.fWidth <= 0 || desc.fHeight <= 0) {
return nullptr;
}
GrSurfaceDesc copyDesc = desc;
copyDesc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig);
#ifdef SK_DISABLE_DEFERRED_PROXIES
// Temporarily force instantiation for crbug.com/769760 and crbug.com/769898
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = resourceProvider->createApproxTexture(copyDesc, flags);
} else {
tex = resourceProvider->createTexture(copyDesc, budgeted, flags);
}
if (!tex) {
return nullptr;
}
return GrSurfaceProxy::MakeWrapped(std::move(tex), copyDesc.fOrigin);
#else
if (willBeRT) {
// We know anything we instantiate later from this deferred path will be
// both texturable and renderable
return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(*caps, copyDesc, fit,
budgeted, flags));
}
return sk_sp<GrTextureProxy>(new GrTextureProxy(copyDesc, fit, budgeted, nullptr, 0, flags));
#endif
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferred(GrProxyProvider* proxyProvider,
const GrSurfaceDesc& desc,
SkBudgeted budgeted,
const void* srcData,
size_t rowBytes) {
if (srcData) {
GrMipLevel mipLevel = { srcData, rowBytes };
return proxyProvider->createTextureProxy(desc, budgeted, mipLevel);
}
return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBackingFit::kExact, budgeted);
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferredMipMap(GrProxyProvider* proxyProvider,
const GrSurfaceDesc& desc,
SkBudgeted budgeted) {
// SkMipMap doesn't include the base level in the level count so we have to add 1
int mipCount = SkMipMap::ComputeLevelCount(desc.fWidth, desc.fHeight) + 1;
std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipCount]);
// We don't want to upload any texel data
for (int i = 0; i < mipCount; i++) {
texels[i].fPixels = nullptr;
texels[i].fRowBytes = 0;
}
return MakeDeferredMipMap(proxyProvider, desc, budgeted, texels.get(), mipCount);
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeDeferredMipMap(
GrProxyProvider* proxyProvider,
const GrSurfaceDesc& desc,
SkBudgeted budgeted,
const GrMipLevel texels[],
int mipLevelCount,
SkDestinationSurfaceColorMode mipColorMode) {
if (!mipLevelCount) {
if (texels) {
return nullptr;
}
return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, budgeted, nullptr, 0);
}
if (!texels) {
return nullptr;
}
if (1 == mipLevelCount) {
return proxyProvider->createTextureProxy(desc, budgeted, texels[0]);
}
#ifdef SK_DEBUG
// There are only three states we want to be in when uploading data to a mipped surface.
// 1) We have data to upload to all layers
// 2) We are not uploading data to any layers
// 3) We are only uploading data to the base layer
// We check here to make sure we do not have any other state.
bool firstLevelHasData = SkToBool(texels[0].fPixels);
bool allOtherLevelsHaveData = true, allOtherLevelsLackData = true;
for (int i = 1; i < mipLevelCount; ++i) {
if (texels[i].fPixels) {
allOtherLevelsLackData = false;
} else {
allOtherLevelsHaveData = false;
}
}
SkASSERT((firstLevelHasData && allOtherLevelsHaveData) || allOtherLevelsLackData);
#endif
return proxyProvider->createTextureProxy(desc, budgeted, texels, mipLevelCount, mipColorMode);
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeWrappedBackend(GrContext* context,
const GrBackendTexture& backendTex,
GrSurfaceOrigin origin) {
sk_sp<GrTexture> tex(context->resourceProvider()->wrapBackendTexture(backendTex));
return GrSurfaceProxy::MakeWrapped(std::move(tex), origin);
}
sk_sp<GrTextureProxy> GrSurfaceProxy::MakeLazy(LazyInstantiateCallback&& callback,
const GrSurfaceDesc& desc,
GrMipMapped mipMapped,

2
src/gpu/GrTextureRenderTargetProxy.h
View File

@ -23,7 +23,9 @@
// the uniqueID of the RenderTarget/Texture it represents!
class GrTextureRenderTargetProxy : public GrTextureProxy, public GrRenderTargetProxy {
private:
// DDL TODO: rm the GrSurfaceProxy friending
friend class GrSurfaceProxy; // for ctors
friend class GrProxyProvider; // for ctors
// Deferred version
GrTextureRenderTargetProxy(const GrCaps&, const GrSurfaceDesc&,

35
src/gpu/SkGr.cpp
View File

@ -92,8 +92,8 @@ sk_sp<GrTextureProxy> GrUploadPixmapToTextureProxy(GrProxyProvider* proxyProvide
ATRACE_ANDROID_FRAMEWORK("Upload Texture [%ux%u]", pixmap.width(), pixmap.height());
GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *proxyProvider->caps());
return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, budgeted, pixmap.addr(),
pixmap.rowBytes());
return proxyProvider->createTextureProxy(desc, budgeted, pixmap.addr(), pixmap.rowBytes());
}
////////////////////////////////////////////////////////////////////////////////
@ -111,7 +111,7 @@ void GrInstallBitmapUniqueKeyInvalidator(const GrUniqueKey& key, SkPixelRef* pix
pixelRef->addGenIDChangeListener(new Invalidator(key));
}
sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext* ctx,
sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrProxyProvider* proxyProvider,
const SkBitmap& bitmap,
SkColorSpace* dstColorSpace) {
SkDestinationSurfaceColorMode colorMode = dstColorSpace
@ -128,7 +128,7 @@ sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext* ctx,
}
ATRACE_ANDROID_FRAMEWORK("Upload MipMap Texture [%ux%u]", pixmap.width(), pixmap.height());
GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *ctx->resourceProvider()->caps());
GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *proxyProvider->caps());
std::unique_ptr<SkMipMap> mipmaps(SkMipMap::Build(pixmap, colorMode, nullptr));
if (!mipmaps) {
return nullptr;
@ -151,22 +151,18 @@ sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext* ctx,
texels[i].fRowBytes = generatedMipLevel.fPixmap.rowBytes();
}
return GrSurfaceProxy::MakeDeferredMipMap(ctx->contextPriv().proxyProvider(),
desc,
SkBudgeted::kYes,
texels.get(),
mipLevelCount,
colorMode);
return proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes, texels.get(), mipLevelCount,
colorMode);
}
sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext* ctx,
GrTextureProxy* baseProxy) {
sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext* ctx, GrTextureProxy* baseProxy) {
SkASSERT(baseProxy);
if (!ctx->caps()->isConfigCopyable(baseProxy->config())) {
return nullptr;
}
GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fOrigin = baseProxy->origin();
@ -175,9 +171,7 @@ sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext* ctx,
desc.fConfig = baseProxy->config();
desc.fSampleCnt = 0;
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferredMipMap(ctx->contextPriv().proxyProvider(),
desc,
SkBudgeted::kYes);
sk_sp<GrTextureProxy> proxy = proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes);
if (!proxy) {
return nullptr;
}
@ -191,7 +185,8 @@ sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext* ctx,
}
sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext* ctx, const SkImageInfo& info,
sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrProxyProvider* proxyProvider,
const SkImageInfo& info,
const GrMipLevel texels[],
int mipLevelCount,
SkDestinationSurfaceColorMode colorMode) {
@ -199,10 +194,10 @@ sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext* ctx, const SkImage
return nullptr;
}
return GrSurfaceProxy::MakeDeferredMipMap(ctx->contextPriv().proxyProvider(),
GrImageInfoToSurfaceDesc(info, *ctx->caps()),
SkBudgeted::kYes, texels,
mipLevelCount, colorMode);
GrSurfaceDesc desc(GrImageInfoToSurfaceDesc(info, *proxyProvider->caps()));
return proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes,
texels, mipLevelCount, colorMode);
}
sk_sp<GrTextureProxy> GrRefCachedBitmapTextureProxy(GrContext* ctx,

4
src/gpu/SkGr.h
View File

@ -208,7 +208,7 @@ sk_sp<GrTextureProxy> GrRefCachedBitmapTextureProxy(GrContext*,
sk_sp<GrTextureProxy> GrUploadBitmapToTextureProxy(GrProxyProvider*, const SkBitmap&,
SkColorSpace* dstColorSpace);
sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrContext*, const SkBitmap&,
sk_sp<GrTextureProxy> GrGenerateMipMapsAndUploadToTextureProxy(GrProxyProvider*, const SkBitmap&,
SkColorSpace* dstColorSpace);
/**
@ -226,7 +226,7 @@ sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrContext*,
/**
* Creates a new texture populated with the mipmap levels.
*/
sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrContext*, const SkImageInfo&,
sk_sp<GrTextureProxy> GrUploadMipMapToTextureProxy(GrProxyProvider*, const SkImageInfo&,
const GrMipLevel texels[],
int mipLevelCount,
SkDestinationSurfaceColorMode colorMode);

5
src/gpu/effects/GrConfigConversionEffect.h
View File

@ -16,6 +16,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
@ -60,8 +61,8 @@ public:
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> dataProxy =
GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes, data, 0);
sk_sp<GrTextureProxy> dataProxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
data, 0);
if (!dataProxy) {
return false;
}

4
src/gpu/effects/GrRectBlurEffect.h
View File

@ -40,8 +40,8 @@ public:
std::unique_ptr<uint8_t[]> profile(SkBlurMask::ComputeBlurProfile(sigma));
blurProfile = GrSurfaceProxy::MakeDeferred(proxyProvider, texDesc, SkBudgeted::kYes,
profile.get(), 0);
blurProfile = proxyProvider->createTextureProxy(texDesc, SkBudgeted::kYes,
profile.get(), 0);
if (!blurProfile) {
return nullptr;
}

6
src/gpu/effects/GrTextureStripAtlas.cpp
View File

@ -218,10 +218,8 @@ void GrTextureStripAtlas::lockTexture() {
texDesc.fHeight = fDesc.fHeight;
texDesc.fConfig = fDesc.fConfig;
proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
texDesc, SkBackingFit::kExact,
SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
proxy = proxyProvider->createProxy(texDesc, SkBackingFit::kExact, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
if (!proxy) {
return;
}

8
src/gpu/ops/GrTextureOp.cpp
View File

@ -793,6 +793,7 @@ std::unique_ptr<GrDrawOp> Make(sk_sp<GrTextureProxy> proxy, GrSamplerState::Filt
#if GR_TEST_UTILS
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
GR_DRAW_OP_TEST_DEFINE(TextureOp) {
GrSurfaceDesc desc;
@ -801,9 +802,10 @@ GR_DRAW_OP_TEST_DEFINE(TextureOp) {
desc.fWidth = random->nextULessThan(90) + 10;
desc.fOrigin = random->nextBool() ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
SkBackingFit fit = random->nextBool() ? SkBackingFit::kApprox : SkBackingFit::kExact;
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(
context->contextPriv().proxyProvider(),
desc, fit, SkBudgeted::kNo);
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, fit, SkBudgeted::kNo);
SkRect rect = GrTest::TestRect(random);
SkRect srcRect;
srcRect.fLeft = random->nextRangeScalar(0.f, proxy->width() / 2.f);

30
src/image/SkImage_Gpu.cpp
View File

@ -19,6 +19,7 @@
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrImageTextureMaker.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrResourceProvider.h"
#include "GrSemaphore.h"
@ -291,10 +292,10 @@ static sk_sp<SkImage> new_wrapped_texture_common(GrContext* ctx,
tex->setRelease(releaseProc, releaseCtx);
}
const SkBudgeted budgeted = SkBudgeted::kNo;
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeWrapped(std::move(tex), origin));
return sk_make_sp<SkImage_Gpu>(ctx, kNeedNewImageUniqueID,
at, std::move(proxy), std::move(colorSpace), budgeted);
at, std::move(proxy), std::move(colorSpace), SkBudgeted::kNo);
}
sk_sp<SkImage> SkImage::MakeFromTexture(GrContext* ctx,
@ -394,20 +395,22 @@ static sk_sp<SkImage> make_from_yuv_textures_copy(GrContext* ctx, SkYUVColorSpac
const SkISize yuvSizes[],
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> imageColorSpace) {
GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
if (!are_yuv_sizes_valid(yuvSizes, nv12)) {
return nullptr;
}
sk_sp<GrTextureProxy> yProxy = GrSurfaceProxy::MakeWrappedBackend(ctx, yuvBackendTextures[0],
origin);
sk_sp<GrTextureProxy> uProxy = GrSurfaceProxy::MakeWrappedBackend(ctx, yuvBackendTextures[1],
origin);
sk_sp<GrTextureProxy> yProxy = proxyProvider->createWrappedTextureProxy(yuvBackendTextures[0],
origin);
sk_sp<GrTextureProxy> uProxy = proxyProvider->createWrappedTextureProxy(yuvBackendTextures[1],
origin);
sk_sp<GrTextureProxy> vProxy;
if (nv12) {
vProxy = uProxy;
} else {
vProxy = GrSurfaceProxy::MakeWrappedBackend(ctx, yuvBackendTextures[2], origin);
vProxy = proxyProvider->createWrappedTextureProxy(yuvBackendTextures[2], origin);
}
if (!yProxy || !uProxy || !vProxy) {
return nullptr;
@ -605,15 +608,16 @@ sk_sp<SkImage> SkImage::MakeCrossContextFromPixmap(GrContext* context, const SkP
return SkImage::MakeRasterCopy(pixmap);
}
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
// Turn the pixmap into a GrTextureProxy
sk_sp<GrTextureProxy> proxy;
if (buildMips) {
SkBitmap bmp;
bmp.installPixels(pixmap);
proxy = GrGenerateMipMapsAndUploadToTextureProxy(context, bmp, dstColorSpace);
proxy = GrGenerateMipMapsAndUploadToTextureProxy(proxyProvider, bmp, dstColorSpace);
} else {
proxy = GrUploadPixmapToTextureProxy(context->contextPriv().proxyProvider(),
pixmap, SkBudgeted::kYes, dstColorSpace);
proxy = GrUploadPixmapToTextureProxy(proxyProvider, pixmap, SkBudgeted::kYes,
dstColorSpace);
}
if (!proxy) {
@ -1089,6 +1093,8 @@ sk_sp<SkImage> SkImage::MakeTextureFromMipMap(GrContext* ctx, const SkImageInfo&
if (!ctx) {
return nullptr;
}
GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
// For images where the client is passing the mip data we require that all the mip levels have
// valid data.
for (int i = 0; i < mipLevelCount; ++i) {
@ -1096,8 +1102,8 @@ sk_sp<SkImage> SkImage::MakeTextureFromMipMap(GrContext* ctx, const SkImageInfo&
return nullptr;
}
}
sk_sp<GrTextureProxy> proxy(GrUploadMipMapToTextureProxy(ctx, info, texels, mipLevelCount,
colorMode));
sk_sp<GrTextureProxy> proxy(GrUploadMipMapToTextureProxy(proxyProvider, info,
texels, mipLevelCount, colorMode));
if (!proxy) {
return nullptr;
}

2
src/image/SkImage_Lazy.cpp
View File

@ -829,7 +829,7 @@ sk_sp<GrTextureProxy> SkImage_Lazy::lockTextureProxy(GrContext* ctx,
SkBitmap bitmap;
if (!proxy && this->lockAsBitmap(&bitmap, chint, format, genPixelsInfo, behavior)) {
if (willBeMipped) {
proxy = GrGenerateMipMapsAndUploadToTextureProxy(ctx, bitmap, dstColorSpace);
proxy = GrGenerateMipMapsAndUploadToTextureProxy(proxyProvider, bitmap, dstColorSpace);
}
if (!proxy) {
proxy = GrUploadBitmapToTextureProxy(proxyProvider, bitmap, dstColorSpace);

16
tests/CopySurfaceTest.cpp
View File

@ -11,6 +11,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrSurfaceContext.h"
#include "GrSurfaceProxy.h"
@ -74,17 +75,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CopySurface, reporter, ctxInfo) {
dstDesc.fOrigin = dOrigin;
dstDesc.fFlags = dFlags;
sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(
proxyProvider,
srcDesc, SkBudgeted::kNo,
srcPixels.get(),
kRowBytes));
sk_sp<GrTextureProxy> dst(GrSurfaceProxy::MakeDeferred(
proxyProvider,
dstDesc, SkBudgeted::kNo,
dstPixels.get(),
kRowBytes));
sk_sp<GrTextureProxy> src = proxyProvider->createTextureProxy(
srcDesc, SkBudgeted::kNo, srcPixels.get(), kRowBytes);
sk_sp<GrTextureProxy> dst = proxyProvider->createTextureProxy(
dstDesc, SkBudgeted::kNo, dstPixels.get(), kRowBytes);
if (!src || !dst) {
ERRORF(reporter,
"Could not create surfaces for copy surface test.");

3
tests/DetermineDomainModeTest.cpp
View File

@ -10,6 +10,7 @@
#if SK_SUPPORT_GPU
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTextureProducer.h"
#include "GrTextureProxy.h"
@ -133,7 +134,7 @@ static sk_sp<GrTextureProxy> create_proxy(GrProxyProvider* proxyProvider,
(isPowerOfTwo || isExact) ? RectInfo::kHard : RectInfo::kBad,
name);
return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, fit, SkBudgeted::kYes);
return proxyProvider->createProxy(desc, fit, SkBudgeted::kYes);
}
static RectInfo::EdgeType compute_inset_edgetype(RectInfo::EdgeType previous,

8
tests/FloatingPointTextureTest.cpp
View File

@ -18,7 +18,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrResourceProvider.h"
#include "GrProxyProvider.h"
#include "GrTextureProxy.h"
#include "SkHalf.h"
@ -52,9 +52,9 @@ void runFPTest(skiatest::Reporter* reporter, GrContext* context,
desc.fWidth = DEV_W;
desc.fHeight = DEV_H;
desc.fConfig = config;
sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kNo,
controlPixelData.begin(), 0);
sk_sp<GrTextureProxy> fpProxy = proxyProvider->createTextureProxy(
desc, SkBudgeted::kNo, controlPixelData.begin(), 0);
// Floating point textures are NOT supported everywhere
if (!fpProxy) {
continue;

31
tests/GLProgramsTest.cpp
View File

@ -266,19 +266,24 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages, int ma
sk_sp<GrTextureProxy> proxies[2];
// setup dummy textures
GrSurfaceDesc dummyDesc;
dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
dummyDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
dummyDesc.fWidth = 34;
dummyDesc.fHeight = 18;
dummyDesc.fConfig = kRGBA_8888_GrPixelConfig;
proxies[0] = GrSurfaceProxy::MakeDeferred(proxyProvider, dummyDesc, SkBudgeted::kNo, nullptr, 0);
dummyDesc.fFlags = kNone_GrSurfaceFlags;
dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
dummyDesc.fWidth = 16;
dummyDesc.fHeight = 22;
dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
proxies[1] = GrSurfaceProxy::MakeDeferred(proxyProvider, dummyDesc, SkBudgeted::kNo, nullptr, 0);
{
GrSurfaceDesc dummyDesc;
dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
dummyDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
dummyDesc.fWidth = 34;
dummyDesc.fHeight = 18;
dummyDesc.fConfig = kRGBA_8888_GrPixelConfig;
proxies[0] = proxyProvider->createProxy(dummyDesc, SkBackingFit::kExact, SkBudgeted::kNo);
}
{
GrSurfaceDesc dummyDesc;
dummyDesc.fFlags = kNone_GrSurfaceFlags;
dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
dummyDesc.fWidth = 16;
dummyDesc.fHeight = 22;
dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
proxies[1] = proxyProvider->createProxy(dummyDesc, SkBackingFit::kExact, SkBudgeted::kNo);
}
if (!proxies[0] || !proxies[1]) {
SkDebugf("Could not allocate dummy textures");

6
tests/GrPorterDuffTest.cpp
View File

@ -13,6 +13,7 @@
#include "GrContextOptions.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrProxyProvider.h"
#include "GrTest.h"
#include "GrXferProcessor.h"
#include "effects/GrPorterDuffXferProcessor.h"
@ -1060,6 +1061,7 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, options) {
return;
}
GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider();
const GrCaps& caps = *ctx->caps();
if (caps.shaderCaps()->dualSourceBlendingSupport()) {
SK_ABORT("Null context failed to honor request for no ARB_blend_func_extended.");
@ -1072,8 +1074,8 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, options) {
GrXferProcessor::DstProxy fakeDstProxy;
{
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrappedBackend(ctx, backendTex,
kTopLeft_GrSurfaceOrigin);
sk_sp<GrTextureProxy> proxy = proxyProvider->createWrappedTextureProxy(
backendTex, kTopLeft_GrSurfaceOrigin);
fakeDstProxy.setProxy(std::move(proxy));
}

32
tests/GrSurfaceTest.cpp
View File

@ -12,6 +12,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrProxyProvider.h"
#include "GrRenderTarget.h"
#include "GrResourceProvider.h"
#include "GrTest.h"
@ -126,10 +127,10 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(GrSurfaceRenderability, reporter, ctxInfo) {
texels[i].fPixels = pixelData.get();
texels[i].fRowBytes = rowBytes >> i;
}
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferredMipMap(proxyProvider,
desc, SkBudgeted::kNo,
texels.get(),
levelCount);
sk_sp<GrTextureProxy> proxy = proxyProvider->createMipMapProxy(
desc, SkBudgeted::kNo,
texels.get(), levelCount);
REPORTER_ASSERT(reporter, SkToBool(proxy.get()) ==
(caps->isConfigTexturable(desc.fConfig) &&
caps->mipMapSupport() &&
@ -155,7 +156,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(InitialTextureClear, reporter, context_info)
GrSurfaceDesc desc;
desc.fWidth = desc.fHeight = kSize;
std::unique_ptr<uint32_t[]> data(new uint32_t[kSize * kSize]);
GrContext* context = context_info.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
for (int c = 0; c <= kLast_GrPixelConfig; ++c) {
desc.fConfig = static_cast<GrPixelConfig>(c);
if (!context_info.grContext()->caps()->isConfigTexturable(desc.fConfig)) {
@ -170,22 +174,16 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(InitialTextureClear, reporter, context_info)
for (GrSurfaceOrigin origin :
{kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
desc.fOrigin = origin;
for (bool approx : {false, true}) {
auto resourceProvider = context->resourceProvider();
for (auto fit : { SkBackingFit::kApprox, SkBackingFit::kExact }) {
// Try directly creating the texture.
// Do this twice in an attempt to hit the cache on the second time through.
for (int i = 0; i < 2; ++i) {
sk_sp<GrTexture> tex;
if (approx) {
tex = sk_sp<GrTexture>(
resourceProvider->createApproxTexture(desc, 0));
} else {
tex = resourceProvider->createTexture(desc, SkBudgeted::kYes);
}
if (!tex) {
sk_sp<GrTextureProxy> proxy = proxyProvider->createInstantiatedProxy(
desc, fit, SkBudgeted::kYes);
if (!proxy) {
continue;
}
auto proxy = GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
auto texCtx = context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr);
SkImageInfo info = SkImageInfo::Make(
@ -212,9 +210,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(InitialTextureClear, reporter, context_info)
// Try creating the texture as a deferred proxy.
for (int i = 0; i < 2; ++i) {
auto surfCtx = context->contextPriv().makeDeferredSurfaceContext(
desc, GrMipMapped::kNo,
approx ? SkBackingFit::kApprox : SkBackingFit::kExact,
SkBudgeted::kYes);
desc, GrMipMapped::kNo, fit, SkBudgeted::kYes);
if (!surfCtx) {
continue;
}

6
tests/ImageFilterCacheTest.cpp
View File

@ -180,6 +180,7 @@ DEF_TEST(ImageFilterCache_ImageBackedRaster, reporter) {
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxyPriv.h"
#include "GrTest.h"
@ -196,9 +197,8 @@ static sk_sp<GrTextureProxy> create_proxy(GrProxyProvider* proxyProvider) {
desc.fHeight = kFullSize;
desc.fConfig = kRGBA_8888_GrPixelConfig;
return GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kYes,
srcBM.getPixels(), srcBM.rowBytes());
return proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
srcBM.getPixels(), srcBM.rowBytes());
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {

31
tests/IntTextureTest.cpp
View File

@ -11,6 +11,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrResourceProvider.h"
#include "GrTexture.h"
@ -68,25 +69,25 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
levels[1].fPixels = testData.get();
levels[1].fRowBytes = (kS / 2) * sizeof(int32_t);
sk_sp<GrTextureProxy> temp(GrSurfaceProxy::MakeDeferredMipMap(proxyProvider,
desc, SkBudgeted::kYes,
levels, 2));
sk_sp<GrTextureProxy> temp = proxyProvider->createMipMapProxy(
desc, SkBudgeted::kYes, levels, 2);
REPORTER_ASSERT(reporter, !temp);
}
// Test that we can create an integer texture.
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kYes,
testData.get(), kRowBytes);
REPORTER_ASSERT(reporter, proxy);
if (!proxy) {
return;
}
sk_sp<GrSurfaceContext> sContext;
// Test that we can create a non-mipmapped integer texture.
{
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
testData.get(), kRowBytes);
REPORTER_ASSERT(reporter, proxy);
if (!proxy) {
return;
}
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr);
if (!sContext) {
return;
sContext = context->contextPriv().makeWrappedSurfaceContext(std::move(proxy), nullptr);
if (!sContext) {
return;
}
}
std::unique_ptr<int32_t[]> readData(new int32_t[kS * kS]);

12
tests/OnFlushCallbackTest.cpp
View File

@ -14,6 +14,7 @@
#include "GrContextPriv.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrOnFlushResourceProvider.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContextPriv.h"
#include "GrResourceProvider.h"
#include "GrQuad.h"
@ -474,17 +475,16 @@ sk_sp<GrTextureProxy> pre_create_atlas(GrContext* context) {
}
#else
// TODO: this is unfortunate and must be removed. We want the atlas to be created later.
sk_sp<GrTextureProxy> pre_create_atlas(GrContext* context) {
sk_sp<GrTextureProxy> pre_create_atlas(GrProxyProvider* proxyProvider) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
desc.fWidth = 32;
desc.fHeight = 16;
desc.fConfig = kSkia8888_GrPixelConfig;
return GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
desc, SkBackingFit::kExact,
SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
return proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
}
#endif
@ -520,7 +520,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(OnFlushCallbackTest, reporter, ctxInfo) {
// For now (until we add a GrSuperDeferredSimpleTextureEffect), we create the final atlas
// proxy ahead of time.
sk_sp<GrTextureProxy> atlasDest = pre_create_atlas(context);
sk_sp<GrTextureProxy> atlasDest = pre_create_atlas(context->contextPriv().proxyProvider());
object.setAtlasDest(atlasDest);

7
tests/PackedConfigsTextureTest.cpp
View File

@ -16,7 +16,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrResourceProvider.h"
#include "GrProxyProvider.h"
#include "GrTextureProxy.h"
static const int DEV_W = 10, DEV_H = 10;
@ -120,9 +120,8 @@ static void run_test(skiatest::Reporter* reporter, GrContext* context,
desc.fConfig = config;
desc.fOrigin = origin;
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kNo,
controlPixelData.begin(), 0);
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
desc, SkBudgeted::kNo, controlPixelData.begin(), 0);
SkASSERT(proxy);
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(

93
tests/ProcessorTest.cpp
View File

@ -14,6 +14,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpuResource.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrRenderTargetContextPriv.h"
#include "GrResourceProvider.h"
@ -171,22 +172,14 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
kRGBA_8888_GrPixelConfig, nullptr));
{
bool texelBufferSupport = context->caps()->shaderCaps()->texelBufferSupport();
sk_sp<GrTextureProxy> proxy1(
GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBackingFit::kExact,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy2
(GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBackingFit::kExact,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy3(
GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBackingFit::kExact,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy4(
GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBackingFit::kExact,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy1 =
proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
sk_sp<GrTextureProxy> proxy2 =
proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
sk_sp<GrTextureProxy> proxy3 =
proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
sk_sp<GrTextureProxy> proxy4 =
proxyProvider->createProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
sk_sp<GrBuffer> buffer(texelBufferSupport
? context->resourceProvider()->createBuffer(
1024, GrBufferType::kTexel_GrBufferType,
@ -296,9 +289,8 @@ void test_draw_op(GrRenderTargetContext* rtc, std::unique_ptr<GrFragmentProcesso
}
/** Initializes the two test texture proxies that are available to the FP test factories. */
bool init_test_textures(GrContext* context, SkRandom* random, sk_sp<GrTextureProxy> proxies[2]) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
bool init_test_textures(GrProxyProvider* proxyProvider, SkRandom* random,
sk_sp<GrTextureProxy> proxies[2]) {
static const int kTestTextureSize = 256;
GrSurfaceDesc desc;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
@ -306,36 +298,41 @@ bool init_test_textures(GrContext* context, SkRandom* random, sk_sp<GrTexturePro
desc.fHeight = kTestTextureSize;
desc.fConfig = kRGBA_8888_GrPixelConfig;
// Put premul data into the RGBA texture that the test FPs can optionally use.
std::unique_ptr<GrColor[]> rgbaData(new GrColor[kTestTextureSize * kTestTextureSize]);
for (int y = 0; y < kTestTextureSize; ++y) {
for (int x = 0; x < kTestTextureSize; ++x) {
rgbaData[kTestTextureSize * y + x] =
input_texel_color(random->nextULessThan(256), random->nextULessThan(256));
{
// Put premul data into the RGBA texture that the test FPs can optionally use.
std::unique_ptr<GrColor[]> rgbaData(new GrColor[kTestTextureSize * kTestTextureSize]);
for (int y = 0; y < kTestTextureSize; ++y) {
for (int x = 0; x < kTestTextureSize; ++x) {
rgbaData[kTestTextureSize * y + x] =
input_texel_color(random->nextULessThan(256), random->nextULessThan(256));
}
}
}
proxies[0] = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes,
rgbaData.get(), kTestTextureSize * sizeof(GrColor));
// Put random values into the alpha texture that the test FPs can optionally use.
desc.fConfig = kAlpha_8_GrPixelConfig;
std::unique_ptr<uint8_t[]> alphaData(new uint8_t[kTestTextureSize * kTestTextureSize]);
for (int y = 0; y < kTestTextureSize; ++y) {
for (int x = 0; x < kTestTextureSize; ++x) {
alphaData[kTestTextureSize * y + x] = random->nextULessThan(256);
}
proxies[0] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
rgbaData.get(),
kTestTextureSize * sizeof(GrColor));
}
{
// Put random values into the alpha texture that the test FPs can optionally use.
desc.fConfig = kAlpha_8_GrPixelConfig;
std::unique_ptr<uint8_t[]> alphaData(new uint8_t[kTestTextureSize * kTestTextureSize]);
for (int y = 0; y < kTestTextureSize; ++y) {
for (int x = 0; x < kTestTextureSize; ++x) {
alphaData[kTestTextureSize * y + x] = random->nextULessThan(256);
}
}
proxies[1] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
alphaData.get(), kTestTextureSize);
}
proxies[1] = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes,
alphaData.get(), kTestTextureSize);
return proxies[0] && proxies[1];
}
// Creates a texture of premul colors used as the output of the fragment processor that precedes
// the fragment processor under test. Color values are those provided by input_texel_color().
sk_sp<GrTextureProxy> make_input_texture(GrContext* context, int width, int height) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> make_input_texture(GrProxyProvider* proxyProvider, int width, int height) {
std::unique_ptr<GrColor[]> data(new GrColor[width * height]);
for (int y = 0; y < width; ++y) {
for (int x = 0; x < height; ++x) {
@ -347,11 +344,14 @@ sk_sp<GrTextureProxy> make_input_texture(GrContext* context, int width, int heig
desc.fWidth = width;
desc.fHeight = height;
desc.fConfig = kRGBA_8888_GrPixelConfig;
return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, SkBudgeted::kYes,
data.get(), width * sizeof(GrColor));
return proxyProvider->createTextureProxy(desc, SkBudgeted::kYes,
data.get(), width * sizeof(GrColor));
}
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
using FPFactory = GrFragmentProcessorTestFactory;
uint32_t seed = 0;
@ -369,13 +369,13 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig, nullptr);
sk_sp<GrTextureProxy> proxies[2];
if (!init_test_textures(context, &random, proxies)) {
if (!init_test_textures(proxyProvider, &random, proxies)) {
ERRORF(reporter, "Could not create test textures");
return;
}
GrProcessorTestData testData(&random, context, rtc.get(), proxies);
auto inputTexture = make_input_texture(context, kRenderSize, kRenderSize);
auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize);
std::unique_ptr<GrColor[]> readData(new GrColor[kRenderSize * kRenderSize]);
// Because processor factories configure themselves in random ways, this is not exhaustive.
@ -489,6 +489,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
// progenitors.
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorCloneTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkRandom random;
@ -498,13 +499,13 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorCloneTest, reporter, ctxInfo) {
SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig, nullptr);
sk_sp<GrTextureProxy> proxies[2];
if (!init_test_textures(context, &random, proxies)) {
if (!init_test_textures(proxyProvider, &random, proxies)) {
ERRORF(reporter, "Could not create test textures");
return;
}
GrProcessorTestData testData(&random, context, rtc.get(), proxies);
auto inputTexture = make_input_texture(context, kRenderSize, kRenderSize);
auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize);
std::unique_ptr<GrColor[]> readData1(new GrColor[kRenderSize * kRenderSize]);
std::unique_ptr<GrColor[]> readData2(new GrColor[kRenderSize * kRenderSize]);
auto readInfo = SkImageInfo::Make(kRenderSize, kRenderSize, kRGBA_8888_SkColorType,

56
tests/ProxyConversionTest.cpp
View File

@ -12,14 +12,14 @@
#if SK_SUPPORT_GPU
#include "GrBackendSurface.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTarget.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTexture.h"
#include "GrTextureProxy.h"
static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrResourceProvider* provider,
static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrProxyProvider* provider,
skiatest::Reporter* reporter,
const GrSurfaceDesc& desc) {
GrGLFramebufferInfo fboInfo;
@ -27,35 +27,25 @@ static sk_sp<GrSurfaceProxy> make_wrapped_FBO0(GrResourceProvider* provider,
GrBackendRenderTarget backendRT(desc.fWidth, desc.fHeight, desc.fSampleCnt, 8,
desc.fConfig, fboInfo);
sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendRT));
SkASSERT(!defaultFBO->asTexture());
return GrSurfaceProxy::MakeWrapped(std::move(defaultFBO), desc.fOrigin);
return provider->createWrappedRenderTargetProxy(backendRT, desc.fOrigin);
}
static sk_sp<GrSurfaceProxy> make_wrapped_offscreen_rt(GrResourceProvider* provider,
skiatest::Reporter* reporter,
const GrSurfaceDesc& desc,
SkBudgeted budgeted) {
static sk_sp<GrSurfaceProxy> make_wrapped_offscreen_rt(GrProxyProvider* provider,
const GrSurfaceDesc& desc) {
SkASSERT(kRenderTarget_GrSurfaceFlag == desc.fFlags);
sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
return provider->createInstantiatedProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
}
static sk_sp<GrSurfaceProxy> make_wrapped_texture(GrResourceProvider* provider,
const GrSurfaceDesc& desc,
SkBudgeted budgeted) {
sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
static sk_sp<GrSurfaceProxy> make_wrapped_texture(GrProxyProvider* provider,
const GrSurfaceDesc& desc) {
return provider->createInstantiatedProxy(desc, SkBackingFit::kExact, SkBudgeted::kYes);
}
// Test converting between RenderTargetProxies and TextureProxies for wrapped
// Proxies
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo) {
GrResourceProvider* provider = ctxInfo.grContext()->resourceProvider();
GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
@ -66,7 +56,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo
if (kOpenGL_GrBackend == ctxInfo.backend()) {
// External on-screen render target.
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_FBO0(provider, reporter, desc));
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_FBO0(proxyProvider, reporter, desc));
// RenderTarget-only
GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy();
@ -77,9 +67,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo
{
// Internal offscreen render target.
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_offscreen_rt(provider,
reporter, desc,
SkBudgeted::kYes));
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_offscreen_rt(proxyProvider, desc));
// Both RenderTarget and Texture
GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy();
@ -92,7 +80,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo
{
// Internal offscreen render target - but through GrTextureProxy
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(provider, desc, SkBudgeted::kYes));
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(proxyProvider, desc));
// Both RenderTarget and Texture
GrTextureProxy* tProxy = sProxy->asTextureProxy();
@ -106,7 +94,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo
{
desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(provider, desc, SkBudgeted::kYes));
sk_sp<GrSurfaceProxy> sProxy(make_wrapped_texture(proxyProvider, desc));
// Texture-only
GrTextureProxy* tProxy = sProxy->asTextureProxy();
@ -129,9 +117,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
desc.fConfig = kRGBA_8888_GrPixelConfig;
{
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
SkBackingFit::kApprox,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
SkBudgeted::kYes);
// Both RenderTarget and Texture
GrRenderTargetProxy* rtProxy = proxy->asRenderTargetProxy();
@ -143,9 +130,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
}
{
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
SkBackingFit::kApprox,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
SkBudgeted::kYes);
// Both RenderTarget and Texture - but via GrTextureProxy
GrTextureProxy* tProxy = proxy->asTextureProxy();
@ -160,10 +146,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
desc.fOrigin = kTopLeft_GrSurfaceOrigin;
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
SkBackingFit::kApprox,
SkBudgeted::kYes));
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
SkBudgeted::kYes);
// Texture-only
GrTextureProxy* tProxy = proxy->asTextureProxy();
REPORTER_ASSERT(reporter, tProxy);

37
tests/ProxyRefTest.cpp
View File

@ -12,6 +12,7 @@
#if SK_SUPPORT_GPU
#include "GrContextPriv.h"
#include "GrGpuResourceRef.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxy.h"
@ -65,7 +66,7 @@ static void check_refs(skiatest::Reporter* reporter,
SkASSERT(proxy->getPendingWriteCnt_TestOnly() == expectedNumWrites);
}
static sk_sp<GrTextureProxy> make_deferred(GrContext* context) {
static sk_sp<GrTextureProxy> make_deferred(GrProxyProvider* proxyProvider) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
@ -73,12 +74,11 @@ static sk_sp<GrTextureProxy> make_deferred(GrContext* context) {
desc.fHeight = kWidthHeight;
desc.fConfig = kRGBA_8888_GrPixelConfig;
return GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(), desc,
SkBackingFit::kApprox, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
return proxyProvider->createProxy(desc, SkBackingFit::kApprox, SkBudgeted::kYes,
GrResourceProvider::kNoPendingIO_Flag);
}
static sk_sp<GrTextureProxy> make_wrapped(GrContext* context) {
static sk_sp<GrTextureProxy> make_wrapped(GrProxyProvider* proxyProvider) {
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
@ -86,18 +86,17 @@ static sk_sp<GrTextureProxy> make_wrapped(GrContext* context) {
desc.fHeight = kWidthHeight;
desc.fConfig = kRGBA_8888_GrPixelConfig;
sk_sp<GrTexture> tex(context->resourceProvider()->createTexture(desc, SkBudgeted::kNo));
return GrSurfaceProxy::MakeWrapped(std::move(tex), desc.fOrigin);
return proxyProvider->createInstantiatedProxy(desc, SkBackingFit::kExact, SkBudgeted::kNo);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
GrResourceProvider* provider = ctxInfo.grContext()->resourceProvider();
GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
GrResourceProvider* resourceProvider = ctxInfo.grContext()->resourceProvider();
for (auto make : { make_deferred, make_wrapped }) {
// A single write
{
sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
GrPendingIOResource<GrSurfaceProxy, kWrite_GrIOType> fWrite(proxy.get());
@ -106,7 +105,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
proxy->instantiate(provider);
proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transfered to the GrSurface
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
@ -115,7 +114,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
// A single read
{
sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
GrPendingIOResource<GrSurfaceProxy, kRead_GrIOType> fRead(proxy.get());
@ -124,7 +123,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
proxy->instantiate(provider);
proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transfered to the GrSurface
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
@ -133,7 +132,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
// A single read/write pair
{
sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
GrPendingIOResource<GrSurfaceProxy, kRW_GrIOType> fRW(proxy.get());
@ -142,7 +141,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
proxy->instantiate(provider);
proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transferred to the GrSurface
check_refs(reporter, proxy.get(), 1, 1, kExpectedReads, kExpectedWrites);
@ -151,7 +150,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
// Multiple normal refs
{
sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
proxy->ref();
proxy->ref();
@ -161,7 +160,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
check_refs(reporter, proxy.get(), 3, 3,kExpectedReads, kExpectedWrites);
proxy->instantiate(provider);
proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transferred to the GrSurface
check_refs(reporter, proxy.get(), 3, 3, kExpectedReads, kExpectedWrites);
@ -173,7 +172,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
// Continue using (reffing) proxy after instantiation
{
sk_sp<GrTextureProxy> proxy((*make)(ctxInfo.grContext()));
sk_sp<GrTextureProxy> proxy((*make)(proxyProvider));
if (proxy.get()) {
proxy->ref();
@ -183,7 +182,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
check_refs(reporter, proxy.get(), 2, 2, 0, kExpectedWrites);
proxy->instantiate(provider);
proxy->instantiate(resourceProvider);
// In the deferred case, this checks that the refs transfered to the GrSurface
check_refs(reporter, proxy.get(), 2, 2, 0, kExpectedWrites);

86
tests/ProxyTest.cpp
View File

@ -13,6 +13,7 @@
#include "GrBackendSurface.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetPriv.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceProvider.h"
@ -26,17 +27,12 @@ static void check_surface(skiatest::Reporter* reporter,
GrSurfaceOrigin origin,
int width, int height,
GrPixelConfig config,
const GrGpuResource::UniqueID& uniqueID,
SkBudgeted budgeted) {
REPORTER_ASSERT(reporter, proxy->origin() == origin);
REPORTER_ASSERT(reporter, proxy->width() == width);
REPORTER_ASSERT(reporter, proxy->height() == height);
REPORTER_ASSERT(reporter, proxy->config() == config);
if (!uniqueID.isInvalid()) {
REPORTER_ASSERT(reporter, proxy->uniqueID().asUInt() == uniqueID.asUInt());
} else {
REPORTER_ASSERT(reporter, !proxy->uniqueID().isInvalid());
}
REPORTER_ASSERT(reporter, !proxy->uniqueID().isInvalid());
REPORTER_ASSERT(reporter, proxy->isBudgeted() == budgeted);
}
@ -114,8 +110,6 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
GrResourceProvider* resourceProvider = ctxInfo.grContext()->resourceProvider();
const GrCaps& caps = *ctxInfo.grContext()->caps();
const GrGpuResource::UniqueID kInvalidResourceID = GrGpuResource::UniqueID::InvalidID();
int attempt = 0; // useful for debugging
for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
@ -141,9 +135,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
tex = resourceProvider->createTexture(desc, budgeted);
}
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
proxyProvider, desc,
fit, budgeted));
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
desc, fit, budgeted);
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
@ -155,8 +148,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), origin,
widthHeight, widthHeight, config,
kInvalidResourceID, budgeted);
widthHeight, widthHeight, config, budgeted);
int supportedSamples = caps.getSampleCount(numSamples, config);
check_rendertarget(reporter, caps, resourceProvider,
proxy->asRenderTargetProxy(),
@ -175,11 +167,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
tex = resourceProvider->createTexture(desc, budgeted);
}
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
proxyProvider,
desc,
fit,
budgeted));
sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
desc, fit, budgeted));
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
// This forces the proxy to compute and cache its
@ -190,8 +179,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), origin,
widthHeight, widthHeight, config,
kInvalidResourceID, budgeted);
widthHeight, widthHeight, config, budgeted);
check_texture(reporter, resourceProvider,
proxy->asTextureProxy(), fit, false);
}
@ -207,6 +195,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
GrResourceProvider* provider = ctxInfo.grContext()->resourceProvider();
const GrCaps& caps = *ctxInfo.grContext()->caps();
@ -234,49 +223,45 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, 8,
config, fboInfo);
sk_sp<GrRenderTarget> defaultFBO(
provider->wrapBackendRenderTarget(backendRT));
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(defaultFBO,
origin));
sk_sp<GrSurfaceProxy> sProxy(proxyProvider->createWrappedRenderTargetProxy(
backendRT, origin));
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight, config,
defaultFBO->uniqueID(), SkBudgeted::kNo);
kWidthHeight, kWidthHeight, config, SkBudgeted::kNo);
check_rendertarget(reporter, caps, provider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact, 0, true);
}
sk_sp<GrTexture> tex;
// Internal offscreen render target.
if (renderable) {
// Internal offscreen render target.
desc.fFlags = kRenderTarget_GrSurfaceFlag;
tex = provider->createTexture(desc, budgeted);
if (!tex) {
continue; // This can fail on Mesa
}
sk_sp<GrRenderTarget> rt(sk_ref_sp(tex->asRenderTarget()));
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(rt, origin));
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->createInstantiatedProxy(
desc, SkBackingFit::kExact, budgeted);
if (!sProxy) {
continue; // This can fail on Mesa
}
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight, config,
rt->uniqueID(), budgeted);
kWidthHeight, kWidthHeight, config, budgeted);
check_rendertarget(reporter, caps, provider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles(), true);
}
if (!tex) {
} else {
// Internal offscreen texture
SkASSERT(kNone_GrSurfaceFlags == desc.fFlags );
desc.fSampleCnt = 0;
tex = provider->createTexture(desc, budgeted);
}
sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(tex, origin));
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight, config, tex->uniqueID(), budgeted);
check_texture(reporter, provider, sProxy->asTextureProxy(),
SkBackingFit::kExact, true);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->createInstantiatedProxy(
desc, SkBackingFit::kExact, budgeted);
if (!sProxy) {
continue;
}
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight, config, budgeted);
check_texture(reporter, provider, sProxy->asTextureProxy(),
SkBackingFit::kExact, true);
}
}
}
}
@ -302,10 +287,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ZeroSizedProxyTest, reporter, ctxInfo) {
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fSampleCnt = 0;
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(provider,
desc,
fit,
SkBudgeted::kNo));
sk_sp<GrTextureProxy> proxy = provider->createProxy(desc, fit, SkBudgeted::kNo);
REPORTER_ASSERT(reporter, !proxy);
}
}

8
tests/ReadPixelsTest.cpp
View File

@ -18,6 +18,7 @@
#include "GrContext.h"
#include "GrContextFactory.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "SkGr.h"
#endif
@ -463,10 +464,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Texture, reporter, ctxInfo) {
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fOrigin = origin;
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kNo,
bmp.getPixels(),
bmp.rowBytes());
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
bmp.getPixels(),
bmp.rowBytes());
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
std::move(proxy), nullptr);

12
tests/ReadWriteAlphaTest.cpp
View File

@ -12,6 +12,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrResourceProvider.h"
#include "GrSurfaceContext.h"
#include "GrSurfaceProxy.h"
@ -60,9 +61,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
// We are initializing the texture with zeros here
memset(alphaData, 0, X_SIZE * Y_SIZE);
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kNo,
alphaData, 0));
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
alphaData, 0);
if (!proxy) {
ERRORF(reporter, "Could not create alpha texture.");
return;
@ -167,9 +167,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
}
}
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kNo,
rgbaData, 0));
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(desc, SkBudgeted::kNo,
rgbaData, 0);
if (!proxy) {
// We always expect to be able to create a RGBA texture
if (!rt && kRGBA_8888_GrPixelConfig == desc.fConfig) {

8
tests/RectangleTextureTest.cpp
View File

@ -12,6 +12,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrTest.h"
#include "gl/GLTestContext.h"
@ -85,6 +86,7 @@ static void test_clear(skiatest::Reporter* reporter, GrSurfaceContext* rectConte
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_gpu_test::GLTestContext* glContext = ctxInfo.glContext();
static const int kWidth = 13;
static const int kHeight = 13;
@ -125,9 +127,9 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
}
}
sk_sp<GrTextureProxy> rectProxy = GrSurfaceProxy::MakeWrappedBackend(context,
rectangleTex,
origin);
sk_sp<GrTextureProxy> rectProxy = proxyProvider->createWrappedTextureProxy(
rectangleTex, origin);
if (!rectProxy) {
ERRORF(reporter, "Error creating proxy for rectangle texture.");
GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));

9
tests/ResourceAllocatorTest.cpp
View File

@ -14,6 +14,7 @@
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrProxyProvider.h"
#include "GrResourceAllocator.h"
#include "GrResourceProvider.h"
#include "GrSurfaceProxyPriv.h"
@ -40,18 +41,18 @@ static sk_sp<GrSurfaceProxy> make_deferred(GrProxyProvider* proxyProvider, const
desc.fConfig = p.fConfig;
desc.fSampleCnt = p.fSampleCnt;
return GrSurfaceProxy::MakeDeferred(proxyProvider, desc, p.fFit, SkBudgeted::kNo);
return proxyProvider->createProxy(desc, p.fFit, SkBudgeted::kNo);
}
static sk_sp<GrSurfaceProxy> make_backend(GrContext* context, const ProxyParams& p,
GrBackendTexture* backendTex) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
*backendTex = context->getGpu()->createTestingOnlyBackendTexture(nullptr, p.fSize, p.fSize,
p.fConfig, false,
GrMipMapped::kNo);
sk_sp<GrSurface> tex = context->resourceProvider()->wrapBackendTexture(*backendTex,
kBorrow_GrWrapOwnership);
return GrSurfaceProxy::MakeWrapped(std::move(tex), p.fOrigin);
return proxyProvider->createWrappedTextureProxy(*backendTex, p.fOrigin);
}
static void cleanup_backend(GrContext* context, GrBackendTexture* backendTex) {

6
tests/ResourceCacheTest.cpp
View File

@ -16,6 +16,7 @@
#include "GrGpu.h"
#include "GrGpuResourceCacheAccess.h"
#include "GrGpuResourcePriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetPriv.h"
#include "GrResourceCache.h"
#include "GrResourceProvider.h"
@ -1632,7 +1633,7 @@ static sk_sp<GrTexture> make_normal_texture(GrResourceProvider* provider,
return provider->createTexture(desc, SkBudgeted::kYes);
}
static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* provider,
static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* proxyProvider,
GrSurfaceFlags flags,
int width, int height,
int sampleCnt) {
@ -1668,8 +1669,7 @@ static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* provider,
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fSampleCnt = sampleCnt;
return GrSurfaceProxy::MakeDeferredMipMap(provider, desc, SkBudgeted::kYes,
texels.get(), mipLevelCount);
return proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes, texels.get(), mipLevelCount);
}
// Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,

6
tests/SRGBMipMapTest.cpp
View File

@ -11,6 +11,7 @@
#include "GrClip.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "SkCanvas.h"
#include "SkGr.h"
@ -131,9 +132,8 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SRGBMipMaps, reporter, ctxInfo) {
desc.fConfig = kSRGBA_8888_GrPixelConfig;
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
desc, SkBudgeted::kNo,
texData, 0);
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
desc, SkBudgeted::kNo, texData, 0);
// Create two render target contexts (L32 and S32)
sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::MakeSRGB();

20
tests/SpecialImageTest.cpp
View File

@ -18,6 +18,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTextureProxy.h"
#include "SkGr.h"
@ -207,6 +208,7 @@ static void test_texture_backed(skiatest::Reporter* reporter,
// Test out the SkSpecialImage::makeTextureImage entry point
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkBitmap bm = create_bm();
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
@ -235,10 +237,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo)
// gpu
const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
context->contextPriv().proxyProvider(),
desc, SkBudgeted::kNo,
bm.getPixels(), bm.rowBytes()));
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
desc, SkBudgeted::kNo, bm.getPixels(), bm.rowBytes());
if (!proxy) {
return;
}
@ -265,13 +265,13 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo)
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkBitmap bm = create_bm();
const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
desc, SkBudgeted::kNo,
bm.getPixels(), bm.rowBytes()));
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
desc, SkBudgeted::kNo, bm.getPixels(), bm.rowBytes());
if (!proxy) {
return;
}
@ -300,6 +300,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_DeferredGpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
SkBitmap bm = create_bm();
GrSurfaceDesc desc;
@ -309,9 +310,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_DeferredGpu, reporter, ctxInfo)
desc.fHeight = kFullSize;
desc.fConfig = kSkia8888_GrPixelConfig;
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->contextPriv().proxyProvider(),
desc, SkBudgeted::kNo,
bm.getPixels(), 0));
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(
desc, SkBudgeted::kNo, bm.getPixels(), bm.rowBytes());
if (!proxy) {
return;
}

7
tests/TestUtils.cpp
View File

@ -9,6 +9,7 @@
#if SK_SUPPORT_GPU
#include "GrProxyProvider.h"
#include "GrSurfaceContext.h"
#include "GrSurfaceProxy.h"
#include "GrTextureProxy.h"
@ -111,9 +112,9 @@ void test_copy_to_surface(skiatest::Reporter* reporter, GrProxyProvider* proxyPr
copySrcDesc.fOrigin = (kNone_GrSurfaceFlags == flags) ? kTopLeft_GrSurfaceOrigin
: kBottomLeft_GrSurfaceOrigin;
sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(proxyProvider,
copySrcDesc,
SkBudgeted::kYes, pixels.get(), 0));
sk_sp<GrTextureProxy> src = proxyProvider->createTextureProxy(copySrcDesc, SkBudgeted::kYes,
pixels.get(), 0);
dstContext->copy(src.get());
test_read_pixels(reporter, dstContext, pixels.get(), testName);

37
tests/TextureProxyTest.cpp
View File

@ -45,11 +45,10 @@ static GrSurfaceDesc make_desc(GrSurfaceFlags flags) {
static sk_sp<GrTextureProxy> deferred_tex(skiatest::Reporter* reporter,
GrContext* context, SkBackingFit fit) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, fit, SkBudgeted::kYes);
// Only budgeted & wrapped external proxies get to carry uniqueKeys
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, fit,
SkBudgeted::kYes);
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
}
@ -57,31 +56,22 @@ static sk_sp<GrTextureProxy> deferred_tex(skiatest::Reporter* reporter,
static sk_sp<GrTextureProxy> deferred_texRT(skiatest::Reporter* reporter,
GrContext* context, SkBackingFit fit) {
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
GrSurfaceDesc desc = make_desc(kRenderTarget_GrSurfaceFlag);
const GrSurfaceDesc desc = make_desc(kRenderTarget_GrSurfaceFlag);
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(desc, fit, SkBudgeted::kYes);
// Only budgeted & wrapped external proxies get to carry uniqueKeys
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, desc, fit,
SkBudgeted::kYes);
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
}
static sk_sp<GrTextureProxy> wrapped(skiatest::Reporter* reporter,
GrContext* context, SkBackingFit fit) {
GrResourceProvider* resourceProvider = context->resourceProvider();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = sk_sp<GrTexture>(resourceProvider->createApproxTexture(desc, 0));
} else {
// Only budgeted & wrapped external proxies get to carry uniqueKeys
tex = resourceProvider->createTexture(desc, SkBudgeted::kYes);
}
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(std::move(tex),
kBottomLeft_GrSurfaceOrigin);
sk_sp<GrTextureProxy> proxy = proxyProvider->createInstantiatedProxy(desc, fit,
SkBudgeted::kYes);
// Only budgeted & wrapped external proxies get to carry uniqueKeys
REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
return proxy;
}
@ -99,7 +89,7 @@ static sk_sp<GrTextureProxy> wrapped_with_key(skiatest::Reporter* reporter,
builder[0] = kUniqueKeyData++;
builder.finish();
GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
@ -119,18 +109,19 @@ static sk_sp<GrTextureProxy> wrapped_with_key(skiatest::Reporter* reporter,
static sk_sp<GrTextureProxy> create_wrapped_backend(GrContext* context, SkBackingFit fit,
sk_sp<GrTexture>* backingSurface) {
GrResourceProvider* provider = context->resourceProvider();
GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
GrResourceProvider* resourceProvider = context->resourceProvider();
const GrSurfaceDesc desc = make_desc(kNone_GrSurfaceFlags);
*backingSurface = provider->createTexture(desc, SkBudgeted::kNo);
*backingSurface = resourceProvider->createTexture(desc, SkBudgeted::kNo);
if (!(*backingSurface)) {
return nullptr;
}
GrBackendTexture backendTex = (*backingSurface)->getBackendTexture();
return GrSurfaceProxy::MakeWrappedBackend(context, backendTex, kBottomLeft_GrSurfaceOrigin);
return proxyProvider->createWrappedTextureProxy(backendTex, kBottomLeft_GrSurfaceOrigin);
}

8
tests/VkUploadPixelsTests.cpp
View File

@ -13,6 +13,7 @@
#include "GrContextFactory.h"
#include "GrContextPriv.h"
#include "GrProxyProvider.h"
#include "GrSurfaceProxy.h"
#include "GrTest.h"
#include "SkGr.h"
@ -73,9 +74,8 @@ void basic_texture_test(skiatest::Reporter* reporter, GrContext* context, GrPixe
SkColorType ct;
SkAssertResult(GrPixelConfigToColorType(config, &ct));
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(proxyProvider,
surfDesc, SkBudgeted::kNo,
srcBuffer, 0);
sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy(surfDesc, SkBudgeted::kNo,
srcBuffer, 0);
REPORTER_ASSERT(reporter, proxy);
if (proxy) {
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
@ -107,7 +107,7 @@ void basic_texture_test(skiatest::Reporter* reporter, GrContext* context, GrPixe
surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
proxy = GrSurfaceProxy::MakeDeferred(proxyProvider, surfDesc, SkBudgeted::kNo, srcBuffer, 0);
proxy = proxyProvider->createTextureProxy(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
REPORTER_ASSERT(reporter, proxy);
if (proxy) {
sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(

6
tests/WritePixelsTest.cpp
View File

@ -17,6 +17,7 @@
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrProxyProvider.h"
#include "GrTest.h"
#endif
@ -501,9 +502,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixelsPendingIO, reporter, ctxInfo) {
desc.fHeight = 64;
desc.fConfig = kRGBA_8888_GrPixelConfig;
sk_sp<GrTextureProxy> temp = GrSurfaceProxy::MakeDeferred(proxyProvider, desc,
SkBackingFit::kApprox,
SkBudgeted::kYes);
sk_sp<GrTextureProxy> temp = proxyProvider->createProxy(desc, SkBackingFit::kApprox,
SkBudgeted::kYes);
temp->instantiate(context->resourceProvider());
}