Convert GrCrash->SkFAIL GrDebugCrash->SkDEBUGFAIL

src/gpu/gl/GrGLProgramEffects.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramEffects.h"
 #include "GrDrawEffect.h"
 #include "gl/GrGLEffect.h"
@@ skipping 323 matching lines @@
                 transforms[t].fType = kMat33f_GrSLType;
                 uniName = "StageMatrix";
                 varyingType = kVec2f_GrSLType;
                 break;
             case kGeneral_MatrixType:
                 transforms[t].fType = kMat33f_GrSLType;
                 uniName = "StageMatrix";
                 varyingType = kVec3f_GrSLType;
                 break;
             default:
-                GrCrash("Unexpected key.");
+                SkFAIL("Unexpected key.");
         }
         SkString suffixedUniName;
         if (kVoid_GrSLType != transforms[t].fType) {
             if (0 != t) {
                 suffixedUniName.append(uniName);
                 suffixedUniName.appendf("_%i", t);
                 uniName = suffixedUniName.c_str();
             }
             transforms[t].fHandle = builder->addUniform(GrGLShaderBuilder::kVertex_Visibility,
                                                         transforms[t].fType,
@@ skipping 31 matching lines @@
                 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:
-                GrCrash("Unexpected uniform type.");
+                SkFAIL("Unexpected uniform type.");
         }
         SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords,
                                (SkString(fsVaryingName), varyingType));
     }
 }
 
 void GrGLVertexProgramEffects::setData(GrGpuGL* gpu,
                                        const GrGLUniformManager& uniformManager,
                                        const GrEffectStage* effectStages[]) {
     int numEffects = fGLEffects.count();
@@ skipping 32 matching lines @@
             }
             case kMat33f_GrSLType: {
                 const SkMatrix& matrix = get_transform_matrix(drawEffect, t);
                 if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) {
                     uniformManager.setSkMatrix(transforms[t].fHandle, matrix);
                     transforms[t].fCurrentValue = matrix;
                 }
                 break;
             }
             default:
-                GrCrash("Unexpected uniform type.");
+                SkFAIL("Unexpected uniform type.");
         }
     }
 }
 
 GrGLVertexProgramEffectsBuilder::GrGLVertexProgramEffectsBuilder(GrGLFullShaderBuilder* builder,
                                                                  int reserveCount)
     : fBuilder(builder)
     , fProgramEffects(SkNEW_ARGS(GrGLVertexProgramEffects,
                                  (reserveCount, fBuilder->hasExplicitLocalCoords()))) {
 }
@@ skipping 105 matching lines @@
                 break;
             }
             case kGeneral_MatrixType: {
                 const SkMatrix& transform = get_transform_matrix(drawEffect, t);
                 gpu->enablePathTexGen(texCoordIndex++,
                                       GrGpuGL::kSTR_PathTexGenComponents,
                                       transform);
                 break;
             }
             default:
-                GrCrash("Unexpected matrixs type.");
+                SkFAIL("Unexpected matrixs type.");
         }
     }
 }
 
 GrGLPathTexGenProgramEffectsBuilder::GrGLPathTexGenProgramEffectsBuilder(
         GrGLFragmentOnlyShaderBuilder* builder,
         int reserveCount)
     : fBuilder(builder)
     , fProgramEffects(SkNEW_ARGS(GrGLPathTexGenProgramEffects, (reserveCount))) {
 }
 
 void GrGLPathTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
                                                      GrGLProgramEffects::EffectKey key,
                                                      const char* outColor,
                                                      const char* inColor,
                                                      int stageIndex) {
     SkASSERT(NULL != fProgramEffects.get());
     fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex);
 }