Replace uses of GrAssert by SkASSERT.

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.
  */
 
 
 
@@ skipping 30 matching lines @@
         fCoordChangeMatrixSet = other.fCoordChangeMatrixSet;
         if (other.fCoordChangeMatrixSet) {
             fCoordChangeMatrix = other.fCoordChangeMatrix;
         }
         fEffectRef.reset(SkRef(other.fEffectRef.get()));
         memcpy(fVertexAttribIndices, other.fVertexAttribIndices, sizeof(fVertexAttribIndices));
         return *this;
     }
 
     bool operator== (const GrEffectStage& other) const {
-        GrAssert(NULL != fEffectRef.get());
-        GrAssert(NULL != other.fEffectRef.get());
+        SkASSERT(NULL != fEffectRef.get());
+        SkASSERT(NULL != other.fEffectRef.get());
 
         if (!(*this->getEffect())->isEqual(*other.getEffect())) {
             return false;
         }
 
         if (fCoordChangeMatrixSet != other.fCoordChangeMatrixSet) {
             return false;
         }
 
         if (!fCoordChangeMatrixSet) {
@@ skipping 33 matching lines @@
      * This gets the current coordinate system change. It is the accumulation of
      * 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());
+        SkASSERT(NULL == savedCoordChange->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;
         }
-        GrAssert(savedCoordChange.fEffectRef.get() == fEffectRef);
+        SkASSERT(savedCoordChange.fEffectRef.get() == fEffectRef);
         GR_DEBUGCODE(savedCoordChange.fEffectRef.reset(NULL);)
     }
 
     /**
      * Used when storing a deferred GrDrawState. The DeferredStage allows resources owned by its
      * GrEffect to be recycled through the cache.
      */
     class DeferredStage {
     public:
         DeferredStage() : fEffect(NULL) {
             SkDEBUGCODE(fInitialized = false;)
         }
 
         ~DeferredStage() {
             if (NULL != fEffect) {
                 fEffect->decDeferredRefCounts();
             }
         }
 
         void saveFrom(const GrEffectStage& stage) {
-            GrAssert(!fInitialized);
-            GrAssert(NULL != stage.fEffectRef.get());
+            SkASSERT(!fInitialized);
+            SkASSERT(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) const {
-            GrAssert(fInitialized);
+            SkASSERT(fInitialized);
             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 {
@@ skipping 49 matching lines @@
     int getVertexAttribIndexCount() const { return fEffectRef->get()->numVertexAttribs(); }
 
 private:
     bool                                fCoordChangeMatrixSet;
     SkMatrix                            fCoordChangeMatrix;
     SkAutoTUnref<const GrEffectRef>     fEffectRef;
     int                                 fVertexAttribIndices[2];
 };
 
 #endif