Remove possiblity of NULL effect in GrEffectStage

include/gpu/GrEffectStage.h

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
 #ifndef GrEffectStage_DEFINED
 #define GrEffectStage_DEFINED
 
 #include "GrBackendEffectFactory.h"
 #include "GrEffect.h"
 #include "SkMatrix.h"
 #include "GrTypes.h"
 
 #include "SkShader.h"
 
 class GrEffectStage {
 public:
-    GrEffectStage() {
-        fCoordChangeMatrixSet = false;
-        fVertexAttribIndices[0] = -1;
-        fVertexAttribIndices[1] = -1;
-    }

[jvanverth1, 2013/07/15 13:20:02]

You may want to make the default constructor private so that it's not
inadvertently called.

[bsalomon, 2013/07/15 13:24:53]

Since we have other constructors, there is no automatically generated
constructor.

-
     explicit GrEffectStage(const GrEffectRef* effectRef, int attrIndex0 = -1, int attrIndex1 = -1)
-    : fEffectRef(SkSafeRef(effectRef)) {
+    : fEffectRef(SkRef(effectRef)) {
         fCoordChangeMatrixSet = false;
         fVertexAttribIndices[0] = attrIndex0;
         fVertexAttribIndices[1] = attrIndex1;
     }
 
     GrEffectStage(const GrEffectStage& other) {
         *this = other;
     }
 
+    class DeferredStage;
+    // This constructor balances DeferredStage::saveFrom().
+    explicit GrEffectStage(const DeferredStage& deferredStage) {
+        deferredStage.restoreTo(this);
+    }
+
     GrEffectStage& operator= (const GrEffectStage& other) {
         fCoordChangeMatrixSet = other.fCoordChangeMatrixSet;
         if (other.fCoordChangeMatrixSet) {
             fCoordChangeMatrix = other.fCoordChangeMatrix;
         }
-        fEffectRef.reset(SkSafeRef(other.fEffectRef.get()));
+        fEffectRef.reset(SkRef(other.fEffectRef.get()));
         memcpy(fVertexAttribIndices, other.fVertexAttribIndices, sizeof(fVertexAttribIndices));
         return *this;
     }
 
     bool operator== (const GrEffectStage& other) const {
-        // first handle cases where one or the other has no effect
-        if (NULL == fEffectRef.get()) {
-            return NULL == other.fEffectRef.get();
-        } else if (NULL == other.fEffectRef.get()) {
-            return false;
-        }
+        GrAssert(NULL != fEffectRef.get());
+        GrAssert(NULL != other.fEffectRef.get());
 
         if (!(*this->getEffect())->isEqual(*other.getEffect())) {
             return false;
         }
 
         if (fCoordChangeMatrixSet != other.fCoordChangeMatrixSet) {
             return false;
         }
 
         if (!fCoordChangeMatrixSet) {
@@ skipping 34 matching lines @@
      * localCoordChange calls since the effect was installed. It is used when then caller
      * wants to temporarily change the source geometry coord system, draw something, and then
      * restore the previous coord system (e.g. temporarily draw in device coords).
      */
     void saveCoordChange(SavedCoordChange* savedCoordChange) const {
         savedCoordChange->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
         if (fCoordChangeMatrixSet) {
             savedCoordChange->fCoordChangeMatrix = fCoordChangeMatrix;
         }
         GrAssert(NULL == savedCoordChange->fEffectRef.get());
-        GR_DEBUGCODE(GrSafeRef(fEffectRef.get());)
+        GR_DEBUGCODE(SkRef(fEffectRef.get());)
         GR_DEBUGCODE(savedCoordChange->fEffectRef.reset(fEffectRef.get());)
     }
 
     /**
      * This balances the saveCoordChange call.
      */
     void restoreCoordChange(const SavedCoordChange& savedCoordChange) {
         fCoordChangeMatrixSet = savedCoordChange.fCoordChangeMatrixSet;
         if (fCoordChangeMatrixSet) {
             fCoordChangeMatrix = savedCoordChange.fCoordChangeMatrix;
@@ skipping 13 matching lines @@
         }
 
         ~DeferredStage() {
             if (NULL != fEffect) {
                 fEffect->decDeferredRefCounts();
             }
         }
 
         void saveFrom(const GrEffectStage& stage) {
             GrAssert(!fInitialized);
-            if (NULL != stage.fEffectRef.get()) {
-                stage.fEffectRef->get()->incDeferredRefCounts();
-                fEffect = stage.fEffectRef->get();
-                fCoordChangeMatrixSet = stage.fCoordChangeMatrixSet;
-                if (fCoordChangeMatrixSet) {
-                    fCoordChangeMatrix = stage.fCoordChangeMatrix;
-                }
-                fVertexAttribIndices[0] = stage.fVertexAttribIndices[0];
-                fVertexAttribIndices[1] = stage.fVertexAttribIndices[1];
+            GrAssert(NULL != stage.fEffectRef.get());
+            stage.fEffectRef->get()->incDeferredRefCounts();
+            fEffect = stage.fEffectRef->get();
+            fCoordChangeMatrixSet = stage.fCoordChangeMatrixSet;
+            if (fCoordChangeMatrixSet) {
+                fCoordChangeMatrix = stage.fCoordChangeMatrix;
             }
+            fVertexAttribIndices[0] = stage.fVertexAttribIndices[0];
+            fVertexAttribIndices[1] = stage.fVertexAttribIndices[1];
             SkDEBUGCODE(fInitialized = true;)
         }
 
-        void restoreTo(GrEffectStage* stage) {
+        void restoreTo(GrEffectStage* stage) const {
             GrAssert(fInitialized);
-            if (NULL != fEffect) {
-                stage->fEffectRef.reset(GrEffect::CreateEffectRef(fEffect));
-                stage->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
-                if (fCoordChangeMatrixSet) {
-                    stage->fCoordChangeMatrix = fCoordChangeMatrix;
-                }
-                stage->fVertexAttribIndices[0] = fVertexAttribIndices[0];
-                stage->fVertexAttribIndices[1] = fVertexAttribIndices[1];
-            } else {
-                stage->fEffectRef.reset(NULL);
+            stage->fEffectRef.reset(GrEffect::CreateEffectRef(fEffect));
+            stage->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
+            if (fCoordChangeMatrixSet) {
+                stage->fCoordChangeMatrix = fCoordChangeMatrix;
             }
+            stage->fVertexAttribIndices[0] = fVertexAttribIndices[0];
+            stage->fVertexAttribIndices[1] = fVertexAttribIndices[1];
         }
 
         bool isEqual(const GrEffectStage& stage, bool ignoreCoordChange) const {
-            if (NULL == stage.fEffectRef.get()) {
-                return NULL == fEffect;
-            } else if (NULL == fEffect) {
+            if (fVertexAttribIndices[0] != stage.fVertexAttribIndices[0] ||
+                fVertexAttribIndices[1] != stage.fVertexAttribIndices[1]) {
                 return false;
             }
 
-            if (fVertexAttribIndices[0] != stage.fVertexAttribIndices[0]
-                || fVertexAttribIndices[1] != stage.fVertexAttribIndices[1]) {
-                return false;
-            }
-
             if (!(*stage.getEffect())->isEqual(*fEffect)) {
                 return false;
             }
 
             if (ignoreCoordChange) {
                 // ignore the coordinate change matrix since there are
                 // explicit uv coordinates
                 return true;
             }
 
@@ skipping 21 matching lines @@
      * installed in the stage.
      */
     const SkMatrix& getCoordChangeMatrix() const {
         if (fCoordChangeMatrixSet) {
             return fCoordChangeMatrix;
         } else {
             return SkMatrix::I();
         }
     }
 
-    void reset() { fEffectRef.reset(NULL); }
-
-    const GrEffectRef* setEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
-        fEffectRef.reset(SkSafeRef(effect));
-        fCoordChangeMatrixSet = false;
-
-        fVertexAttribIndices[0] = attr0;
-        fVertexAttribIndices[1] = attr1;
-
-        return effect;
-    }
-
     const GrEffectRef* getEffect() const { return fEffectRef.get(); }
 
     const int* getVertexAttribIndices() const { return fVertexAttribIndices; }
     int getVertexAttribIndexCount() const { return fEffectRef->get()->numVertexAttribs(); }
 
 private:
     bool                                fCoordChangeMatrixSet;
     SkMatrix                            fCoordChangeMatrix;
     SkAutoTUnref<const GrEffectRef>     fEffectRef;
     int                                 fVertexAttribIndices[2];
 };
 
 #endif