Replace uses of GrAssert by SkASSERT.

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 89 matching lines @@
             break;
         // The prog will write a coverage value to the secondary
         // output and the dst is blended by one minus that value.
         case GrGLProgramDesc::kSecondaryCoverage_CoverageOutput:
         case GrGLProgramDesc::kSecondaryCoverageISA_CoverageOutput:
         case GrGLProgramDesc::kSecondaryCoverageISC_CoverageOutput:
             *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             break;
         case GrGLProgramDesc::kCombineWithDst_CoverageOutput:
             // We should only have set this if the blend was specified as (1, 0)
-            GrAssert(kOne_GrBlendCoeff == *srcCoeff && kZero_GrBlendCoeff == *dstCoeff);
+            SkASSERT(kOne_GrBlendCoeff == *srcCoeff && kZero_GrBlendCoeff == *dstCoeff);
             break;
         default:
             GrCrash("Unexpected coverage output");
             break;
     }
 }
 
 namespace {
 // given two blend coefficients determine whether the src
 // and/or dst computation can be omitted.
@@ skipping 154 matching lines @@
         default:
             GrCrash("Unknown color type.");
             return kNone_GrSLConstantVec;
     }
 }
 
 void GrGLProgram::genGeometryShader(GrGLShaderBuilder* builder) const {
 #if GR_GL_EXPERIMENTAL_GS
     // TODO: The builder should add all this glue code.
     if (fDesc.getHeader().fExperimentalGS) {
-        GrAssert(fContext.info().glslGeneration() >= k150_GrGLSLGeneration);
+        SkASSERT(fContext.info().glslGeneration() >= k150_GrGLSLGeneration);
         builder->fGSHeader.append("layout(triangles) in;\n"
                                    "layout(triangle_strip, max_vertices = 6) out;\n");
         builder->gsCodeAppend("\tfor (int i = 0; i < 3; ++i) {\n"
                               "\t\tgl_Position = gl_in[i].gl_Position;\n");
         if (fDesc.getHeader().fEmitsPointSize) {
             builder->gsCodeAppend("\t\tgl_PointSize = 1.0;\n");
         }
-        GrAssert(builder->fGSInputs.count() == builder->fGSOutputs.count());
+        SkASSERT(builder->fGSInputs.count() == builder->fGSOutputs.count());
         int count = builder->fGSInputs.count();
         for (int i = 0; i < count; ++i) {
             builder->gsCodeAppendf("\t\t%s = %s[i];\n",
                                    builder->fGSOutputs[i].getName().c_str(),
                                    builder->fGSInputs[i].getName().c_str());
         }
         builder->gsCodeAppend("\t\tEmitVertex();\n"
                               "\t}\n"
                               "\tEndPrimitive();\n");
     }
@@ skipping 53 matching lines @@
         SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
         if (infoLen > 0) {
             // retrieve length even though we don't need it to workaround bug in chrome cmd buffer
             // param validation.
             GrGLsizei length = GR_GL_INIT_ZERO;
             GR_GL_CALL(gli, GetShaderInfoLog(shader, infoLen+1,
                                              &length, (char*)log.get()));
             print_shader(stringCnt, strings, stringLengths);
             GrPrintf("\n%s", log.get());
         }
-        GrAssert(!"Shader compilation failed!");
+        SkASSERT(!"Shader compilation failed!");
         GR_GL_CALL(gli, DeleteShader(shader));
         return 0;
     }
     return shader;
 }
 
 // helper version of above for when shader is already flattened into a single SkString
 GrGLuint compile_shader(const GrGLContext& gl, GrGLenum type, const SkString& shader) {
     const GrGLchar* str = shader.c_str();
     int length = shader.size();
     return compile_shader(gl, type, 1, &str, &length);
 }
 
 void expand_known_value4f(SkString* string, GrSLConstantVec vec) {
-    GrAssert(string->isEmpty() == (vec != kNone_GrSLConstantVec));
+    SkASSERT(string->isEmpty() == (vec != kNone_GrSLConstantVec));
     switch (vec) {
         case kNone_GrSLConstantVec:
             break;
         case kZeros_GrSLConstantVec:
             *string = GrGLSLZerosVecf(4);
             break;
         case kOnes_GrSLConstantVec:
             *string = GrGLSLOnesVecf(4);
             break;
     }
@@ skipping 37 matching lines @@
     }
     if (!(fFShaderID = compile_shader(fContext, GR_GL_FRAGMENT_SHADER, shader))) {
         return false;
     }
 
     return true;
 }
 
 bool GrGLProgram::genProgram(const GrEffectStage* colorStages[],
                              const GrEffectStage* coverageStages[]) {
-    GrAssert(0 == fProgramID);
+    SkASSERT(0 == fProgramID);
 
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
 
     GrGLShaderBuilder builder(fContext.info(), fUniformManager, fDesc);
 
     // the dual source output has no canonical var name, have to
     // declare an output, which is incompatible with gl_FragColor/gl_FragData.
     bool dualSourceOutputWritten = false;
 
     GrGLShaderVar colorOutput;
@@ skipping 284 matching lines @@
         if (infoLen > 0) {
             // retrieve length even though we don't need it to workaround
             // bug in chrome cmd buffer param validation.
             GrGLsizei length = GR_GL_INIT_ZERO;
             GL_CALL(GetProgramInfoLog(fProgramID,
                                       infoLen+1,
                                       &length,
                                       (char*)log.get()));
             GrPrintf((char*)log.get());
         }
-        GrAssert(!"Error linking program");
+        SkASSERT(!"Error linking program");
         GL_CALL(DeleteProgram(fProgramID));
         fProgramID = 0;
         return false;
     }
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
@@ skipping 29 matching lines @@
                                 const GrEffectStage& stage,
                                 const EffectAndSamplers& effect) {
 
     // Let the GrGLEffect set its data.
     bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
     GrDrawEffect drawEffect(stage, explicitLocalCoords);
     effect.fGLEffect->setData(fUniformManager, drawEffect);
 
     // Bind the texures for the effect.
     int numSamplers = effect.fSamplerUnis.count();
-    GrAssert((*stage.getEffect())->numTextures() == numSamplers);
+    SkASSERT((*stage.getEffect())->numTextures() == numSamplers);
     for (int s = 0; s < numSamplers; ++s) {
         UniformHandle handle = effect.fSamplerUnis[s];
         if (handle.isValid()) {
             const GrTextureAccess& access = (*stage.getEffect())->textureAccess(s);
             GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
             int unit = effect.fTextureUnits[s];
             gpu->bindTexture(unit, access.getParams(), texture);
         }
     }
 }
