Replace uses of GrAssert by SkASSERT.

src/gpu/gl/GrGLEffectMatrix.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLEffectMatrix.h"
 #include "GrDrawEffect.h"
 #include "GrTexture.h"
@@ skipping 83 matching lines @@
         suffixedVaryingName.append(suffix);
         varyingName = suffixedVaryingName.c_str();
     }
     const char* vsVaryingName;
     const char* fsVaryingName;
     builder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName);
 
     const GrGLShaderVar* coords;
     switch (fCoordsType) {
         case GrEffect::kLocal_CoordsType:
-            GrAssert(!(kPositionCoords_Flag & key));
+            SkASSERT(!(kPositionCoords_Flag & key));
             coords = &builder->localCoordsAttribute();
             break;
         case GrEffect::kPosition_CoordsType:
-            GrAssert((kPositionCoords_Flag & key) || !builder->hasExplicitLocalCoords());
+            SkASSERT((kPositionCoords_Flag & key) || !builder->hasExplicitLocalCoords());
             coords = &builder->positionAttribute();
             break;
         default:
             coords = NULL; // prevents warning
             GrCrash("Unexpected coords type.");
     }
     // varying = matrix * coords (logically)
     switch (fUniType) {
         case kVoid_GrSLType:
-            GrAssert(kVec2f_GrSLType == varyingType);
+            SkASSERT(kVec2f_GrSLType == varyingType);
             builder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coords->c_str());
             break;
         case kVec2f_GrSLType:
-            GrAssert(kVec2f_GrSLType == varyingType);
+            SkASSERT(kVec2f_GrSLType == varyingType);
             builder->vsCodeAppendf("\t%s = %s + %s;\n",
                                    vsVaryingName, uniName, coords->c_str());
             break;
         case kMat33f_GrSLType: {
-            GrAssert(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
+            SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
             if (kVec2f_GrSLType == varyingType) {
                 builder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n",
                                        vsVaryingName, uniName, coords->c_str());
             } else {
                 builder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n",
                                        vsVaryingName, uniName, coords->c_str());
             }
             break;
         }
         default:
@@ skipping 44 matching lines @@
     }
     if (NULL != vsVaryingType) {
         *vsVaryingType = varyingType;
     }
 }
 
 void GrGLEffectMatrix::setData(const GrGLUniformManager& uniformManager,
                                const SkMatrix& matrix,
                                const GrDrawEffect& drawEffect,
                                const GrTexture* texture) {
-    GrAssert(fUni.isValid() != (kVoid_GrSLType == fUniType));
+    SkASSERT(fUni.isValid() != (kVoid_GrSLType == fUniType));
     const SkMatrix& coordChangeMatrix = GrEffect::kLocal_CoordsType == fCoordsType ?
                                             drawEffect.getCoordChangeMatrix() :
                                             SkMatrix::I();
     switch (fUniType) {
         case kVoid_GrSLType:
-            GrAssert(matrix.isIdentity());
-            GrAssert(coordChangeMatrix.isIdentity());
-            GrAssert(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
+            SkASSERT(matrix.isIdentity());
+            SkASSERT(coordChangeMatrix.isIdentity());
+            SkASSERT(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
             return;
         case kVec2f_GrSLType: {
-            GrAssert(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType()));
-            GrAssert(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
+            SkASSERT(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType()));
+            SkASSERT(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
             SkScalar tx = matrix[SkMatrix::kMTransX] + (coordChangeMatrix)[SkMatrix::kMTransX];
             SkScalar ty = matrix[SkMatrix::kMTransY] + (coordChangeMatrix)[SkMatrix::kMTransY];
             if (fPrevMatrix.get(SkMatrix::kMTransX) != tx ||
                 fPrevMatrix.get(SkMatrix::kMTransY) != ty) {
                 uniformManager.set2f(fUni, tx, ty);
                 fPrevMatrix.set(SkMatrix::kMTransX, tx);
                 fPrevMatrix.set(SkMatrix::kMTransY, ty);
             }
             break;
         }
@@ skipping 13 matching lines @@
             if (!fPrevMatrix.cheapEqualTo(combined)) {
                 uniformManager.setSkMatrix(fUni, combined);
                 fPrevMatrix = combined;
             }
             break;
         }
         default:
             GrCrash("Unexpected uniform type.");
     }
 }