GrSurfaceProxyPriv Class Reference

#include <GrSurfaceProxyPriv.h>

Public Member Functions
void	computeScratchKey (const GrCaps &caps, skgpu::ScratchKey *key) const
sk_sp< GrSurface >	createSurface (GrResourceProvider *resourceProvider) const
void	assign (sk_sp< GrSurface > surface)
bool	isExact () const
void	exactify ()
void	setLazyDimensions (SkISize dimensions)
bool	doLazyInstantiation (GrResourceProvider *)
void	setIsDDLTarget ()
void	setIsPromiseProxy ()

Friends
class	GrSurfaceProxy

Detailed Description

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

Definition at line 20 of file GrSurfaceProxyPriv.h.

Member Function Documentation

assign()

void GrSurfaceProxyPriv::assign ( sk_sp< GrSurface >  surface )

inline

Definition at line 33 of file GrSurfaceProxyPriv.h.

{ fProxy->assign(std::move(surface)); }

computeScratchKey()

void GrSurfaceProxyPriv::computeScratchKey ( const GrCaps &  caps, skgpu::ScratchKey *  key  ) const

inline

Definition at line 22 of file GrSurfaceProxyPriv.h.

                                                                           {
        return fProxy->computeScratchKey(caps, key);
    }

createSurface()

sk_sp< GrSurface > GrSurfaceProxyPriv::createSurface ( GrResourceProvider *  resourceProvider ) const

inline

Definition at line 28 of file GrSurfaceProxyPriv.h.

                                                                               {
        return fProxy->createSurface(resourceProvider);
    }

doLazyInstantiation()

bool GrSurfaceProxyPriv::doLazyInstantiation

(

GrResourceProvider *

resourceProvider

)

Definition at line 424 of file GrSurfaceProxy.cpp.

                                                                                 {
    SkASSERT(fProxy->isLazy());
 
    sk_sp<GrSurface> surface;
    if (const auto& uniqueKey = fProxy->getUniqueKey(); uniqueKey.isValid()) {
        // First try to reattach to a cached version if the proxy is uniquely keyed
        surface = resourceProvider->findByUniqueKey<GrSurface>(uniqueKey);
    }
 
    bool syncKey = true;
    bool releaseCallback = false;
    if (!surface) {
        auto result = fProxy->fLazyInstantiateCallback(resourceProvider, fProxy->callbackDesc());
        surface = std::move(result.fSurface);
        syncKey = result.fKeyMode == GrSurfaceProxy::LazyInstantiationKeyMode::kSynced;
        releaseCallback = surface && result.fReleaseCallback;
    }
    if (!surface) {
        fProxy->fDimensions.setEmpty();
        return false;
    }
 
    if (fProxy->isFullyLazy()) {
        // This was a fully lazy proxy. We need to fill in the width & height. For partially
        // lazy proxies we must preserve the original width & height since that indicates
        // the content area.
        fProxy->fDimensions = surface->dimensions();
    }
 
    SkASSERT(fProxy->width() <= surface->width());
    SkASSERT(fProxy->height() <= surface->height());
 
    if (GrTextureProxy* texProxy = fProxy->asTextureProxy()) {
        texProxy->setTargetKeySync(syncKey);
        if (syncKey) {
            const skgpu::UniqueKey& key = texProxy->getUniqueKey();
            if (key.isValid()) {
                if (!surface->asTexture()->getUniqueKey().isValid()) {
                    // If 'surface' is newly created, attach the unique key
                    resourceProvider->assignUniqueKeyToResource(key, surface.get());
                } else {
                    // otherwise we had better have reattached to a cached version
                    SkASSERT(surface->asTexture()->getUniqueKey() == key);
                }
            } else {
                SkASSERT(!surface->getUniqueKey().isValid());
            }
        }
    }
 
    this->assign(std::move(surface));
    if (releaseCallback) {
        fProxy->fLazyInstantiateCallback = nullptr;
    }
 
    return true;
}

exactify()

void GrSurfaceProxyPriv::exactify

(

)

Definition at line 406 of file GrSurfaceProxy.cpp.

                                  {
    SkASSERT(!fProxy->isFullyLazy());
    if (this->isExact()) {
        return;
    }
 
    // The kApprox case. Setting the proxy's width & height to the backing-store width & height
    // could have side-effects going forward, since we're obliterating the area of interest
    // information. This is only used by SkSpecialImage when it's determined that sampling will
    // not access beyond the safe known region (the current value of fProxy->fDimensions). If
    // the proxy is instantiated, update the proxy's dimensions to match. Otherwise update them
    // to the backing-store dimensions.
    SkASSERT(SkBackingFit::kApprox == fProxy->fFit);
    fProxy->fDimensions = fProxy->fTarget ? fProxy->fTarget->dimensions()
                                          : fProxy->backingStoreDimensions();
    fProxy->fFit = SkBackingFit::kExact;
}

isExact()

bool GrSurfaceProxyPriv::isExact ( ) const

inline

Definition at line 36 of file GrSurfaceProxyPriv.h.

{ return SkBackingFit::kExact == fProxy->fFit; }

setIsDDLTarget()

void GrSurfaceProxyPriv::setIsDDLTarget ( )

inline

Definition at line 45 of file GrSurfaceProxyPriv.h.

{ fProxy->fIsDDLTarget = true; }

setIsPromiseProxy()

void GrSurfaceProxyPriv::setIsPromiseProxy ( )

inline

Definition at line 47 of file GrSurfaceProxyPriv.h.

{ fProxy->fIsPromiseProxy = true; }

setLazyDimensions()

void GrSurfaceProxyPriv::setLazyDimensions ( SkISize  dimensions )

inline

Definition at line 41 of file GrSurfaceProxyPriv.h.

{ fProxy->setLazyDimensions(dimensions); }

Friends And Related Function Documentation

GrSurfaceProxy

friend class GrSurfaceProxy

friend

Definition at line 59 of file GrSurfaceProxyPriv.h.

---

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

• third_party/skia/src/gpu/ganesh/GrSurfaceProxyPriv.h
• third_party/skia/src/gpu/ganesh/GrSurfaceProxy.cpp