@@ skipping 37 matching lines @@
             fUniformManager.set2f(fUniformHandles.fDstCopyTopLeftUni,
                                   static_cast<GrGLfloat>(dstCopy->offset().fX),
                                   static_cast<GrGLfloat>(dstCopy->offset().fY));
             fUniformManager.set2f(fUniformHandles.fDstCopyScaleUni,
                                   1.f / dstCopy->texture()->width(),
                                   1.f / dstCopy->texture()->height());
             GrGLTexture* texture = static_cast<GrGLTexture*>(dstCopy->texture());
             static GrTextureParams kParams; // the default is clamp, nearest filtering.
             gpu->bindTexture(fDstCopyTexUnit, kParams, texture);
         } else {
-            GrAssert(!fUniformHandles.fDstCopyScaleUni.isValid());
-            GrAssert(!fUniformHandles.fDstCopySamplerUni.isValid());
+            SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
+            SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
-        GrAssert(!fUniformHandles.fDstCopyTopLeftUni.isValid());
-        GrAssert(!fUniformHandles.fDstCopyScaleUni.isValid());
-        GrAssert(!fUniformHandles.fDstCopySamplerUni.isValid());
+        SkASSERT(!fUniformHandles.fDstCopyTopLeftUni.isValid());
+        SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
+        SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
     }
 
     for (int e = 0; e < fColorEffects.count(); ++e) {
         // We may have omitted the GrGLEffect because of the color filter logic in genProgram.
         // This can be removed when the color filter is an effect.
         if (NULL != fColorEffects[e].fGLEffect) {
             this->setEffectData(gpu, *colorStages[e], fColorEffects[e]);
         }
     }
 
     for (int e = 0; e < fCoverageEffects.count(); ++e) {
         if (NULL != fCoverageEffects[e].fGLEffect) {
             this->setEffectData(gpu, *coverageStages[e], fCoverageEffects[e]);
         }
     }
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasColorVertexAttribute()) {
         switch (header.fColorInput) {
             case GrGLProgramDesc::kAttribute_ColorInput:
-                GrAssert(-1 != header.fColorAttributeIndex);
+                SkASSERT(-1 != header.fColorAttributeIndex);
                 if (sharedState->fConstAttribColor != color ||
                     sharedState->fConstAttribColorIndex != header.fColorAttributeIndex) {
                     // OpenGL ES only supports the float varieties of glVertexAttrib
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(color, c);
                     GL_CALL(VertexAttrib4fv(header.fColorAttributeIndex, c));
                     sharedState->fConstAttribColor = color;
                     sharedState->fConstAttribColorIndex = header.fColorAttributeIndex;
                 }
                 break;
@@ skipping 97 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }