Convert GrCrash->SkFAIL GrDebugCrash->SkDEBUGFAIL

src/gpu/gl/GrGLNoOpInterface.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 "GrGLNoOpInterface.h"
 #include "SkString.h"
 #include "SkThread.h"
@@ skipping 482 matching lines @@
         case GR_GL_MAX_VERTEX_ATTRIBS:
             *params = kDefaultMaxVertexAttribs;
             break;
         case GR_GL_MAX_VARYING_VECTORS:
             *params = kDefaultMaxVaryingVectors;
             break;
         case GR_GL_NUM_EXTENSIONS:
             *params = SK_ARRAY_COUNT(kExtensions);
             break;
         default:
-            GrCrash("Unexpected pname to GetIntegerv");
+            SkFAIL("Unexpected pname to GetIntegerv");
    }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
                                               GrGLsizei bufsize,
                                               GrGLsizei* length,
                                               char* infolog) {
     if (length) {
         *length = 0;
    }
     if (bufsize > 0) {
         *infolog = 0;
    }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
                                                         GrGLenum pname,
                                                         GrGLint* params) {
     switch (pname) {
         case GR_GL_LINK_STATUS:  // fallthru
         case GR_GL_COMPILE_STATUS:
             *params = GR_GL_TRUE;
             break;
         case GR_GL_INFO_LOG_LENGTH:
             *params = 0;
             break;
         // we don't expect any other pnames
         default:
-            GrCrash("Unexpected pname to GetProgramiv");
+            SkFAIL("Unexpected pname to GetProgramiv");
             break;
    }
 }
 
 namespace {
 template <typename T>
 void query_result(GrGLenum GLtarget, GrGLenum pname, T *params) {
     switch (pname) {
         case GR_GL_QUERY_RESULT_AVAILABLE:
             *params = GR_GL_TRUE;
             break;
         case GR_GL_QUERY_RESULT:
             *params = 0;
             break;
         default:
-            GrCrash("Unexpected pname passed to GetQueryObject.");
+            SkFAIL("Unexpected pname passed to GetQueryObject.");
             break;
    }
 }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
                                               GrGLenum pname,
                                               GrGLint *params) {
     switch (pname) {
         case GR_GL_CURRENT_QUERY:
             *params = 0;
             break;
         case GR_GL_QUERY_COUNTER_BITS:
             *params = 32;
             break;
         default:
-            GrCrash("Unexpected pname passed GetQueryiv.");
+            SkFAIL("Unexpected pname passed GetQueryiv.");
    }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
                                                       GrGLenum pname,
                                                       GrGLint64 *params) {
     query_result(id, pname, params);
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id,
@@ skipping 20 matching lines @@
             return combined_extensions_string();
         case GR_GL_VERSION:
             return (const GrGLubyte*)"4.0 Debug GL";
         case GR_GL_SHADING_LANGUAGE_VERSION:
             return (const GrGLubyte*)"4.20.8 Debug GLSL";
         case GR_GL_VENDOR:
             return (const GrGLubyte*)"Debug Vendor";
         case GR_GL_RENDERER:
             return (const GrGLubyte*)"The Debug (Non-)Renderer";
         default:
-            GrCrash("Unexpected name passed to GetString");
+            SkFAIL("Unexpected name passed to GetString");
             return NULL;
    }
 }
 
 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i) {
     switch (name) {
         case GR_GL_EXTENSIONS:
             if (static_cast<size_t>(i) <= SK_ARRAY_COUNT(kExtensions)) {
                 return (const GrGLubyte*) kExtensions[i];
             } else {
                 return NULL;
             }
         default:
-            GrCrash("Unexpected name passed to GetStringi");
+            SkFAIL("Unexpected name passed to GetStringi");
             return NULL;
     }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
                                                           GrGLint level,
                                                           GrGLenum pname,
                                                           GrGLint* params) {
     // we used to use this to query stuff about externally created textures,
     // now we just require clients to tell us everything about the texture.
-    GrCrash("Should never query texture parameters.");
+    SkFAIL("Should never query texture parameters.");
 }
 
 GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name) {
     static int gUniLocation = 0;
     return ++gUniLocation;
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker) {
 }
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length  , const char* marker) {
 }
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker() {
 }