GrRecordingContextPriv Class Reference

#include <GrRecordingContextPriv.h>

Inheritance diagram for GrRecordingContextPriv:

Public Member Functions
GrRecordingContext *	context ()
const GrRecordingContext *	context () const
GrProxyProvider *	proxyProvider ()
const GrProxyProvider *	proxyProvider () const
GrDrawingManager *	drawingManager ()
SkArenaAlloc *	recordTimeAllocator ()
sktext::gpu::SubRunAllocator *	recordTimeSubRunAllocator ()
GrRecordingContext::Arenas	arenas ()
GrRecordingContext::OwnedArenas &&	detachArenas ()
void	recordProgramInfo (const GrProgramInfo *programInfo)
void	detachProgramData (skia_private::TArray< GrRecordingContext::ProgramData > *dst)
sktext::gpu::TextBlobRedrawCoordinator *	getTextBlobCache ()
GrThreadSafeCache *	threadSafeCache ()
void	moveRenderTasksToDDL (GrDeferredDisplayList *)
void	addOnFlushCallbackObject (GrOnFlushCallbackObject *)
GrAuditTrail *	auditTrail ()
void	printWarningMessage (const char *msg) const
GrRecordingContext::Stats *	stats ()
sktext::gpu::SDFTControl	getSDFTControl (bool useSDFTForSmallText) const
sk_sp< skgpu::ganesh::Device >	createDevice (GrColorType, sk_sp< GrSurfaceProxy >, sk_sp< SkColorSpace >, GrSurfaceOrigin, const SkSurfaceProps &, skgpu::ganesh::Device::InitContents)
sk_sp< skgpu::ganesh::Device >	createDevice (skgpu::Budgeted, const SkImageInfo &, SkBackingFit, int sampleCount, skgpu::Mipmapped, skgpu::Protected, GrSurfaceOrigin, const SkSurfaceProps &, skgpu::ganesh::Device::InitContents)
std::unique_ptr< skgpu::ganesh::SurfaceContext >	makeSC (GrSurfaceProxyView readView, const GrColorInfo &)
std::unique_ptr< skgpu::ganesh::SurfaceContext >	makeSC (const GrImageInfo &, const GrBackendFormat &, std::string_view label, SkBackingFit=SkBackingFit::kExact, GrSurfaceOrigin=kTopLeft_GrSurfaceOrigin, skgpu::Renderable=skgpu::Renderable::kNo, int renderTargetSampleCnt=1, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Protected=skgpu::Protected::kNo, skgpu::Budgeted=skgpu::Budgeted::kYes)
std::unique_ptr< skgpu::ganesh::SurfaceFillContext >	makeSFC (GrImageInfo, std::string_view label, SkBackingFit=SkBackingFit::kExact, int sampleCount=1, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Protected=skgpu::Protected::kNo, GrSurfaceOrigin=kTopLeft_GrSurfaceOrigin, skgpu::Budgeted=skgpu::Budgeted::kYes)
std::unique_ptr< skgpu::ganesh::SurfaceFillContext >	makeSFC (SkAlphaType, sk_sp< SkColorSpace >, SkISize dimensions, SkBackingFit, const GrBackendFormat &, int sampleCount, skgpu::Mipmapped, skgpu::Protected, skgpu::Swizzle readSwizzle, skgpu::Swizzle writeSwizzle, GrSurfaceOrigin, skgpu::Budgeted, std::string_view label)
std::unique_ptr< skgpu::ganesh::SurfaceFillContext >	makeSFCWithFallback (GrImageInfo, SkBackingFit, int sampleCount, skgpu::Mipmapped, skgpu::Protected, GrSurfaceOrigin=kTopLeft_GrSurfaceOrigin, skgpu::Budgeted=skgpu::Budgeted::kYes)
std::unique_ptr< skgpu::ganesh::SurfaceFillContext >	makeSFCFromBackendTexture (GrColorInfo, const GrBackendTexture &, int sampleCount, GrSurfaceOrigin, sk_sp< skgpu::RefCntedCallback > releaseHelper)
Public Member Functions inherited from GrImageContextPriv
GrImageContext *	context ()
const GrImageContext *	context () const
bool	abandoned ()
	SkDEBUGCODE (skgpu::SingleOwner *singleOwner() const { return this->context() ->singleOwner();}) protected
