From 45725db1d82615d43408ec488549aec6218f80e4 Mon Sep 17 00:00:00 2001 From: bsalomon Date: Fri, 19 Sep 2014 11:48:02 -0700 Subject: [PATCH] Move IOType to GrGpuRef and rename that to GrIORef. Template GrPendingIORef on IOType. BUG=skia:2889 R=robertphillips@google.com Author: bsalomon@google.com Review URL: https://codereview.chromium.org/579403003 --- include/gpu/GrGpuResource.h | 20 +++++++++++------ include/gpu/GrGpuResourceRef.h | 49 ++++++++++++++---------------------------- src/gpu/GrDrawState.h | 2 +- src/gpu/GrGpuResource.cpp | 2 +- src/gpu/GrGpuResourceRef.cpp | 37 ++++++++++--------------------- src/gpu/GrInOrderDrawBuffer.h | 32 +++++++++++++-------------- src/gpu/GrRODrawState.cpp | 2 +- src/gpu/GrTextureAccess.cpp | 8 +++---- 8 files changed, 62 insertions(+), 90 deletions(-) diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h index 32f4b93..f20bad3 100644 --- a/include/gpu/GrGpuResource.h +++ b/include/gpu/GrGpuResource.h @@ -33,11 +33,17 @@ class GrContext; * * The latter two ref types are private and intended only for Gr core code. */ -class GrGpuRef : public SkNoncopyable { +class GrIORef : public SkNoncopyable { public: - SK_DECLARE_INST_COUNT_ROOT(GrGpuRef) + SK_DECLARE_INST_COUNT_ROOT(GrIORef) - virtual ~GrGpuRef(); + enum IOType { + kRead_IOType, + kWrite_IOType, + kRW_IOType + }; + + virtual ~GrIORef(); // Some of the signatures are written to mirror SkRefCnt so that GrGpuResource can work with // templated helper classes (e.g. SkAutoTUnref). However, we have different categories of @@ -75,7 +81,7 @@ public: } protected: - GrGpuRef() : fRefCnt(1), fPendingReads(0), fPendingWrites(0) {} + GrIORef() : fRefCnt(1), fPendingReads(0), fPendingWrites(0) {} private: void addPendingRead() const { @@ -111,13 +117,13 @@ private: // This class is used to manage conversion of refs to pending reads/writes. friend class GrGpuResourceRef; - template friend class GrPendingIOResource; + template friend class GrPendingIOResource; }; /** * Base class for objects that can be kept in the GrResourceCache. */ -class GrGpuResource : public GrGpuRef { +class GrGpuResource : public GrIORef { public: SK_DECLARE_INST_COUNT(GrGpuResource) @@ -242,7 +248,7 @@ private: GrResourceKey fScratchKey; - typedef GrGpuRef INHERITED; + typedef GrIORef INHERITED; }; #endif diff --git a/include/gpu/GrGpuResourceRef.h b/include/gpu/GrGpuResourceRef.h index d178908..6b3937b 100644 --- a/include/gpu/GrGpuResourceRef.h +++ b/include/gpu/GrGpuResourceRef.h @@ -8,10 +8,9 @@ #ifndef GrGpuResourceRef_DEFINED #define GrGpuResourceRef_DEFINED +#include "GrGpuResource.h" #include "SkRefCnt.h" -class GrGpuResource; - /** * This class is intended only for internal use in core Gr code. * @@ -37,14 +36,6 @@ class GrGpuResourceRef : SkNoncopyable { public: SK_DECLARE_INST_COUNT_ROOT(GrGpuResourceRef); - enum IOType { - kRead_IOType, - kWrite_IOType, - kRW_IOType, - - kNone_IOType, // For internal use only, don't specify to constructor or setResource(). - }; - ~GrGpuResourceRef(); GrGpuResource* getResource() const { return fResource; } @@ -61,11 +52,11 @@ protected: /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as pending on the resource when markPendingIO is called. */ - GrGpuResourceRef(GrGpuResource*, IOType); + GrGpuResourceRef(GrGpuResource*, GrIORef::IOType); /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as pending on the resource when markPendingIO is called. */ - void setResource(GrGpuResource*, IOType); + void setResource(GrGpuResource*, GrIORef::IOType); private: /** Called by owning GrProgramElement when the program element is first scheduled for @@ -90,7 +81,7 @@ private: GrGpuResource* fResource; mutable bool fOwnRef; mutable bool fPendingIO; - IOType fIOType; + GrIORef::IOType fIOType; typedef SkNoncopyable INHERITED; }; @@ -104,13 +95,13 @@ public: /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as pending on the resource when markPendingIO is called. */ - GrTGpuResourceRef(T* resource, IOType ioType) : INHERITED(resource, ioType) {} + GrTGpuResourceRef(T* resource, GrIORef::IOType ioType) : INHERITED(resource, ioType) {} T* get() const { return static_cast(this->getResource()); } /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as pending on the resource when markPendingIO is called. */ - void set(T* resource, IOType ioType) { this->setResource(resource, ioType); } + void set(T* resource, GrIORef::IOType ioType) { this->setResource(resource, ioType); } private: typedef GrGpuResourceRef INHERITED; @@ -120,22 +111,18 @@ private: * This is similar to GrTGpuResourceRef but can only be in the pending IO state. It never owns a * ref. */ -template class GrPendingIOResource : SkNoncopyable { +template class GrPendingIOResource : SkNoncopyable { public: - typedef GrGpuResourceRef::IOType IOType; - GrPendingIOResource(T* resource, IOType ioType) : fResource(resource), fIOType(ioType) { + GrPendingIOResource(T* resource) : fResource(resource) { if (NULL != fResource) { - switch (fIOType) { - case GrGpuResourceRef::kNone_IOType: - SkFAIL("GrPendingIOResource with neither reads nor writes?"); - break; - case GrGpuResourceRef::kRead_IOType: + switch (IO_TYPE) { + case GrIORef::kRead_IOType: fResource->addPendingRead(); break; - case GrGpuResourceRef::kWrite_IOType: + case GrIORef::kWrite_IOType: fResource->addPendingWrite(); break; - case GrGpuResourceRef::kRW_IOType: + case GrIORef::kRW_IOType: fResource->addPendingRead(); fResource->addPendingWrite(); break; @@ -145,17 +132,14 @@ public: ~GrPendingIOResource() { if (NULL != fResource) { - switch (fIOType) { - case GrGpuResourceRef::kNone_IOType: - SkFAIL("GrPendingIOResource with neither reads nor writes?"); - break; - case GrGpuResourceRef::kRead_IOType: + switch (IO_TYPE) { + case GrIORef::kRead_IOType: fResource->completedRead(); break; - case GrGpuResourceRef::kWrite_IOType: + case GrIORef::kWrite_IOType: fResource->completedWrite(); break; - case GrGpuResourceRef::kRW_IOType: + case GrIORef::kRW_IOType: fResource->completedRead(); fResource->completedWrite(); break; @@ -167,6 +151,5 @@ public: private: T* fResource; - IOType fIOType; }; #endif diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h index 4d72062..458fb95 100644 --- a/src/gpu/GrDrawState.h +++ b/src/gpu/GrDrawState.h @@ -405,7 +405,7 @@ public: * @param target The render target to set. */ void setRenderTarget(GrRenderTarget* target) { - fRenderTarget.set(SkSafeRef(target), GrGpuResourceRef::kWrite_IOType); + fRenderTarget.set(SkSafeRef(target), GrIORef::kWrite_IOType); this->invalidateOptState(); } diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp index a8d7bbf..bba934e 100644 --- a/src/gpu/GrGpuResource.cpp +++ b/src/gpu/GrGpuResource.cpp @@ -11,7 +11,7 @@ #include "GrResourceCache2.h" #include "GrGpu.h" -GrGpuRef::~GrGpuRef() { +GrIORef::~GrIORef() { SkASSERT(0 == fRefCnt); SkASSERT(0 == fPendingReads); SkASSERT(0 == fPendingWrites); diff --git a/src/gpu/GrGpuResourceRef.cpp b/src/gpu/GrGpuResourceRef.cpp index e2a702e..7c521df 100644 --- a/src/gpu/GrGpuResourceRef.cpp +++ b/src/gpu/GrGpuResourceRef.cpp @@ -6,16 +6,14 @@ */ #include "GrGpuResourceRef.h" -#include "GrGpuResource.h" GrGpuResourceRef::GrGpuResourceRef() { fResource = NULL; fOwnRef = false; fPendingIO = false; - fIOType = kNone_IOType; } -GrGpuResourceRef::GrGpuResourceRef(GrGpuResource* resource, IOType ioType) { +GrGpuResourceRef::GrGpuResourceRef(GrGpuResource* resource, GrIORef::IOType ioType) { fResource = NULL; fOwnRef = false; fPendingIO = false; @@ -29,16 +27,13 @@ GrGpuResourceRef::~GrGpuResourceRef() { } if (fPendingIO) { switch (fIOType) { - case kNone_IOType: - SkFAIL("Shouldn't get here if fIOType is kNone."); - break; - case kRead_IOType: + case GrIORef::kRead_IOType: fResource->completedRead(); break; - case kWrite_IOType: + case GrIORef::kWrite_IOType: fResource->completedWrite(); break; - case kRW_IOType: + case GrIORef::kRW_IOType: fResource->completedRead(); fResource->completedWrite(); break; @@ -53,20 +48,17 @@ void GrGpuResourceRef::reset() { fResource->unref(); fOwnRef = false; fResource = NULL; - fIOType = kNone_IOType; } } -void GrGpuResourceRef::setResource(GrGpuResource* resource, IOType ioType) { +void GrGpuResourceRef::setResource(GrGpuResource* resource, GrIORef::IOType ioType) { SkASSERT(!fPendingIO); SkASSERT(SkToBool(fResource) == fOwnRef); SkSafeUnref(fResource); if (NULL == resource) { fResource = NULL; fOwnRef = false; - fIOType = kNone_IOType; } else { - SkASSERT(kNone_IOType != ioType); fResource = resource; fOwnRef = true; fIOType = ioType; @@ -80,16 +72,13 @@ void GrGpuResourceRef::markPendingIO() const { SkASSERT(fResource); fPendingIO = true; switch (fIOType) { - case kNone_IOType: - SkFAIL("GrGpuResourceRef with neither reads nor writes?"); - break; - case kRead_IOType: + case GrIORef::kRead_IOType: fResource->addPendingRead(); break; - case kWrite_IOType: + case GrIORef::kWrite_IOType: fResource->addPendingWrite(); break; - case kRW_IOType: + case GrIORef::kRW_IOType: fResource->addPendingRead(); fResource->addPendingWrite(); break; @@ -102,16 +91,13 @@ void GrGpuResourceRef::pendingIOComplete() const { SkASSERT(fOwnRef); SkASSERT(fPendingIO); switch (fIOType) { - case kNone_IOType: - SkFAIL("GrGpuResourceRef with neither reads nor writes?"); - break; - case kRead_IOType: + case GrIORef::kRead_IOType: fResource->completedRead(); break; - case kWrite_IOType: + case GrIORef::kWrite_IOType: fResource->completedWrite(); break; - case kRW_IOType: + case GrIORef::kRW_IOType: fResource->completedRead(); fResource->completedWrite(); break; @@ -125,7 +111,6 @@ void GrGpuResourceRef::removeRef() const { // there is a pending execution. SkASSERT(fOwnRef); SkASSERT(fPendingIO); - SkASSERT(kNone_IOType != fIOType); SkASSERT(fResource); fResource->unref(); fOwnRef = false; diff --git a/src/gpu/GrInOrderDrawBuffer.h b/src/gpu/GrInOrderDrawBuffer.h index 532b83f..e6ed06e 100644 --- a/src/gpu/GrInOrderDrawBuffer.h +++ b/src/gpu/GrInOrderDrawBuffer.h @@ -102,30 +102,30 @@ private: public: Draw(const DrawInfo& info, const GrVertexBuffer* vb, const GrIndexBuffer* ib) : DrawInfo(info) - , fVertexBuffer(vb, GrGpuResourceRef::kRead_IOType) - , fIndexBuffer(ib, GrGpuResourceRef::kRead_IOType) {} + , fVertexBuffer(vb) + , fIndexBuffer(ib) {} const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); } const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); } private: - GrPendingIOResource fVertexBuffer; - GrPendingIOResource fIndexBuffer; + GrPendingIOResource fVertexBuffer; + GrPendingIOResource fIndexBuffer; }; struct StencilPath : public ::SkNoncopyable { - StencilPath(const GrPath* path) : fPath(path, GrGpuResourceRef::kRead_IOType) {} + StencilPath(const GrPath* path) : fPath(path) {} const GrPath* path() const { return fPath.get(); } SkPath::FillType fFill; private: - GrPendingIOResource fPath; + GrPendingIOResource fPath; }; struct DrawPath : public ::SkNoncopyable { - DrawPath(const GrPath* path) : fPath(path, GrGpuResourceRef::kRead_IOType) {} + DrawPath(const GrPath* path) : fPath(path) {} const GrPath* path() const { return fPath.get(); } @@ -133,12 +133,12 @@ private: GrDeviceCoordTexture fDstCopy; private: - GrPendingIOResource fPath; + GrPendingIOResource fPath; }; struct DrawPaths : public ::SkNoncopyable { DrawPaths(const GrPathRange* pathRange) - : fPathRange(pathRange, GrGpuResourceRef::kRead_IOType) {} + : fPathRange(pathRange) {} ~DrawPaths() { if (fTransforms) { @@ -159,12 +159,12 @@ private: GrDeviceCoordTexture fDstCopy; private: - GrPendingIOResource fPathRange; + GrPendingIOResource fPathRange; }; // This is also used to record a discard by setting the color to GrColor_ILLEGAL struct Clear : public ::SkNoncopyable { - Clear(GrRenderTarget* rt) : fRenderTarget(rt, GrGpuResourceRef::kWrite_IOType) {} + Clear(GrRenderTarget* rt) : fRenderTarget(rt) {} ~Clear() { } GrRenderTarget* renderTarget() const { return fRenderTarget.get(); } @@ -173,13 +173,11 @@ private: bool fCanIgnoreRect; private: - GrPendingIOResource fRenderTarget; + GrPendingIOResource fRenderTarget; }; struct CopySurface : public ::SkNoncopyable { - CopySurface(GrSurface* dst, GrSurface* src) - : fDst(dst, GrGpuResourceRef::kWrite_IOType) - , fSrc(src, GrGpuResourceRef::kRead_IOType) {} + CopySurface(GrSurface* dst, GrSurface* src) : fDst(dst), fSrc(src) {} GrSurface* dst() const { return fDst.get(); } GrSurface* src() const { return fSrc.get(); } @@ -188,8 +186,8 @@ private: SkIRect fSrcRect; private: - GrPendingIOResource fDst; - GrPendingIOResource fSrc; + GrPendingIOResource fDst; + GrPendingIOResource fSrc; }; struct Clip : public ::SkNoncopyable { diff --git a/src/gpu/GrRODrawState.cpp b/src/gpu/GrRODrawState.cpp index 4d35684..fb4db2d 100644 --- a/src/gpu/GrRODrawState.cpp +++ b/src/gpu/GrRODrawState.cpp @@ -14,7 +14,7 @@ GrRODrawState::GrRODrawState(const GrRODrawState& drawState) : INHERITED() { fRenderTarget.setResource(SkSafeRef(drawState.fRenderTarget.getResource()), - GrGpuResourceRef::kWrite_IOType); + GrIORef::kWrite_IOType); } bool GrRODrawState::isEqual(const GrRODrawState& that) const { diff --git a/src/gpu/GrTextureAccess.cpp b/src/gpu/GrTextureAccess.cpp index 3e543ca..662ccd6 100644 --- a/src/gpu/GrTextureAccess.cpp +++ b/src/gpu/GrTextureAccess.cpp @@ -46,7 +46,7 @@ void GrTextureAccess::reset(GrTexture* texture, SkASSERT(strlen(swizzle) >= 1 && strlen(swizzle) <= 4); fParams = params; - fTexture.set(SkRef(texture), GrGpuResourceRef::kRead_IOType); + fTexture.set(SkRef(texture), GrIORef::kRead_IOType); this->setSwizzle(swizzle); } @@ -58,14 +58,14 @@ void GrTextureAccess::reset(GrTexture* texture, SkASSERT(strlen(swizzle) >= 1 && strlen(swizzle) <= 4); fParams.reset(tileXAndY, filterMode); - fTexture.set(SkRef(texture), GrGpuResourceRef::kRead_IOType); + fTexture.set(SkRef(texture), GrIORef::kRead_IOType); this->setSwizzle(swizzle); } void GrTextureAccess::reset(GrTexture* texture, const GrTextureParams& params) { SkASSERT(texture); - fTexture.set(SkRef(texture), GrGpuResourceRef::kRead_IOType); + fTexture.set(SkRef(texture), GrIORef::kRead_IOType); fParams = params; memcpy(fSwizzle, "rgba", 5); fSwizzleMask = kRGBA_GrColorComponentFlags; @@ -75,7 +75,7 @@ void GrTextureAccess::reset(GrTexture* texture, GrTextureParams::FilterMode filterMode, SkShader::TileMode tileXAndY) { SkASSERT(texture); - fTexture.set(SkRef(texture), GrGpuResourceRef::kRead_IOType); + fTexture.set(SkRef(texture), GrIORef::kRead_IOType); fParams.reset(tileXAndY, filterMode); memcpy(fSwizzle, "rgba", 5); fSwizzleMask = kRGBA_GrColorComponentFlags; -- 2.7.4