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

diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h
index 32f4b93..f20bad3 100644 (file)
--- 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 <typename T> friend class GrPendingIOResource;
+    template <typename, IOType> 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 (file)
--- 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<T*>(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 <typename T> class GrPendingIOResource : SkNoncopyable {
+template <typename T, GrIORef::IOType IO_TYPE> 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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<const GrVertexBuffer> fVertexBuffer;
-        GrPendingIOResource<const GrIndexBuffer> fIndexBuffer;
+        GrPendingIOResource<const GrVertexBuffer, GrIORef::kRead_IOType>    fVertexBuffer;
+        GrPendingIOResource<const GrIndexBuffer, GrIORef::kRead_IOType>     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<const GrPath>   fPath;
+        GrPendingIOResource<const GrPath, GrIORef::kRead_IOType>   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<const GrPath>   fPath;
+        GrPendingIOResource<const GrPath, GrIORef::kRead_IOType> 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<const GrPathRange>  fPathRange;
+        GrPendingIOResource<const GrPathRange, GrIORef::kRead_IOType> 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<GrRenderTarget> fRenderTarget;
+        GrPendingIOResource<GrRenderTarget, GrIORef::kWrite_IOType> 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<GrSurface> fDst;
-        GrPendingIOResource<GrSurface> fSrc;
+        GrPendingIOResource<GrSurface, GrIORef::kWrite_IOType> fDst;
+        GrPendingIOResource<GrSurface, GrIORef::kRead_IOType> fSrc;
     };
 
     struct Clip : public ::SkNoncopyable {

diff --git a/src/gpu/GrRODrawState.cpp b/src/gpu/GrRODrawState.cpp
index 4d35684..fb4db2d 100644 (file)
--- 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 (file)
--- 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;