Replace uses of GrAssert by SkASSERT.

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 24 matching lines @@
         TextureSampler()
             : fConfigComponentMask(0) {
             // we will memcpy the first 4 bytes from passed in swizzle. This ensures the string is
             // terminated.
             fSwizzle[4] = '\0';
         }
 
         TextureSampler(const TextureSampler& other) { *this = other; }
 
         TextureSampler& operator= (const TextureSampler& other) {
-            GrAssert(0 == fConfigComponentMask);
-            GrAssert(!fSamplerUniform.isValid());
+            SkASSERT(0 == fConfigComponentMask);
+            SkASSERT(!fSamplerUniform.isValid());
 
             fConfigComponentMask = other.fConfigComponentMask;
             fSamplerUniform = other.fSamplerUniform;
             return *this;
         }
 
         // bitfield of GrColorComponentFlags present in the texture's config.
         uint32_t configComponentMask() const { return fConfigComponentMask; }
 
         const char* swizzle() const { return fSwizzle; }
 
         bool isInitialized() const { return 0 != fConfigComponentMask; }
 
     private:
         // The idx param is used to ensure multiple samplers within a single effect have unique
         // uniform names. swizzle is a four char max string made up of chars 'r', 'g', 'b', and 'a'.
         void init(GrGLShaderBuilder* builder,
                   uint32_t configComponentMask,
                   const char* swizzle,
                   int idx) {
-            GrAssert(!this->isInitialized());
-            GrAssert(0 != configComponentMask);
-            GrAssert(!fSamplerUniform.isValid());
+            SkASSERT(!this->isInitialized());
+            SkASSERT(0 != configComponentMask);
+            SkASSERT(!fSamplerUniform.isValid());
 
-            GrAssert(NULL != builder);
+            SkASSERT(NULL != builder);
             SkString name;
             name.printf("Sampler%d", idx);
             fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                   kSampler2D_GrSLType,
                                                   name.c_str());
-            GrAssert(fSamplerUniform.isValid());
+            SkASSERT(fSamplerUniform.isValid());
 
             fConfigComponentMask = configComponentMask;
             memcpy(fSwizzle, swizzle, 4);
         }
 
         void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
-            GrAssert(NULL != access);
+            SkASSERT(NULL != access);
             this->init(builder,
                        GrPixelConfigComponentMask(access->getTexture()->config()),
                        access->getSwizzle(),
                        idx);
         }
 
         uint32_t                          fConfigComponentMask;
         char                              fSwizzle[5];
         GrGLUniformManager::UniformHandle fSamplerUniform;
 
@@ skipping 273 matching lines @@
         }
 
         int stageIndex() const {
             this->validate();
             return fCurrentIndex;
         }
 
         class AutoStageRestore : GrNoncopyable {
         public:
             AutoStageRestore(CodeStage* codeStage, const GrEffectStage* newStage) {
-                GrAssert(NULL != codeStage);
+                SkASSERT(NULL != codeStage);
                 fSavedIndex = codeStage->fCurrentIndex;
                 fSavedEffectStage = codeStage->fEffectStage;
 
                 if (NULL == newStage) {
                     codeStage->fCurrentIndex = -1;
                 } else {
                     codeStage->fCurrentIndex = codeStage->fNextIndex++;
                 }
                 codeStage->fEffectStage = newStage;
 
                 fCodeStage = codeStage;
             }
             ~AutoStageRestore() {
                 fCodeStage->fCurrentIndex = fSavedIndex;
                 fCodeStage->fEffectStage = fSavedEffectStage;
             }
         private:
             CodeStage*              fCodeStage;
             int                     fSavedIndex;
             const GrEffectStage*    fSavedEffectStage;
         };
     private:
-        void validate() const { GrAssert((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
+        void validate() const { SkASSERT((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
         int                     fNextIndex;
         int                     fCurrentIndex;
         const GrEffectStage*    fEffectStage;
     } fCodeStage;
 
     /**
      * Features that should only be enabled by GrGLShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
@@ skipping 47 matching lines @@
     bool                                fTopLeftFragPosRead;
 
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
 };
 
 #endif