Public Member Functions inherited from GrBaseContextPriv
GrContext_Base *	context ()
const GrContext_Base *	context () const
uint32_t	contextID () const
bool	matches (GrContext_Base *candidate) const
const GrContextOptions &	options () const
const GrCaps *	caps () const
sk_sp< const GrCaps >	refCaps () const
GrImageContext *	asImageContext ()
GrRecordingContext *	asRecordingContext ()
GrDirectContext *	asDirectContext ()
GrContextOptions::ShaderErrorHandler *	getShaderErrorHandler () const

Static Public Member Functions
static sk_sp< GrRecordingContext >	MakeDDL (sk_sp< GrContextThreadSafeProxy >)
Static Public Member Functions inherited from GrImageContextPriv
static sk_sp< GrImageContext >	MakeForPromiseImage (sk_sp< GrContextThreadSafeProxy > tsp)

Protected Member Functions
	GrRecordingContextPriv (GrRecordingContext *rContext)
Protected Member Functions inherited from GrBaseContextPriv
	GrBaseContextPriv (GrContext_Base *context)

Friends
class	GrRecordingContext

Additional Inherited Members
Protected Attributes inherited from GrBaseContextPriv
GrContext_Base *	fContext

Detailed Description

Class that exposes methods on GrRecordingContext that are only intended for use internal to Skia. This class is purely a privileged window into GrRecordingContext. It should never have additional data members or virtual methods.

Definition at line 33 of file GrRecordingContextPriv.h.

Constructor & Destructor Documentation

GrRecordingContextPriv()

GrRecordingContextPriv::GrRecordingContextPriv ( GrRecordingContext *  rContext )

inlineexplicitprotected

Definition at line 216 of file GrRecordingContextPriv.h.

: GrImageContextPriv(rContext) {}

Member Function Documentation

addOnFlushCallbackObject()

void GrRecordingContextPriv::addOnFlushCallbackObject

(

GrOnFlushCallbackObject *

onFlushCBObject

)

Registers an object for flush-related callbacks. (See GrOnFlushCallbackObject.)

NOTE: the drawing manager tracks this object as a raw pointer; it is up to the caller to ensure its lifetime is tied to that of the context.

Definition at line 20 of file GrRecordingContextPriv.cpp.

                                                                                              {
    this->context()->addOnFlushCallbackObject(onFlushCBObject);
}

arenas()

GrRecordingContext::Arenas GrRecordingContextPriv::arenas ( )

inline

Definition at line 49 of file GrRecordingContextPriv.h.

{ return this->context()->arenas(); }

auditTrail()

GrAuditTrail * GrRecordingContextPriv::auditTrail ( )

inline

Definition at line 77 of file GrRecordingContextPriv.h.

{ return this->context()->fAuditTrail.get(); }

context() [1/2]

GrRecordingContext * GrRecordingContextPriv::context ( )

inline

Definition at line 35 of file GrRecordingContextPriv.h.

{ return static_cast<GrRecordingContext*>(fContext); }

context() [2/2]

const GrRecordingContext * GrRecordingContextPriv::context ( ) const

inline

Definition at line 36 of file GrRecordingContextPriv.h.

                                              {
        return static_cast<const GrRecordingContext*>(fContext);
    }

createDevice() [1/2]

sk_sp< skgpu::ganesh::Device > GrRecordingContextPriv::createDevice	(	GrColorType	colorType,
		sk_sp< GrSurfaceProxy >	proxy,
		sk_sp< SkColorSpace >	colorSpace,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	props,
		skgpu::ganesh::Device::InitContents	init
	)

Definition at line 24 of file GrRecordingContextPriv.cpp.

                                            {
    return skgpu::ganesh::Device::Make(this->context(),
                                       colorType,
                                       std::move(proxy),
                                       std::move(colorSpace),
                                       origin,
                                       props,
                                       init);
}

createDevice() [2/2]

sk_sp< skgpu::ganesh::Device > GrRecordingContextPriv::createDevice	(	skgpu::Budgeted	budgeted,
		const SkImageInfo &	ii,
		SkBackingFit	fit,
		int	sampleCount,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	props,
		skgpu::ganesh::Device::InitContents	init
	)

Definition at line 40 of file GrRecordingContextPriv.cpp.

                                            {
    return skgpu::ganesh::Device::Make(this->context(),
                                       budgeted,
                                       ii,
                                       fit,
                                       sampleCount,
                                       mipmapped,
                                       isProtected,
                                       origin,
                                       props,
                                       init);
}

detachArenas()

GrRecordingContext::OwnedArenas && GrRecordingContextPriv::detachArenas ( )

inline

Definition at line 51 of file GrRecordingContextPriv.h.

{ return this->context()->detachArenas(); }

detachProgramData()

void GrRecordingContextPriv::detachProgramData ( skia_private::TArray< GrRecordingContext::ProgramData > *  dst )

inline

Definition at line 57 of file GrRecordingContextPriv.h.

                                                                                   {
        this->context()->detachProgramData(dst);
    }

drawingManager()

GrDrawingManager * GrRecordingContextPriv::drawingManager ( )

inline

Definition at line 43 of file GrRecordingContextPriv.h.

{ return this->context()->drawingManager(); }

getSDFTControl()

sktext::gpu::SDFTControl GrRecordingContextPriv::getSDFTControl

(

bool

useSDFTForSmallText

)

const

Definition at line 66 of file GrRecordingContextPriv.cpp.

                                                                                          {
#if !defined(SK_DISABLE_SDF_TEXT)
    return sktext::gpu::SDFTControl{
            this->caps()->shaderCaps()->supportsDistanceFieldText(),
            useSDFTForSmallText,
            !this->caps()->disablePerspectiveSDFText(),
            this->options().fMinDistanceFieldFontSize,
            this->options().fGlyphsAsPathsFontSize};
#else
    return sktext::gpu::SDFTControl{};
#endif
}

getTextBlobCache()

sktext::gpu::TextBlobRedrawCoordinator * GrRecordingContextPriv::getTextBlobCache ( )

inline

Definition at line 61 of file GrRecordingContextPriv.h.

                                                           {
        return this->context()->getTextBlobRedrawCoordinator();
    }

MakeDDL()

sk_sp< GrRecordingContext > GrRecordingContextPriv::MakeDDL ( sk_sp< GrContextThreadSafeProxy >  proxy )

static

Create a GrRecordingContext without a resource cache

Definition at line 114 of file GrDDLContext.cpp.

                                                                                               {
    sk_sp<GrRecordingContext> context(new GrDDLContext(std::move(proxy)));
 
    if (!context->init()) {
        return nullptr;
    }
    return context;
}

makeSC() [1/2]

std::unique_ptr< skgpu::ganesh::SurfaceContext > GrRecordingContextPriv::makeSC	(	const GrImageInfo &	info,
		const GrBackendFormat &	format,
		std::string_view	label,
		SkBackingFit	fit = SkBackingFit::kExact,
		GrSurfaceOrigin	origin = kTopLeft_GrSurfaceOrigin,
		skgpu::Renderable	renderable = skgpu::Renderable::kNo,
		int	renderTargetSampleCnt = 1,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		skgpu::Protected	isProtected = skgpu::Protected::kNo,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Definition at line 121 of file GrRecordingContextPriv.cpp.

                                {
    SkASSERT(renderable == GrRenderable::kYes || sampleCount == 1);
    if (this->abandoned()) {
        return nullptr;
    }
    sk_sp<GrTextureProxy> proxy =
            this->proxyProvider()->createProxy(format,
                                               info.dimensions(),
                                               renderable,
                                               sampleCount,
                                               mipmapped,
                                               fit,
                                               budgeted,
                                               isProtected,
                                               label);
    if (!proxy) {
        return nullptr;
    }
 
    skgpu::Swizzle swizzle;
    if (info.colorType() != GrColorType::kUnknown &&
        !this->caps()->isFormatCompressed(format)) {
        swizzle = this->caps()->getReadSwizzle(format, info.colorType());
    }
 
    GrSurfaceProxyView view(std::move(proxy), origin, swizzle);
    return this->makeSC(std::move(view), info.colorInfo());
}

makeSC() [2/2]

std::unique_ptr< skgpu::ganesh::SurfaceContext > GrRecordingContextPriv::makeSC	(	GrSurfaceProxyView	readView,
		const GrColorInfo &	info
	)

Definition at line 79 of file GrRecordingContextPriv.cpp.

                                                              {
    // It is probably not necessary to check if the context is abandoned here since uses of the
    // SurfaceContext which need the context will mostly likely fail later on w/o an issue.
    // However having this here adds some reassurance in case there is a path that doesn't
    // handle an abandoned context correctly. It also lets us early out of some extra work.
    if (this->context()->abandoned()) {
        return nullptr;
    }
    GrSurfaceProxy* proxy = readView.proxy();
    SkASSERT(proxy && proxy->asTextureProxy());
 
    std::unique_ptr<skgpu::ganesh::SurfaceContext> sc;
    if (proxy->asRenderTargetProxy()) {
        // Will we ever want a swizzle that is not the default write swizzle for the format and
        // colorType here? If so we will need to manually pass that in.
        skgpu::Swizzle writeSwizzle;
        if (info.colorType() != GrColorType::kUnknown) {
            writeSwizzle = this->caps()->getWriteSwizzle(proxy->backendFormat(),
                                                         info.colorType());
        }
        GrSurfaceProxyView writeView(readView.refProxy(), readView.origin(), writeSwizzle);
        if (info.alphaType() == kPremul_SkAlphaType ||
            info.alphaType() == kOpaque_SkAlphaType) {
            sc = std::make_unique<skgpu::ganesh::SurfaceDrawContext>(this->context(),
                                                                     std::move(readView),
                                                                     std::move(writeView),
                                                                     info.colorType(),
                                                                     info.refColorSpace(),
                                                                     SkSurfaceProps());
        } else {
            sc = std::make_unique<skgpu::ganesh::SurfaceFillContext>(
                    this->context(), std::move(readView), std::move(writeView), info);
        }
    } else {
        sc = std::make_unique<skgpu::ganesh::SurfaceContext>(
                this->context(), std::move(readView), info);
    }
    SkDEBUGCODE(sc->validate();)
    return sc;
}

makeSFC() [1/2]

std::unique_ptr< skgpu::ganesh::SurfaceFillContext > GrRecordingContextPriv::makeSFC	(	GrImageInfo	info,
		std::string_view	label,
		SkBackingFit	fit = SkBackingFit::kExact,
		int	sampleCount = 1,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		skgpu::Protected	isProtected = skgpu::Protected::kNo,
		GrSurfaceOrigin	origin = kTopLeft_GrSurfaceOrigin,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Uses GrImageInfo's color type to pick the default texture format. Will return a SurfaceDrawContext if possible.

Definition at line 160 of file GrRecordingContextPriv.cpp.

                                {
    if (info.alphaType() == kPremul_SkAlphaType || info.alphaType() == kOpaque_SkAlphaType) {
        return skgpu::ganesh::SurfaceDrawContext::Make(this->context(),
                                                       info.colorType(),
                                                       info.refColorSpace(),
                                                       fit,
                                                       info.dimensions(),
                                                       SkSurfaceProps(),
                                                       label,
                                                       sampleCount,
                                                       mipmapped,
                                                       isProtected,
                                                       origin,
                                                       budgeted);
    }
    GrBackendFormat format = this->caps()->getDefaultBackendFormat(info.colorType(),
                                                                   GrRenderable::kYes);
    sk_sp<GrTextureProxy> proxy =
            this->proxyProvider()->createProxy(format,
                                               info.dimensions(),
                                               GrRenderable::kYes,
                                               sampleCount,
                                               mipmapped,
                                               fit,
                                               budgeted,
                                               isProtected,
                                               label);
    if (!proxy) {
        return nullptr;
    }
    skgpu::Swizzle readSwizzle  = this->caps()->getReadSwizzle (format, info.colorType());
    skgpu::Swizzle writeSwizzle = this->caps()->getWriteSwizzle(format, info.colorType());
 
    GrSurfaceProxyView readView(            proxy, origin,  readSwizzle);
    GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
    std::unique_ptr<skgpu::ganesh::SurfaceFillContext> sfc;
    sfc = std::make_unique<skgpu::ganesh::SurfaceFillContext>(
            this->context(), std::move(readView), std::move(writeView), info.colorInfo());
    sfc->discard();
    return sfc;
}

makeSFC() [2/2]

std::unique_ptr< skgpu::ganesh::SurfaceFillContext > GrRecordingContextPriv::makeSFC	(	SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		SkISize	dimensions,
		SkBackingFit	fit,
		const GrBackendFormat &	format,
		int	sampleCount,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		skgpu::Swizzle	readSwizzle,
		skgpu::Swizzle	writeSwizzle,
		GrSurfaceOrigin	origin,
		skgpu::Budgeted	budgeted,
		std::string_view	label
	)

Makes a custom configured SurfaceFillContext where the caller specifies the specific texture format and swizzles. The color type will be kUnknown. Returns a SurfaceDrawContext if possible.

Definition at line 210 of file GrRecordingContextPriv.cpp.

                              {
    SkASSERT(!dimensions.isEmpty());
    SkASSERT(sampleCount >= 1);
    SkASSERT(format.isValid() && format.backend() == fContext->backend());
    if (alphaType == kPremul_SkAlphaType || alphaType == kOpaque_SkAlphaType) {
        return skgpu::ganesh::SurfaceDrawContext::Make(this->context(),
                                                       std::move(colorSpace),
                                                       fit,
                                                       dimensions,
                                                       format,
                                                       sampleCount,
                                                       mipmapped,
                                                       isProtected,
                                                       readSwizzle,
                                                       writeSwizzle,
                                                       origin,
                                                       budgeted,
                                                       SkSurfaceProps(),
                                                       label);
    }
 
    sk_sp<GrTextureProxy> proxy =
            this->proxyProvider()->createProxy(format,
                                               dimensions,
                                               GrRenderable::kYes,
                                               sampleCount,
                                               mipmapped,
                                               fit,
                                               budgeted,
                                               isProtected,
                                               label);
    if (!proxy) {
        return nullptr;
    }
    GrImageInfo info(GrColorType::kUnknown, alphaType, std::move(colorSpace), dimensions);
    GrSurfaceProxyView readView(            proxy, origin,  readSwizzle);
    GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
    std::unique_ptr<skgpu::ganesh::SurfaceFillContext> sfc;
    sfc = std::make_unique<skgpu::ganesh::SurfaceFillContext>(
            this->context(), std::move(readView), std::move(writeView), info.colorInfo());
    sfc->discard();
    return sfc;
}

makeSFCFromBackendTexture()

std::unique_ptr< skgpu::ganesh::SurfaceFillContext > GrRecordingContextPriv::makeSFCFromBackendTexture	(	GrColorInfo	info,
		const GrBackendTexture &	tex,
		int	sampleCount,
		GrSurfaceOrigin	origin,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper
	)

Creates a SurfaceFillContext from an existing GrBackendTexture. The GrColorInfo's color type must be compatible with backend texture's format or this will fail. All formats are considered compatible with kUnknown. Returns a SurfaceDrawContext if possible.

Definition at line 305 of file GrRecordingContextPriv.cpp.

                                                                                              {
    SkASSERT(sampleCount > 0);
 
    if (info.alphaType() == kPremul_SkAlphaType || info.alphaType() == kOpaque_SkAlphaType) {
        return skgpu::ganesh::SurfaceDrawContext::MakeFromBackendTexture(this->context(),
                                                                         info.colorType(),
                                                                         info.refColorSpace(),
                                                                         tex,
                                                                         sampleCount,
                                                                         origin,
                                                                         SkSurfaceProps(),
                                                                         std::move(releaseHelper));
    }
 
    if (info.colorType() == GrColorType::kUnknown) {
        return nullptr;
    }
 
    const GrBackendFormat& format = tex.getBackendFormat();
    if (!this->caps()->areColorTypeAndFormatCompatible(info.colorType(), format)) {
        return nullptr;
    }
    skgpu::Swizzle readSwizzle  = this->caps()->getReadSwizzle (format, info.colorType());
    skgpu::Swizzle writeSwizzle = this->caps()->getWriteSwizzle(format, info.colorType());
 
    sk_sp<GrTextureProxy> proxy(this->proxyProvider()->wrapRenderableBackendTexture(
            tex, sampleCount, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
            std::move(releaseHelper)));
    if (!proxy) {
        return nullptr;
    }
 
    GrSurfaceProxyView readView(            proxy, origin,  readSwizzle);
    GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
 
    return std::make_unique<skgpu::ganesh::SurfaceFillContext>(
            this->context(), std::move(readView), std::move(writeView), std::move(info));
}

makeSFCWithFallback()

std::unique_ptr< skgpu::ganesh::SurfaceFillContext > GrRecordingContextPriv::makeSFCWithFallback	(	GrImageInfo	info,
		SkBackingFit	fit,
		int	sampleCount,
		skgpu::Mipmapped	mipmapped,
		skgpu::Protected	isProtected,
		GrSurfaceOrigin	origin = kTopLeft_GrSurfaceOrigin,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Like the above but uses GetFallbackColorTypeAndFormat to find a fallback color type (and compatible format) if the passed GrImageInfo's color type is not renderable.

Definition at line 267 of file GrRecordingContextPriv.cpp.

                                {
    if (info.alphaType() == kPremul_SkAlphaType || info.alphaType() == kOpaque_SkAlphaType) {
        return skgpu::ganesh::SurfaceDrawContext::MakeWithFallback(this->context(),
                                                                   info.colorType(),
                                                                   info.refColorSpace(),
                                                                   fit,
                                                                   info.dimensions(),
                                                                   SkSurfaceProps(),
                                                                   sampleCount,
                                                                   mipmapped,
                                                                   isProtected,
                                                                   origin,
                                                                   budgeted);
    }
    const GrCaps* caps = this->caps();
 
    auto [ct, _] = caps->getFallbackColorTypeAndFormat(info.colorType(), sampleCount);
    if (ct == GrColorType::kUnknown) {
        return nullptr;
    }
    info = info.makeColorType(ct);
    return this->makeSFC(info, "MakeSurfaceContextWithFallback",
                         fit,
                         sampleCount,
                         mipmapped,
                         isProtected,
                         origin,
                         budgeted);
}

moveRenderTasksToDDL()

void GrRecordingContextPriv::moveRenderTasksToDDL

(

GrDeferredDisplayList *

ddl

)

Definition at line 62 of file GrRecordingContextPriv.cpp.

                                                                            {
    this->context()->drawingManager()->moveRenderTasksToDDL(ddl);
}

printWarningMessage()

void GrRecordingContextPriv::printWarningMessage ( const char *  msg ) const

inline

Definition at line 97 of file GrRecordingContextPriv.h.

                                                    {
#if defined(GR_TEST_UTILS)
        if (this->context()->fSuppressWarningMessages > 0) {
            return;
        }
#endif
        SkDebugf("%s", msg);
    }

proxyProvider() [1/2]

GrProxyProvider * GrRecordingContextPriv::proxyProvider ( )

inline

Definition at line 40 of file GrRecordingContextPriv.h.

{ return this->context()->proxyProvider(); }

proxyProvider() [2/2]

const GrProxyProvider * GrRecordingContextPriv::proxyProvider ( ) const

inline

Definition at line 41 of file GrRecordingContextPriv.h.

{ return this->context()->proxyProvider(); }

recordProgramInfo()

void GrRecordingContextPriv::recordProgramInfo ( const GrProgramInfo *  programInfo )

inline

Definition at line 53 of file GrRecordingContextPriv.h.

                                                             {
        this->context()->recordProgramInfo(programInfo);
    }

recordTimeAllocator()

SkArenaAlloc * GrRecordingContextPriv::recordTimeAllocator ( )

inline

Definition at line 45 of file GrRecordingContextPriv.h.

{ return this->context()->arenas().recordTimeAllocator(); }

recordTimeSubRunAllocator()

sktext::gpu::SubRunAllocator * GrRecordingContextPriv::recordTimeSubRunAllocator ( )

inline

Definition at line 46 of file GrRecordingContextPriv.h.

                                                          {
        return this->context()->arenas().recordTimeSubRunAllocator();
    }

stats()

GrRecordingContext::Stats * GrRecordingContextPriv::stats ( )

inline

Definition at line 106 of file GrRecordingContextPriv.h.

                                     {
        return &this->context()->fStats;
    }

threadSafeCache()

GrThreadSafeCache * GrRecordingContextPriv::threadSafeCache ( )

inline

Definition at line 65 of file GrRecordingContextPriv.h.

{ return this->context()->threadSafeCache(); }

Friends And Related Function Documentation

GrRecordingContext

friend class GrRecordingContext

friend

Definition at line 226 of file GrRecordingContextPriv.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/GrRecordingContextPriv.h
• third_party/skia/src/gpu/ganesh/GrDDLContext.cpp
• third_party/skia/src/gpu/ganesh/GrRecordingContextPriv.cpp