/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrDrawingManager.h"
#include "GrBackendSemaphore.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "GrMemoryPool.h"
#include "GrOnFlushResourceProvider.h"
#include "GrOpList.h"
#include "GrRenderTargetContext.h"
#include "GrRenderTargetProxy.h"
#include "GrResourceAllocator.h"
#include "GrResourceProvider.h"
#include "GrSoftwarePathRenderer.h"
#include "GrSurfaceProxyPriv.h"
#include "GrTexture.h"
#include "GrTextureContext.h"
#include "GrTextureOpList.h"
#include "GrTexturePriv.h"
#include "GrTextureProxy.h"
#include "GrTextureProxyPriv.h"
#include "GrTracing.h"
#include "SkDeferredDisplayList.h"
#include "SkSurface_Gpu.h"
#include "SkTTopoSort.h"
#include "ccpr/GrCoverageCountingPathRenderer.h"
#include "text/GrTextContext.h"
GrDrawingManager::OpListDAG::OpListDAG(bool explicitlyAllocating,
GrContextOptions::Enable sortOpLists) {
if (GrContextOptions::Enable::kNo == sortOpLists) {
fSortOpLists = false;
} else if (GrContextOptions::Enable::kYes == sortOpLists) {
fSortOpLists = true;
} else {
// By default we always enable sorting when we're explicitly allocating GPU resources
fSortOpLists = explicitlyAllocating;
}
}
GrDrawingManager::OpListDAG::~OpListDAG() {}
void GrDrawingManager::OpListDAG::gatherIDs(SkSTArray<8, uint32_t, true>* idArray) const {
idArray->reset(fOpLists.count());
for (int i = 0; i < fOpLists.count(); ++i) {
if (fOpLists[i]) {
(*idArray)[i] = fOpLists[i]->uniqueID();
}
}
}
void GrDrawingManager::OpListDAG::reset() {
fOpLists.reset();
}
void GrDrawingManager::OpListDAG::removeOpList(int index) {
if (!fOpLists[index]->unique()) {
// TODO: Eventually this should be guaranteed unique: http://skbug.com/7111
fOpLists[index]->endFlush();
}
fOpLists[index] = nullptr;
}
void GrDrawingManager::OpListDAG::removeOpLists(int startIndex, int stopIndex) {
for (int i = startIndex; i < stopIndex; ++i) {
if (!fOpLists[i]) {
continue;
}
this->removeOpList(i);
}
}
void GrDrawingManager::OpListDAG::add(sk_sp<GrOpList> opList) {
fOpLists.emplace_back(std::move(opList));
}
void GrDrawingManager::OpListDAG::add(const SkTArray<sk_sp<GrOpList>>& opLists) {
fOpLists.push_back_n(opLists.count(), opLists.begin());
}
void GrDrawingManager::OpListDAG::swap(SkTArray<sk_sp<GrOpList>>* opLists) {
SkASSERT(opLists->empty());
opLists->swap(fOpLists);
}
void GrDrawingManager::OpListDAG::prepForFlush() {
if (fSortOpLists) {
SkDEBUGCODE(bool result =) SkTTopoSort<GrOpList, GrOpList::TopoSortTraits>(&fOpLists);
SkASSERT(result);
}
#ifdef SK_DEBUG
// This block checks for any unnecessary splits in the opLists. If two sequential opLists
// share the same backing GrSurfaceProxy it means the opList was artificially split.
if (fOpLists.count()) {
GrRenderTargetOpList* prevOpList = fOpLists[0]->asRenderTargetOpList();
for (int i = 1; i < fOpLists.count(); ++i) {
GrRenderTargetOpList* curOpList = fOpLists[i]->asRenderTargetOpList();
if (prevOpList && curOpList) {
SkASSERT(prevOpList->fTarget.get() != curOpList->fTarget.get());
}
prevOpList = curOpList;
}
}
#endif
}
void GrDrawingManager::OpListDAG::closeAll(const GrCaps* caps) {
for (int i = 0; i < fOpLists.count(); ++i) {
if (fOpLists[i]) {
fOpLists[i]->makeClosed(*caps);
}
}
}
void GrDrawingManager::OpListDAG::cleanup(const GrCaps* caps) {
for (int i = 0; i < fOpLists.count(); ++i) {
if (!fOpLists[i]) {
continue;
}
// no opList should receive a new command after this
fOpLists[i]->makeClosed(*caps);
// We shouldn't need to do this, but it turns out some clients still hold onto opLists
// after a cleanup.
// MDB TODO: is this still true?
if (!fOpLists[i]->unique()) {
// TODO: Eventually this should be guaranteed unique.
// https://bugs.chromium.org/p/skia/issues/detail?id=7111
fOpLists[i]->endFlush();
}
}
fOpLists.reset();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
GrDrawingManager::GrDrawingManager(GrContext* context,
const GrPathRendererChain::Options& optionsForPathRendererChain,
const GrTextContext::Options& optionsForTextContext,
GrSingleOwner* singleOwner,
bool explicitlyAllocating,
GrContextOptions::Enable sortOpLists,
GrContextOptions::Enable reduceOpListSplitting)
: fContext(context)
, fOptionsForPathRendererChain(optionsForPathRendererChain)
, fOptionsForTextContext(optionsForTextContext)
, fSingleOwner(singleOwner)
, fAbandoned(false)
, fDAG(explicitlyAllocating, sortOpLists)
, fTextContext(nullptr)
, fPathRendererChain(nullptr)
, fSoftwarePathRenderer(nullptr)
, fFlushing(false) {
if (GrContextOptions::Enable::kNo == reduceOpListSplitting) {
fReduceOpListSplitting = false;
} else if (GrContextOptions::Enable::kYes == reduceOpListSplitting) {
fReduceOpListSplitting = true;
} else {
// For now, this is only turned on when explicitly enabled. Once mini-flushes are
// implemented it should be enabled whenever sorting is enabled.
fReduceOpListSplitting = false; // sortOpLists
}
}
void GrDrawingManager::cleanup() {
fDAG.cleanup(fContext->contextPriv().caps());
fPathRendererChain = nullptr;
fSoftwarePathRenderer = nullptr;
fOnFlushCBObjects.reset();
}
GrDrawingManager::~GrDrawingManager() {
this->cleanup();
}
void GrDrawingManager::abandon() {
fAbandoned = true;
this->cleanup();
}
void GrDrawingManager::freeGpuResources() {
for (int i = fOnFlushCBObjects.count() - 1; i >= 0; --i) {
if (!fOnFlushCBObjects[i]->retainOnFreeGpuResources()) {
// it's safe to just do this because we're iterating in reverse
fOnFlushCBObjects.removeShuffle(i);
}
}
// a path renderer may be holding onto resources
fPathRendererChain = nullptr;
fSoftwarePathRenderer = nullptr;
}
// MDB TODO: make use of the 'proxy' parameter.
GrSemaphoresSubmitted GrDrawingManager::flush(GrSurfaceProxy*,
int numSemaphores,
GrBackendSemaphore backendSemaphores[]) {
GR_CREATE_TRACE_MARKER_CONTEXT("GrDrawingManager", "flush", fContext);
if (fFlushing || this->wasAbandoned()) {
return GrSemaphoresSubmitted::kNo;
}
SkDEBUGCODE(this->validate());
GrGpu* gpu = fContext->contextPriv().getGpu();
if (!gpu) {
return GrSemaphoresSubmitted::kNo; // Can't flush while DDL recording
}
fFlushing = true;
// Semi-usually the GrOpLists are already closed at this point, but sometimes Ganesh
// needs to flush mid-draw. In that case, the SkGpuDevice's GrOpLists won't be closed
// but need to be flushed anyway. Closing such GrOpLists here will mean new
// GrOpLists will be created to replace them if the SkGpuDevice(s) write to them again.
fDAG.closeAll(fContext->contextPriv().caps());
fActiveOpList = nullptr;
fDAG.prepForFlush();
SkASSERT(SkToBool(fVertexBufferSpace) == SkToBool(fIndexBufferSpace));
if (!fVertexBufferSpace) {
fVertexBufferSpace.reset(new char[GrBufferAllocPool::kDefaultBufferSize]());
fIndexBufferSpace.reset(new char[GrBufferAllocPool::kDefaultBufferSize]());
}
GrOpFlushState flushState(gpu, fContext->contextPriv().resourceProvider(), &fTokenTracker,
fVertexBufferSpace.get(), fIndexBufferSpace.get());
GrOnFlushResourceProvider onFlushProvider(this);
// TODO: AFAICT the only reason fFlushState is on GrDrawingManager rather than on the
// stack here is to preserve the flush tokens.
// Prepare any onFlush op lists (e.g. atlases).
if (!fOnFlushCBObjects.empty()) {
fDAG.gatherIDs(&fFlushingOpListIDs);
SkSTArray<4, sk_sp<GrRenderTargetContext>> renderTargetContexts;
for (GrOnFlushCallbackObject* onFlushCBObject : fOnFlushCBObjects) {
onFlushCBObject->preFlush(&onFlushProvider,
fFlushingOpListIDs.begin(), fFlushingOpListIDs.count(),
&renderTargetContexts);
for (const sk_sp<GrRenderTargetContext>& rtc : renderTargetContexts) {
sk_sp<GrRenderTargetOpList> onFlushOpList = sk_ref_sp(rtc->getRTOpList());
if (!onFlushOpList) {
continue; // Odd - but not a big deal
}
#ifdef SK_DEBUG
// OnFlush callbacks are already invoked during flush, and are therefore expected to
// handle resource allocation & usage on their own. (No deferred or lazy proxies!)
onFlushOpList->visitProxies_debugOnly([](GrSurfaceProxy* p) {
SkASSERT(!p->asTextureProxy() || !p->asTextureProxy()->texPriv().isDeferred());
SkASSERT(GrSurfaceProxy::LazyState::kNot == p->lazyInstantiationState());
});
#endif
onFlushOpList->makeClosed(*fContext->contextPriv().caps());
onFlushOpList->prepare(&flushState);
fOnFlushCBOpLists.push_back(std::move(onFlushOpList));
}
renderTargetContexts.reset();
}
}
#if 0
// Enable this to print out verbose GrOp information
for (int i = 0; i < fOpLists.count(); ++i) {
SkDEBUGCODE(fOpLists[i]->dump();)
}
#endif
int startIndex, stopIndex;
bool flushed = false;
{
GrResourceAllocator alloc(fContext->contextPriv().resourceProvider(),
flushState.deinstantiateProxyTracker());
for (int i = 0; i < fDAG.numOpLists(); ++i) {
if (fDAG.opList(i)) {
fDAG.opList(i)->gatherProxyIntervals(&alloc);
}
alloc.markEndOfOpList(i);
}
GrResourceAllocator::AssignError error = GrResourceAllocator::AssignError::kNoError;
int numOpListsExecuted = 0;
while (alloc.assign(&startIndex, &stopIndex, &error)) {
if (GrResourceAllocator::AssignError::kFailedProxyInstantiation == error) {
for (int i = startIndex; i < stopIndex; ++i) {
if (fDAG.opList(i) && !fDAG.opList(i)->isFullyInstantiated()) {
// If the backing surface wasn't allocated drop the entire opList.
fDAG.removeOpList(i);
}
if (fDAG.opList(i)) {
fDAG.opList(i)->purgeOpsWithUninstantiatedProxies();
}
}
}
if (this->executeOpLists(startIndex, stopIndex, &flushState, &numOpListsExecuted)) {
flushed = true;
}
}
}
#ifdef SK_DEBUG
for (int i = 0; i < fDAG.numOpLists(); ++i) {
// If there are any remaining opLists at this point, make sure they will not survive the
// flush. Otherwise we need to call endFlush() on them.
// http://skbug.com/7111
SkASSERT(!fDAG.opList(i) || fDAG.opList(i)->unique());
}
#endif
fDAG.reset();
#ifdef SK_DEBUG
// In non-DDL mode this checks that all the flushed ops have been freed from the memory pool.
// When we move to partial flushes this assert will no longer be valid.
// In DDL mode this check is somewhat superfluous since the memory for most of the ops/opLists
// will be stored in the DDL's GrOpMemoryPools.
GrOpMemoryPool* opMemoryPool = fContext->contextPriv().opMemoryPool();
opMemoryPool->isEmpty();
#endif
GrSemaphoresSubmitted result = gpu->finishFlush(numSemaphores, backendSemaphores);
flushState.deinstantiateProxyTracker()->deinstantiateAllProxies();
// Give the cache a chance to purge resources that become purgeable due to flushing.
if (flushed) {
fContext->contextPriv().getResourceCache()->purgeAsNeeded();
}
for (GrOnFlushCallbackObject* onFlushCBObject : fOnFlushCBObjects) {
onFlushCBObject->postFlush(fTokenTracker.nextTokenToFlush(), fFlushingOpListIDs.begin(),
fFlushingOpListIDs.count());
}
fFlushingOpListIDs.reset();
fFlushing = false;
return result;
}
bool GrDrawingManager::executeOpLists(int startIndex, int stopIndex, GrOpFlushState* flushState,
int* numOpListsExecuted) {
SkASSERT(startIndex <= stopIndex && stopIndex <= fDAG.numOpLists());
#if GR_FLUSH_TIME_OP_SPEW
SkDebugf("Flushing opLists: %d to %d out of [%d, %d]\n",
startIndex, stopIndex, 0, fDAG.numOpLists());
for (int i = startIndex; i < stopIndex; ++i) {
if (fDAG.opList(i)) {
fDAG.opList(i)->dump(true);
}
}
#endif
GrResourceProvider* resourceProvider = fContext->contextPriv().resourceProvider();
bool anyOpListsExecuted = false;
for (int i = startIndex; i < stopIndex; ++i) {
if (!fDAG.opList(i)) {
continue;
}
GrOpList* opList = fDAG.opList(i);
if (resourceProvider->explicitlyAllocateGPUResources()) {
if (!opList->isFullyInstantiated()) {
// If the backing surface wasn't allocated drop the draw of the entire opList.
fDAG.removeOpList(i);
continue;
}
} else {
if (!opList->instantiate(resourceProvider)) {
fDAG.removeOpList(i);
continue;
}
}
// TODO: handle this instantiation via lazy surface proxies?
// Instantiate all deferred proxies (being built on worker threads) so we can upload them
opList->instantiateDeferredProxies(fContext->contextPriv().resourceProvider());
opList->prepare(flushState);
}
// Upload all data to the GPU
flushState->preExecuteDraws();
// For Vulkan, if we have too many oplists to be flushed we end up allocating a lot of resources
// for each command buffer associated with the oplists. If this gets too large we can cause the
// devices to go OOM. In practice we usually only hit this case in our tests, but to be safe we
// put a cap on the number of oplists we will execute before flushing to the GPU to relieve some
// memory pressure.
static constexpr int kMaxOpListsBeforeFlush = 100;
// Execute the onFlush op lists first, if any.
for (sk_sp<GrOpList>& onFlushOpList : fOnFlushCBOpLists) {
if (!onFlushOpList->execute(flushState)) {
SkDebugf("WARNING: onFlushOpList failed to execute.\n");
}
SkASSERT(onFlushOpList->unique());
onFlushOpList = nullptr;
(*numOpListsExecuted)++;
if (*numOpListsExecuted >= kMaxOpListsBeforeFlush) {
flushState->gpu()->finishFlush(0, nullptr);
*numOpListsExecuted = 0;
}
}
fOnFlushCBOpLists.reset();
// Execute the normal op lists.
for (int i = startIndex; i < stopIndex; ++i) {
if (!fDAG.opList(i)) {
continue;
}
if (fDAG.opList(i)->execute(flushState)) {
anyOpListsExecuted = true;
}
(*numOpListsExecuted)++;
if (*numOpListsExecuted >= kMaxOpListsBeforeFlush) {
flushState->gpu()->finishFlush(0, nullptr);
*numOpListsExecuted = 0;
}
}
SkASSERT(!flushState->commandBuffer());
SkASSERT(fTokenTracker.nextDrawToken() == fTokenTracker.nextTokenToFlush());
// We reset the flush state before the OpLists so that the last resources to be freed are those
// that are written to in the OpLists. This helps to make sure the most recently used resources
// are the last to be purged by the resource cache.
flushState->reset();
fDAG.removeOpLists(startIndex, stopIndex);
return anyOpListsExecuted;
}
GrSemaphoresSubmitted GrDrawingManager::prepareSurfaceForExternalIO(
GrSurfaceProxy* proxy, int numSemaphores, GrBackendSemaphore backendSemaphores[]) {
if (this->wasAbandoned()) {
return GrSemaphoresSubmitted::kNo;
}
SkDEBUGCODE(this->validate());
SkASSERT(proxy);
GrGpu* gpu = fContext->contextPriv().getGpu();
if (!gpu) {
return GrSemaphoresSubmitted::kNo; // Can't flush while DDL recording
}
GrSemaphoresSubmitted result = GrSemaphoresSubmitted::kNo;
if (proxy->priv().hasPendingIO() || numSemaphores) {
result = this->flush(proxy, numSemaphores, backendSemaphores);
}
if (!proxy->instantiate(fContext->contextPriv().resourceProvider())) {
return result;
}
GrSurface* surface = proxy->peekSurface();
if (auto* rt = surface->asRenderTarget()) {
gpu->resolveRenderTarget(rt);
}
if (auto* tex = surface->asTexture()) {
if (tex->texturePriv().mipMapped() == GrMipMapped::kYes &&
tex->texturePriv().mipMapsAreDirty()) {
gpu->regenerateMipMapLevels(tex);
}
}
SkDEBUGCODE(this->validate());
return result;
}
void GrDrawingManager::addOnFlushCallbackObject(GrOnFlushCallbackObject* onFlushCBObject) {
fOnFlushCBObjects.push_back(onFlushCBObject);
}
void GrDrawingManager::moveOpListsToDDL(SkDeferredDisplayList* ddl) {
SkDEBUGCODE(this->validate());
// no opList should receive a new command after this
fDAG.closeAll(fContext->contextPriv().caps());
fActiveOpList = nullptr;
fDAG.swap(&ddl->fOpLists);
if (fPathRendererChain) {
if (auto ccpr = fPathRendererChain->getCoverageCountingPathRenderer()) {
ddl->fPendingPaths = ccpr->detachPendingPaths();
}
}
SkDEBUGCODE(this->validate());
}
void GrDrawingManager::copyOpListsFromDDL(const SkDeferredDisplayList* ddl,
GrRenderTargetProxy* newDest) {
SkDEBUGCODE(this->validate());
if (fActiveOpList) {
// This is a temporary fix for the partial-MDB world. In that world we're not
// reordering so ops that (in the single opList world) would've just glommed onto the
// end of the single opList but referred to a far earlier RT need to appear in their
// own opList.
fActiveOpList->makeClosed(*fContext->contextPriv().caps());
fActiveOpList = nullptr;
}
// Here we jam the proxy that backs the current replay SkSurface into the LazyProxyData.
// The lazy proxy that references it (in the copied opLists) will steal its GrTexture.
ddl->fLazyProxyData->fReplayDest = newDest;
if (ddl->fPendingPaths.size()) {
GrCoverageCountingPathRenderer* ccpr = this->getCoverageCountingPathRenderer();
ccpr->mergePendingPaths(ddl->fPendingPaths);
}
fDAG.add(ddl->fOpLists);
SkDEBUGCODE(this->validate());
}
#ifdef SK_DEBUG
void GrDrawingManager::validate() const {
if (fDAG.sortingOpLists() && fReduceOpListSplitting) {
SkASSERT(!fActiveOpList);
} else {
if (fActiveOpList) {
SkASSERT(!fDAG.empty());
SkASSERT(!fActiveOpList->isClosed());
SkASSERT(fActiveOpList == fDAG.back());
}
for (int i = 0; i < fDAG.numOpLists(); ++i) {
if (fActiveOpList != fDAG.opList(i)) {
SkASSERT(fDAG.opList(i)->isClosed());
}
}
if (!fDAG.empty() && !fDAG.back()->isClosed()) {
SkASSERT(fActiveOpList == fDAG.back());
}
}
}
#endif
sk_sp<GrRenderTargetOpList> GrDrawingManager::newRTOpList(GrRenderTargetProxy* rtp,
bool managedOpList) {
SkDEBUGCODE(this->validate());
SkASSERT(fContext);
if (fDAG.sortingOpLists() && fReduceOpListSplitting) {
// In this case we need to close all the opLists that rely on the current contents of
// 'rtp'. That is bc we're going to update the content of the proxy so they need to be
// split in case they use both the old and new content. (This is a bit of an overkill:
// they really only need to be split if they ever reference proxy's contents again but
// that is hard to predict/handle).
if (GrOpList* lastOpList = rtp->getLastOpList()) {
lastOpList->closeThoseWhoDependOnMe(*fContext->contextPriv().caps());
}
} else if (fActiveOpList) {
// This is a temporary fix for the partial-MDB world. In that world we're not
// reordering so ops that (in the single opList world) would've just glommed onto the
// end of the single opList but referred to a far earlier RT need to appear in their
// own opList.
fActiveOpList->makeClosed(*fContext->contextPriv().caps());
fActiveOpList = nullptr;
}
auto resourceProvider = fContext->contextPriv().resourceProvider();
sk_sp<GrRenderTargetOpList> opList(new GrRenderTargetOpList(
resourceProvider,
fContext->contextPriv().refOpMemoryPool(),
rtp,
fContext->contextPriv().getAuditTrail()));
SkASSERT(rtp->getLastOpList() == opList.get());
if (managedOpList) {
fDAG.add(opList);
if (!fDAG.sortingOpLists() || !fReduceOpListSplitting) {
fActiveOpList = opList.get();
}
}
SkDEBUGCODE(this->validate());
return opList;
}
sk_sp<GrTextureOpList> GrDrawingManager::newTextureOpList(GrTextureProxy* textureProxy) {
SkDEBUGCODE(this->validate());
SkASSERT(fContext);
if (fDAG.sortingOpLists() && fReduceOpListSplitting) {
// In this case we need to close all the opLists that rely on the current contents of
// 'texture'. That is bc we're going to update the content of the proxy so they need to
// be split in case they use both the old and new content. (This is a bit of an
// overkill: they really only need to be split if they ever reference proxy's contents
// again but that is hard to predict/handle).
if (GrOpList* lastOpList = textureProxy->getLastOpList()) {
lastOpList->closeThoseWhoDependOnMe(*fContext->contextPriv().caps());
}
} else if (fActiveOpList) {
// This is a temporary fix for the partial-MDB world. In that world we're not
// reordering so ops that (in the single opList world) would've just glommed onto the
// end of the single opList but referred to a far earlier RT need to appear in their
// own opList.
fActiveOpList->makeClosed(*fContext->contextPriv().caps());
fActiveOpList = nullptr;
}
sk_sp<GrTextureOpList> opList(new GrTextureOpList(fContext->contextPriv().resourceProvider(),
fContext->contextPriv().refOpMemoryPool(),
textureProxy,
fContext->contextPriv().getAuditTrail()));
SkASSERT(textureProxy->getLastOpList() == opList.get());
fDAG.add(opList);
if (!fDAG.sortingOpLists() || !fReduceOpListSplitting) {
fActiveOpList = opList.get();
}
SkDEBUGCODE(this->validate());
return opList;
}
GrTextContext* GrDrawingManager::getTextContext() {
if (!fTextContext) {
fTextContext = GrTextContext::Make(fOptionsForTextContext);
}
return fTextContext.get();
}
/*
* This method finds a path renderer that can draw the specified path on
* the provided target.
* Due to its expense, the software path renderer has split out so it can
* can be individually allowed/disallowed via the "allowSW" boolean.
*/
GrPathRenderer* GrDrawingManager::getPathRenderer(const GrPathRenderer::CanDrawPathArgs& args,
bool allowSW,
GrPathRendererChain::DrawType drawType,
GrPathRenderer::StencilSupport* stencilSupport) {
if (!fPathRendererChain) {
fPathRendererChain.reset(new GrPathRendererChain(fContext, fOptionsForPathRendererChain));
}
GrPathRenderer* pr = fPathRendererChain->getPathRenderer(args, drawType, stencilSupport);
if (!pr && allowSW) {
auto swPR = this->getSoftwarePathRenderer();
if (GrPathRenderer::CanDrawPath::kNo != swPR->canDrawPath(args)) {
pr = swPR;
}
}
return pr;
}
GrPathRenderer* GrDrawingManager::getSoftwarePathRenderer() {
if (!fSoftwarePathRenderer) {
fSoftwarePathRenderer.reset(
new GrSoftwarePathRenderer(fContext->contextPriv().proxyProvider(),
fOptionsForPathRendererChain.fAllowPathMaskCaching));
}
return fSoftwarePathRenderer.get();
}
GrCoverageCountingPathRenderer* GrDrawingManager::getCoverageCountingPathRenderer() {
if (!fPathRendererChain) {
fPathRendererChain.reset(new GrPathRendererChain(fContext, fOptionsForPathRendererChain));
}
return fPathRendererChain->getCoverageCountingPathRenderer();
}
void GrDrawingManager::flushIfNecessary() {
GrResourceCache* resourceCache = fContext->contextPriv().getResourceCache();
if (resourceCache && resourceCache->requestsFlush()) {
this->flush(nullptr, 0, nullptr);
resourceCache->purgeAsNeeded();
}
}
sk_sp<GrRenderTargetContext> GrDrawingManager::makeRenderTargetContext(
sk_sp<GrSurfaceProxy> sProxy,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps,
bool managedOpList) {
if (this->wasAbandoned() || !sProxy->asRenderTargetProxy()) {
return nullptr;
}
// SkSurface catches bad color space usage at creation. This check handles anything that slips
// by, including internal usage.
if (!SkSurface_Gpu::Valid(fContext->contextPriv().caps(), sProxy->config(), colorSpace.get())) {
SkDEBUGFAIL("Invalid config and colorspace combination");
return nullptr;
}
sk_sp<GrRenderTargetProxy> rtp(sk_ref_sp(sProxy->asRenderTargetProxy()));
return sk_sp<GrRenderTargetContext>(new GrRenderTargetContext(
fContext, this, std::move(rtp),
std::move(colorSpace),
surfaceProps,
fContext->contextPriv().getAuditTrail(),
fSingleOwner, managedOpList));
}
sk_sp<GrTextureContext> GrDrawingManager::makeTextureContext(sk_sp<GrSurfaceProxy> sProxy,
sk_sp<SkColorSpace> colorSpace) {
if (this->wasAbandoned() || !sProxy->asTextureProxy()) {
return nullptr;
}
// SkSurface catches bad color space usage at creation. This check handles anything that slips
// by, including internal usage.
if (!SkSurface_Gpu::Valid(fContext->contextPriv().caps(), sProxy->config(), colorSpace.get())) {
SkDEBUGFAIL("Invalid config and colorspace combination");
return nullptr;
}
// GrTextureRenderTargets should always be using a GrRenderTargetContext
SkASSERT(!sProxy->asRenderTargetProxy());
sk_sp<GrTextureProxy> textureProxy(sk_ref_sp(sProxy->asTextureProxy()));
return sk_sp<GrTextureContext>(new GrTextureContext(fContext, this, std::move(textureProxy),
std::move(colorSpace),
fContext->contextPriv().getAuditTrail(),
fSingleOwner));
}