Replace uses of GrAssert by SkASSERT.

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
@@ skipping 45 matching lines @@
         if (!preConcatMatrix.isIdentity()) {
             for (int i = 0; i < fColorStages.count(); ++i) {
                 fColorStages[i].localCoordChange(preConcatMatrix);
             }
             for (int i = 0; i < fCoverageStages.count(); ++i) {
                 fCoverageStages[i].localCoordChange(preConcatMatrix);
             }
         }
     }
 
-    virtual ~GrDrawState() { GrAssert(0 == fBlockEffectRemovalCnt); }
+    virtual ~GrDrawState() { SkASSERT(0 == fBlockEffectRemovalCnt); }
 
     /**
      * Resets to the default state. GrEffects will be removed from all stages.
      */
     void reset() { this->onReset(NULL); }
 
     void reset(const SkMatrix& initialViewMatrix) { this->onReset(&initialViewMatrix); }
 
     /**
      * Initializes the GrDrawState based on a GrPaint, view matrix and render target. Note that
@@ skipping 68 matching lines @@
     }
 
     bool validateVertexAttribs() const;
 
     /**
      * Helper to save/restore vertex attribs
      */
      class AutoVertexAttribRestore {
      public:
          AutoVertexAttribRestore(GrDrawState* drawState) {
-             GrAssert(NULL != drawState);
+             SkASSERT(NULL != drawState);
              fDrawState = drawState;
              fVAPtr = drawState->fCommon.fVAPtr;
              fVACount = drawState->fCommon.fVACount;
              fDrawState->setDefaultVertexAttribs();
          }
 
          ~AutoVertexAttribRestore(){
              fDrawState->fCommon.fVAPtr = fVAPtr;
              fDrawState->fCommon.fVACount = fVACount;
          }
@@ skipping 186 matching lines @@
     ///
     /// The input color to the first color-stage is either the constant color or interpolated
     /// per-vertex colors. The input to the first coverage stage is either a constant coverage
     /// (usually full-coverage) or interpolated per-vertex coverage.
     ///
     /// See the documentation of kCoverageDrawing_StateBit for information about disabling the
     /// the color / coverage distinction.
     ////
 
     const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
-        GrAssert(NULL != effect);
+        SkASSERT(NULL != effect);
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
         return effect;
     }
 
     const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
