Convert GrCrash->SkFAIL GrDebugCrash->SkDEBUGFAIL

src/gpu/gl/GrGLShaderBuilder.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 "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLUniformHandle.h"
@@ skipping 169 matching lines @@
         case kStandardDerivatives_GLSLFeature:
             if (!fGpu->glCaps().shaderDerivativeSupport()) {
                 return false;
             }
             if (kGLES_GrGLStandard == fGpu->glStandard()) {
                 this->addFSFeature(1 << kStandardDerivatives_GLSLFeature,
                                    "GL_OES_standard_derivatives");
             }
             return true;
         default:
-            GrCrash("Unexpected GLSLFeature requested.");
+            SkFAIL("Unexpected GLSLFeature requested.");
             return false;
     }
 }
 
 bool GrGLShaderBuilder::enablePrivateFeature(GLSLPrivateFeature feature) {
     switch (feature) {
         case kFragCoordConventions_GLSLPrivateFeature:
             if (!fGpu->glCaps().fragCoordConventionsSupport()) {
                 return false;
             }
@@ skipping 10 matching lines @@
                                "GL_EXT_shader_framebuffer_fetch");
             return true;
         case kNVShaderFramebufferFetch_GLSLPrivateFeature:
             if (GrGLCaps::kNV_FBFetchType != fGpu->glCaps().fbFetchType()) {
                 return false;
             }
             this->addFSFeature(1 << kNVShaderFramebufferFetch_GLSLPrivateFeature,
                                "GL_NV_shader_framebuffer_fetch");
             return true;
         default:
-            GrCrash("Unexpected GLSLPrivateFeature requested.");
+            SkFAIL("Unexpected GLSLPrivateFeature requested.");
             return false;
     }
 }
 
 void GrGLShaderBuilder::addFSFeature(uint32_t featureBit, const char* extensionName) {
     if (!(featureBit & fFSFeaturesAddedMask)) {
         fFSExtensions.appendf("#extension %s: require\n", extensionName);
         fFSFeaturesAddedMask |= featureBit;
     }
 }
@@ skipping 10 matching lines @@
             out->append("x");
         }
         out->appendf("_Stage%d", fCodeStage.stageIndex());
     }
 }
 
 const char* GrGLShaderBuilder::dstColor() {
     if (fCodeStage.inStageCode()) {
         const GrEffectRef& effect = *fCodeStage.effectStage()->getEffect();
         if (!effect->willReadDstColor()) {
-            GrDebugCrash("GrGLEffect asked for dst color but its generating GrEffect "
+            SkDEBUGFAIL("GrGLEffect asked for dst color but its generating GrEffect "
                          "did not request access.");
             return "";
         }
     }
     static const char kFBFetchColorName[] = "gl_LastFragData[0]";
     GrGLCaps::FBFetchType fetchType = fGpu->glCaps().fbFetchType();
     if (GrGLCaps::kEXT_FBFetchType == fetchType) {
         SkAssertResult(this->enablePrivateFeature(kEXTShaderFramebufferFetch_GLSLPrivateFeature));
         return kFBFetchColorName;
     } else if (GrGLCaps::kNV_FBFetchType == fetchType) {
@@ skipping 129 matching lines @@
     }
     this->fsCodeAppendf("\tvec2 %s = %s.xy / %s.z;",
                         coords2D.c_str(), coords[index].c_str(), coords[index].c_str());
     return coords2D;
 }
 
 const char* GrGLShaderBuilder::fragmentPosition() {
     if (fCodeStage.inStageCode()) {
         const GrEffectRef& effect = *fCodeStage.effectStage()->getEffect();
         if (!effect->willReadFragmentPosition()) {
-            GrDebugCrash("GrGLEffect asked for frag position but its generating GrEffect "
+            SkDEBUGFAIL("GrGLEffect asked for frag position but its generating GrEffect "
                          "did not request access.");
             return "";
         }
     }
     // We only declare "gl_FragCoord" when we're in the case where we want to use layout qualifiers
     // to reverse y. Otherwise it isn't necessary and whether the "in" qualifier appears in the
     // declaration varies in earlier GLSL specs. So it is simpler to omit it.
     if (fTopLeftFragPosRead) {
         fSetupFragPosition = true;
         return "gl_FragCoord";
@@ skipping 63 matching lines @@
             case GrGLShaderVar::kHigh_Precision:
                 str->append("precision highp float;\n");
                 break;
             case GrGLShaderVar::kMedium_Precision:
                 str->append("precision mediump float;\n");
                 break;
             case GrGLShaderVar::kLow_Precision:
                 str->append("precision lowp float;\n");
                 break;
             case GrGLShaderVar::kDefault_Precision:
-                GrCrash("Default precision now allowed.");
+                SkFAIL("Default precision now allowed.");
             default:
-                GrCrash("Unknown precision value.");
+                SkFAIL("Unknown precision value.");
         }
     }
 }
 }
 
 void GrGLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const {
     for (int i = 0; i < vars.count(); ++i) {
         vars[i].appendDecl(this->ctxInfo(), out);
         out->append(";\n");
     }
@@ skipping 491 matching lines @@
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }