GrClipData fClipData;
// state for our offscreen render-target
- // TODO: remove 'fCached' and automatically return to the cache
- bool fCached; // is fRenderTarget->asTexture() in the cache
GrRenderTarget* fRenderTarget;
bool fNeedClear;
bool fNeedPrepareRenderTarget;
// called from rt and tex cons
- void initFromRenderTarget(GrContext*, GrRenderTarget*);
+ void initFromRenderTarget(GrContext*, GrRenderTarget*, bool cached);
// used by createCompatibleDevice
SkGpuDevice(GrContext*, GrTexture* texture, bool needClear);
*/
class SK_API SkGrPixelRef : public SkROLockPixelsPixelRef {
public:
- SkGrPixelRef(GrSurface* surface);
+ /**
+ * Constructs a pixel ref around a GrSurface. If the caller has locked the GrSurface in the
+ * cache and would like the pixel ref to unlock it in its destructor then transferCacheLock
+ * should be set to true.
+ */
+ SkGrPixelRef(GrSurface* surface, bool transferCacheLock = false);
virtual ~SkGrPixelRef();
// override from SkPixelRef
private:
GrSurface* fSurface;
+ bool fUnlock; // if true the pixel ref owns a texture cache lock on fSurface
+
typedef SkROLockPixelsPixelRef INHERITED;
};
SkGpuDevice::SkGpuDevice(GrContext* context, GrTexture* texture)
: SkDevice(make_bitmap(context, texture->asRenderTarget())) {
- this->initFromRenderTarget(context, texture->asRenderTarget());
+ this->initFromRenderTarget(context, texture->asRenderTarget(), false);
}
SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget)
: SkDevice(make_bitmap(context, renderTarget)) {
- this->initFromRenderTarget(context, renderTarget);
+ this->initFromRenderTarget(context, renderTarget, false);
}
void SkGpuDevice::initFromRenderTarget(GrContext* context,
- GrRenderTarget* renderTarget) {
+ GrRenderTarget* renderTarget,
+ bool cached) {
fNeedPrepareRenderTarget = false;
fDrawProcs = NULL;
fContext = context;
fContext->ref();
- fCached = false;
fRenderTarget = NULL;
fNeedClear = false;
if (NULL == surface) {
surface = fRenderTarget;
}
- SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (surface));
+ SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (surface, cached));
this->setPixelRef(pr, 0)->unref();
}
fContext = context;
fContext->ref();
- fCached = false;
fRenderTarget = NULL;
fNeedClear = false;
// This call gives the context a chance to relinquish it
fContext->setRenderTarget(NULL);
- GrTexture* texture = fRenderTarget->asTexture();
- if (NULL != texture && fCached) {
- fContext->unlockTexture(texture);
- }
SkSafeUnref(fRenderTarget);
fContext->unref();
}
: SkDevice(make_bitmap(context, texture->asRenderTarget())) {
GrAssert(texture && texture->asRenderTarget());
- this->initFromRenderTarget(context, texture->asRenderTarget());
- fCached = true;
+ // This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture
+ // cache. We pass true for the third argument so that it will get unlocked.
+ this->initFromRenderTarget(context, texture->asRenderTarget(), true);
fNeedClear = needClear;
}
///////////////////////////////////////////////////////////////////////////////
-SkGrPixelRef::SkGrPixelRef(GrSurface* surface) {
+SkGrPixelRef::SkGrPixelRef(GrSurface* surface, bool transferCacheLock) {
// TODO: figure out if this is responsible for Chrome canvas errors
#if 0
// The GrTexture has a ref to the GrRenderTarget but not vice versa.
if (NULL == fSurface) {
fSurface = surface;
}
-
+ fUnlock = transferCacheLock;
GrSafeRef(surface);
}
SkGrPixelRef::~SkGrPixelRef() {
+ if (fUnlock) {
+ GrContext* context = fSurface->getContext();
+ GrTexture* texture= fSurface->asTexture();
+ if (NULL != context && NULL != texture) {
+ context->unlockTexture(texture);
+ }
+ }
GrSafeUnref(fSurface);
}