-        GrAssert(NULL != effect);
+        SkASSERT(NULL != effect);
         SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
         return effect;
     }
 
     /**
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
         GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
         this->addColorEffect(effect)->unref();
@@ skipping 28 matching lines @@
 
         AutoRestoreEffects(GrDrawState* ds) : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {
             this->set(ds);
         }
 
         ~AutoRestoreEffects() { this->set(NULL); }
 
         void set(GrDrawState* ds) {
             if (NULL != fDrawState) {
                 int n = fDrawState->fColorStages.count() - fColorEffectCnt;
-                GrAssert(n >= 0);
+                SkASSERT(n >= 0);
                 fDrawState->fColorStages.pop_back_n(n);
                 n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
-                GrAssert(n >= 0);
+                SkASSERT(n >= 0);
                 fDrawState->fCoverageStages.pop_back_n(n);
                 GR_DEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
             }
             fDrawState = ds;
             if (NULL != ds) {
                 fColorEffectCnt = ds->fColorStages.count();
                 fCoverageEffectCnt = ds->fCoverageStages.count();
                 GR_DEBUGCODE(++ds->fBlockEffectRemovalCnt;)
             }
         }
@@ skipping 244 matching lines @@
                 fDrawState->setRenderTarget(fSavedTarget);
                 fDrawState = NULL;
             }
             GrSafeSetNull(fSavedTarget);
         }
 
         void set(GrDrawState* ds, GrRenderTarget* newTarget) {
             this->restore();
 
             if (NULL != ds) {
-                GrAssert(NULL == fSavedTarget);
+                SkASSERT(NULL == fSavedTarget);
                 fSavedTarget = ds->getRenderTarget();
                 SkSafeRef(fSavedTarget);
                 ds->setRenderTarget(newTarget);
                 fDrawState = ds;
             }
         }
     private:
         GrDrawState* fDrawState;
         GrRenderTarget* fSavedTarget;
     };
@@ skipping 144 matching lines @@
         kBoth_DrawFace,
         kCCW_DrawFace,
         kCW_DrawFace,
     };
 
     /**
      * Controls whether clockwise, counterclockwise, or both faces are drawn.
      * @param face  the face(s) to draw.
      */
     void setDrawFace(DrawFace face) {
-        GrAssert(kInvalid_DrawFace != face);
+        SkASSERT(kInvalid_DrawFace != face);
         fCommon.fDrawFace = face;
     }
 
     /**
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
     DrawFace getDrawFace() const { return fCommon.fDrawFace; }
 
@@ skipping 16 matching lines @@
         for (int i = 0; i < fCoverageStages.count(); i++) {
             if (fCoverageStages[i] != s.fCoverageStages[i]) {
                 return false;
             }
         }
         return true;
     }
     bool operator !=(const GrDrawState& s) const { return !(*this == s); }
 
     GrDrawState& operator= (const GrDrawState& s) {
-        GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
         this->setRenderTarget(s.fRenderTarget.get());
         fCommon = s.fCommon;
         fColorStages = s.fColorStages;
         fCoverageStages = s.fCoverageStages;
         return *this;
     }
 
 private:
 
     void onReset(const SkMatrix* initialViewMatrix) {
-        GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
         fColorStages.reset();
         fCoverageStages.reset();
 
         fRenderTarget.reset(NULL);
 
         this->setDefaultVertexAttribs();
 
         fCommon.fColor = 0xffffffff;
         if (NULL == initialViewMatrix) {
             fCommon.fViewMatrix.reset();
@@ skipping 39 matching lines @@
                           fDstBlend == other.fDstBlend &&
                           fBlendConstant == other.fBlendConstant &&
                           fFlagBits == other.fFlagBits &&
                           fVACount == other.fVACount &&
                           !memcmp(fVAPtr, other.fVAPtr, fVACount * sizeof(GrVertexAttrib)) &&
                           fStencilSettings == other.fStencilSettings &&
                           fCoverage == other.fCoverage &&
                           fColorFilterMode == other.fColorFilterMode &&
                           fColorFilterColor == other.fColorFilterColor &&
                           fDrawFace == other.fDrawFace;
-            GrAssert(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
+            SkASSERT(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
                                             other.fFixedFunctionVertexAttribIndices,
                                             sizeof(fFixedFunctionVertexAttribIndices)));
             return result;
         }
         bool operator!= (const CommonState& other) const { return !(*this == other); }
     };
 
     /** GrDrawState uses GrEffectStages to hold stage state which holds a ref on GrEffectRef.
         DeferredState must directly reference GrEffects, however. */
     struct SavedEffectStage {
@@ skipping 30 matching lines @@
             for (int i = 0; i < fColorStageCnt; ++i) {
                 fStages[i].saveFrom(drawState.fColorStages[i]);
             }
             for (int i = 0; i < drawState.fCoverageStages.count(); ++i) {
                 fStages[i + fColorStageCnt].saveFrom(drawState.fCoverageStages[i]);
             }
             GR_DEBUGCODE(fInitialized = true;)
         }
 
         void restoreTo(GrDrawState* drawState) {
-            GrAssert(fInitialized);
+            SkASSERT(fInitialized);
             drawState->fCommon = fCommon;
             drawState->setRenderTarget(fRenderTarget);
             // reinflate color/cov stage arrays.
             drawState->fColorStages.reset();
             for (int i = 0; i < fColorStageCnt; ++i) {
                 SkNEW_APPEND_TO_TARRAY(&drawState->fColorStages, GrEffectStage, (fStages[i]));
             }
             int coverageStageCnt = fStages.count() - fColorStageCnt;
             drawState->fCoverageStages.reset();
             for (int i = 0; i < coverageStageCnt; ++i) {
@@ skipping 56 matching lines @@
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef GrRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif