Revert of Turned on SkSL->GLSL compiler (patchset #49 id:1240001 of https://codereview.chromium.org/2288033003/ )

Reason for revert:
Pre-emptive revert. Sorry, but we're getting back up on our roll and Chrome reverted our last one for apparently no reason.

Original issue's description:
> Turned on SkSL->GLSL compiler
> GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2288033003
>
> Committed: https://skia.googlesource.com/skia/+/9b0fe3d125f237d9884732a48414fa85fc71b4e3
> Committed: https://skia.googlesource.com/skia/+/b12b3c6908c62c908b3680be01e3b5bfd30de310
> Committed: https://skia.googlesource.com/skia/+/f008b0a59f45c0d4bea3e66faf3b01805009ec89
> Committed: https://skia.googlesource.com/skia/+/08b2ccf398e2b81bc05d2c105837e5419899469b
> Committed: https://skia.googlesource.com/skia/+/dcfe6dba4a335e50e86ff68e3252065d4197432c
> Committed: https://skia.googlesource.com/skia/+/ccb1dd8f267f9d7fe7c9d0ce222ebc81b41853b3

TBR=benjaminwagner@google.com,bsalomon@google.com,egdaniel@google.com,ethannicholas@google.com
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review-Url: https://codereview.chromium.org/2408193002

10 files changed, 84 insertions, 202 deletions

diff --git a/src/gpu/gl/GrGLContext.cpp b/src/gpu/gl/GrGLContext.cpp
index 2126314a7b..9e70b472c5 100644
--- a/src/gpu/gl/GrGLContext.cpp
+++ b/src/gpu/gl/GrGLContext.cpp
@@ -7,7 +7,6 @@
 
 #include "GrGLContext.h"
 #include "GrGLGLSL.h"
-#include "SkSLCompiler.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -64,17 +63,6 @@ GrGLContext* GrGLContext::Create(const GrGLInterface* interface, const GrContext
     return new GrGLContext(args);
 }
 
-GrGLContext::~GrGLContext() {
-    delete fCompiler;
-}
-
-SkSL::Compiler* GrGLContext::compiler() const {
-    if (!fCompiler) {
-        fCompiler = new SkSL::Compiler();
-    }
-    return fCompiler;
-}
-
 GrGLContextInfo::GrGLContextInfo(const ConstructorArgs& args) {
     fInterface.reset(SkRef(args.fInterface));
     fGLVersion = args.fGLVersion;
diff --git a/src/gpu/gl/GrGLContext.h b/src/gpu/gl/GrGLContext.h
index 8207ac89b0..6016f6859a 100644
--- a/src/gpu/gl/GrGLContext.h
+++ b/src/gpu/gl/GrGLContext.h
@@ -15,9 +15,6 @@
 #include "GrGLUtil.h"
 
 struct GrContextOptions;
-namespace SkSL {
-    class Compiler;
-}
 
 /**
  * Encapsulates information about an OpenGL context including the OpenGL
@@ -42,8 +39,6 @@ public:
 
     const GrGLExtensions& extensions() const { return fInterface->fExtensions; }
 
-    virtual ~GrGLContextInfo() {}
-
 protected:
     struct ConstructorArgs {
         const GrGLInterface*                fInterface;
@@ -69,7 +64,7 @@ protected:
 };
 
 /**
- * Extension of GrGLContextInfo that also provides access to GrGLInterface and SkSL::Compiler.
+ * Extension of GrGLContextInfo that also provides access to GrGLInterface.
  */
 class GrGLContext : public GrGLContextInfo {
 public:
@@ -81,16 +76,8 @@ public:
 
     const GrGLInterface* interface() const { return fInterface; }
 
-    SkSL::Compiler* compiler() const;
-
-    ~GrGLContext() override;
-
 private:
-    GrGLContext(const ConstructorArgs& args) 
-    : INHERITED(args)
-    , fCompiler(nullptr) {}
-
-    mutable SkSL::Compiler* fCompiler;
+    GrGLContext(const ConstructorArgs& args) : INHERITED(args) {}
 
     typedef GrGLContextInfo INHERITED;
 };
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 8c0373ac28..5755702463 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -3790,11 +3790,20 @@ bool GrGLGpu::createCopyProgram(int progIdx) {
     fshaderTxt.append(";");
     uTexture.appendDecl(glslCaps, &fshaderTxt);
     fshaderTxt.append(";");
+    const char* fsOutName;
+    if (glslCaps->mustDeclareFragmentShaderOutput()) {
+        oFragColor.appendDecl(glslCaps, &fshaderTxt);
+        fshaderTxt.append(";");
+        fsOutName = oFragColor.c_str();
+    } else {
+        fsOutName = "gl_FragColor";
+    }
     fshaderTxt.appendf(
         "// Copy Program FS\n"
         "void main() {"
-        "  sk_FragColor = %s(u_texture, v_texCoord);"
+        "  %s = %s(u_texture, v_texCoord);"
         "}",
+        fsOutName,
         GrGLSLTexture2DFunctionName(kVec2f_GrSLType, kSamplerTypes[progIdx], this->glslGeneration())
     );
 
@@ -3927,6 +3936,14 @@ bool GrGLGpu::createMipmapProgram(int progIdx) {
     }
     uTexture.appendDecl(glslCaps, &fshaderTxt);
     fshaderTxt.append(";");
+    const char* fsOutName;
+    if (glslCaps->mustDeclareFragmentShaderOutput()) {
+        oFragColor.appendDecl(glslCaps, &fshaderTxt);
+        fshaderTxt.append(";");
+        fsOutName = oFragColor.c_str();
+    } else {
+        fsOutName = "gl_FragColor";
+    }
     const char* sampleFunction = GrGLSLTexture2DFunctionName(kVec2f_GrSLType,
                                                              kTexture2DSampler_GrSLType,
                                                              this->glslGeneration());
@@ -3937,19 +3954,19 @@ bool GrGLGpu::createMipmapProgram(int progIdx) {
 
     if (oddWidth && oddHeight) {
         fshaderTxt.appendf(
-            "  sk_FragColor = (%s(u_texture, v_texCoord0) + %s(u_texture, v_texCoord1) + "
-            "                  %s(u_texture, v_texCoord2) + %s(u_texture, v_texCoord3)) * 0.25;",
-            sampleFunction, sampleFunction, sampleFunction, sampleFunction
+            "  %s = (%s(u_texture, v_texCoord0) + %s(u_texture, v_texCoord1) + "
+            "        %s(u_texture, v_texCoord2) + %s(u_texture, v_texCoord3)) * 0.25;",
+            fsOutName, sampleFunction, sampleFunction, sampleFunction, sampleFunction
         );
     } else if (oddWidth || oddHeight) {
         fshaderTxt.appendf(
-            "  sk_FragColor = (%s(u_texture, v_texCoord0) + %s(u_texture, v_texCoord1)) * 0.5;",
-            sampleFunction, sampleFunction
+            "  %s = (%s(u_texture, v_texCoord0) + %s(u_texture, v_texCoord1)) * 0.5;",
+            fsOutName, sampleFunction, sampleFunction
         );
     } else {
         fshaderTxt.appendf(
-            "  sk_FragColor = %s(u_texture, v_texCoord0);",
-            sampleFunction
+            "  %s = %s(u_texture, v_texCoord0);",
+            fsOutName, sampleFunction
         );
     }
 
@@ -4036,11 +4053,20 @@ bool GrGLGpu::createWireRectProgram() {
                                                  &fshaderTxt);
     uColor.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
     fshaderTxt.append(";");
+    const char* fsOutName;
+    if (this->glCaps().glslCaps()->mustDeclareFragmentShaderOutput()) {
+        oFragColor.appendDecl(this->glCaps().glslCaps(), &fshaderTxt);
+        fshaderTxt.append(";");
+        fsOutName = oFragColor.c_str();
+    } else {
+        fsOutName = "gl_FragColor";
+    }
     fshaderTxt.appendf(
         "// Write Rect Program FS\n"
         "void main() {"
-        "  sk_FragColor = %s;"
+        "  %s = %s;"
         "}",
+        fsOutName,
         uColor.c_str()
     );
 
diff --git a/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp b/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
index b26ce894f0..d2e49a5cfb 100644
--- a/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
@@ -9,9 +9,6 @@
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "SkTraceEvent.h"
-#include "SkSLCompiler.h"
-#include "SkSLGLSLCodeGenerator.h"
-#include "ir/SkSLProgram.h"
 
 #define GL_CALL(X) GR_GL_CALL(gpu->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(gpu->glInterface(), R, X)
@@ -21,90 +18,6 @@ static const bool c_PrintShaders{false};
 
 static void print_shader_source(const char** strings, int* lengths, int count);
 
-SkSL::GLCaps GrGLSkSLCapsForContext(const GrGLContext& context) {
-    GrGLStandard standard = context.standard();
-    const GrGLCaps* caps = context.caps();
-    const GrGLSLCaps* glslCaps = caps->glslCaps();
-    SkSL::GLCaps result;
-    switch (standard) {
-        case kGL_GrGLStandard:
-            result.fStandard = SkSL::GLCaps::kGL_Standard;
-            break;
-        case kGLES_GrGLStandard:
-            result.fStandard = SkSL::GLCaps::kGLES_Standard;
-            break;
-        default:
-            SkASSERT(false);
-            result.fStandard = SkSL::GLCaps::kGL_Standard;
-    }
-
-    switch (glslCaps->generation()) {
-        case k110_GrGLSLGeneration:
-            if (kGLES_GrGLStandard == standard) {
-                // ES2's shader language is based on GLSL 1.20 but is version 1.00 of the ES 
-                // language
-                result.fVersion = 100;
-            } else {
-                SkASSERT(kGL_GrGLStandard == standard);
-                result.fVersion = 110;
-            }
-            break;
-        case k130_GrGLSLGeneration:
-            SkASSERT(kGL_GrGLStandard == standard);
-            result.fVersion = 130;
-            break;
-        case k140_GrGLSLGeneration:
-            SkASSERT(kGL_GrGLStandard == standard);
-            result.fVersion = 140;
-            break;
-        case k150_GrGLSLGeneration:
-            SkASSERT(kGL_GrGLStandard == standard);
-            result.fVersion = 150;
-            break;
-        case k330_GrGLSLGeneration:
-            if (kGLES_GrGLStandard == standard) {
-                result.fVersion = 300;
-            } else {
-                SkASSERT(kGL_GrGLStandard == standard);
-                result.fVersion = 330;
-            }
-            break;
-        case k400_GrGLSLGeneration:
-            SkASSERT(kGL_GrGLStandard == standard);
-            result.fVersion = 400;
-            break;
-        case k310es_GrGLSLGeneration:
-            SkASSERT(kGLES_GrGLStandard == standard);
-            result.fVersion = 310;
-            break;
-        case k320es_GrGLSLGeneration:
-            SkASSERT(kGLES_GrGLStandard == standard);
-            result.fVersion = 320;
-            break;
-    }
-    result.fIsCoreProfile = caps->isCoreProfile();
-    result.fUsesPrecisionModifiers = glslCaps->usesPrecisionModifiers();
-    result.fMustDeclareFragmentShaderOutput = glslCaps->mustDeclareFragmentShaderOutput();
-    result.fCanUseMinAndAbsTogether = glslCaps->canUseMinAndAbsTogether();
-    return result;
-}
-
-static void dump_string(std::string s) {
-    // on Android, SkDebugf only displays the first 1K characters of output, which results in
-    // incomplete shader source code. Print each line individually to avoid this problem.
-    size_t index = 0;
-    for (;;) {
-        size_t next = s.find("\n", index);
-        if (next == std::string::npos) {
-            SkDebugf("%s", s.substr(index).c_str());
-            break;
-        } else {
-            SkDebugf("%s", s.substr(index, next - index + 1).c_str());
-            index = next + 1;
-        }
-    }
-}
-
 GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx,
                                     GrGLuint programId,
                                     GrGLenum type,
@@ -120,40 +33,15 @@ GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx,
         return 0;
     }
 
-    std::string sksl;
 #ifdef SK_DEBUG
     SkString prettySource = GrGLSLPrettyPrint::PrettyPrintGLSL(strings, lengths, count, false);
-    sksl = std::string(prettySource.c_str());
+    const GrGLchar* sourceStr = prettySource.c_str();
+    GrGLint sourceLength = static_cast<GrGLint>(prettySource.size());
+    GR_GL_CALL(gli, ShaderSource(shaderId, 1, &sourceStr, &sourceLength));
 #else
-    for (int i = 0; i < count; i++) {
-        sksl.append(strings[i], lengths[i]);
-    }
-#endif
-
-    std::string glsl;
-    SkSL::Compiler& compiler = *glCtx.compiler();
-    SkSL::GLCaps caps = GrGLSkSLCapsForContext(glCtx);
-    SkASSERT(type == GR_GL_VERTEX_SHADER || type == GR_GL_FRAGMENT_SHADER);
-    SkDEBUGCODE(bool result = )compiler.toGLSL(type == GR_GL_VERTEX_SHADER 
-                                                                    ? SkSL::Program::kVertex_Kind
-                                                                    : SkSL::Program::kFragment_Kind,
-                                               std::string(sksl.c_str()),
-                                               caps,
-                                               &glsl);
-#ifdef SK_DEBUG
-    if (!result) {
-        SkDebugf("SKSL compilation error\n----------------------\n");
-        SkDebugf("SKSL:\n");
-        dump_string(sksl);
-        SkDebugf("\nErrors:\n%s\n", compiler.errorText().c_str());
-        SkDEBUGFAIL("SKSL compilation failed!\n");
-    }
+    GR_GL_CALL(gli, ShaderSource(shaderId, count, strings, lengths));
 #endif
 
-    const char* glslChars = glsl.c_str();
-    GrGLint glslLength = (GrGLint) glsl.length();
-    GR_GL_CALL(gli, ShaderSource(shaderId, 1, &glslChars, &glslLength));
-
     // If tracing is enabled in chrome then we pretty print
     bool traceShader;
     TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), &traceShader);
@@ -184,14 +72,10 @@ GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx,
                 // buffer param validation.
                 GrGLsizei length = GR_GL_INIT_ZERO;
                 GR_GL_CALL(gli, GetShaderInfoLog(shaderId, infoLen+1, &length, (char*)log.get()));
-                SkDebugf("GLSL compilation error\n----------------------\n");
-                SkDebugf("SKSL:\n");
-                dump_string(sksl);
-                SkDebugf("GLSL:\n");
-                dump_string(glsl);
-                SkDebugf("Errors:\n%s\n", (const char*) log.get());
+                print_shader_source(strings, lengths, count);
+                SkDebugf("\n%s", (const char*)log.get());
             }
-            SkDEBUGFAIL("GLSL compilation failed!");
+            SkDEBUGFAIL("Shader compilation failed!");
             GR_GL_CALL(gli, DeleteShader(shaderId));
             return 0;
         }
diff --git a/src/gpu/gl/builders/GrGLShaderStringBuilder.h b/src/gpu/gl/builders/GrGLShaderStringBuilder.h
index 4365751c3a..062e229cdf 100644
--- a/src/gpu/gl/builders/GrGLShaderStringBuilder.h
+++ b/src/gpu/gl/builders/GrGLShaderStringBuilder.h
@@ -11,11 +11,8 @@
 #include "GrAllocator.h"
 #include "GrGpu.h"
 #include "gl/GrGLContext.h"
-#include "SkSLGLSLCodeGenerator.h"
 #include "SkTypes.h"
 
-SkSL::GLCaps GrGLSkSLCapsForContext(const GrGLContext& context);
-
 GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx,
                                     GrGLuint programId,
                                     GrGLenum type,
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
index eb744a9915..d35730f633 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
@@ -291,10 +291,10 @@ void GrGLSLFragmentShaderBuilder::enableCustomOutput() {
     if (!fHasCustomColorOutput) {
         fHasCustomColorOutput = true;
         fCustomColorOutputIndex = fOutputs.count();
-        fOutputs.push_back().set(kVec4f_GrSLType,  
-                                 GrGLSLShaderVar::kOut_TypeModifier,   
-                                 DeclaredColorOutputName());   
-        fProgramBuilder->finalizeFragmentOutputColor(fOutputs.back()); 
+        fOutputs.push_back().set(kVec4f_GrSLType,
+                                 GrGLSLShaderVar::kOut_TypeModifier,
+                                 DeclaredColorOutputName());
+        fProgramBuilder->finalizeFragmentOutputColor(fOutputs.back());
     }
 }
 
@@ -318,7 +318,7 @@ void GrGLSLFragmentShaderBuilder::enableSecondaryOutput() {
 }
 
 const char* GrGLSLFragmentShaderBuilder::getPrimaryColorOutputName() const {
-    return fHasCustomColorOutput ? DeclaredColorOutputName() : "sk_FragColor";
+    return fHasCustomColorOutput ? DeclaredColorOutputName() : "gl_FragColor";
 }
 
 void GrGLSLFragmentBuilder::declAppendf(const char* fmt, ...) {
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
index 6a4a184829..ecb6d455dd 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
@@ -203,7 +203,7 @@ private:
     }
 #endif
 
-    static const char* DeclaredColorOutputName() { return "sk_FragColor"; }
+    static const char* DeclaredColorOutputName() { return "fsColorOut"; }
     static const char* DeclaredSecondaryColorOutputName() { return "fsSecondaryColorOut"; }
 
     GrSurfaceOrigin getSurfaceOrigin() const;
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.h b/src/gpu/glsl/GrGLSLShaderBuilder.h
index f59edb4553..a6ff96dd1b 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.h
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.h
@@ -72,27 +72,23 @@ public:
     void appendTexelFetch(SamplerHandle, const char* coordExpr);
 
     /**
-    * Adds a constant declaration to the top of the shader.
+    * Adds a #define directive to the top of the shader.
     */
-    void defineConstant(const char* type, const char* name, const char* value) {
-        this->definitions().appendf("const %s %s = %s;\n", type, name, value);
+    void define(const char* macro, const char* replacement) {
+        this->definitions().appendf("#define %s %s\n", macro, replacement);
     }
 
-    void defineConstant(const char* name, int value) {
-        this->definitions().appendf("const int %s = %i;\n", name, value);
+    void define(const char* macro, int replacement) {
+        this->definitions().appendf("#define %s %i\n", macro, replacement);
     }
 
-    void defineConstant(const char* name, float value) {
-        this->definitions().appendf("const float %s = %f;\n", name, value);
-    }
-
-    void defineConstantf(const char* type, const char* name, const char* fmt, ...) {
-       this->definitions().appendf("const %s %s = ", type, name);
+    void definef(const char* macro, const char* replacement, ...) {
+       this->definitions().appendf("#define %s ", macro);
        va_list args;
-       va_start(args, fmt);
-       this->definitions().appendVAList(fmt, args);
+       va_start(args, replacement);
+       this->definitions().appendVAList(replacement, args);
        va_end(args);
-       this->definitions().append(";\n");
+       this->definitions().append("\n");
     }
 
     /**
diff --git a/src/gpu/glsl/GrGLSLShaderVar.h b/src/gpu/glsl/GrGLSLShaderVar.h
index 35ac4bcb84..9d162ecaa4 100644
--- a/src/gpu/glsl/GrGLSLShaderVar.h
+++ b/src/gpu/glsl/GrGLSLShaderVar.h
@@ -213,20 +213,24 @@ public:
 
 private:
     static const char* TypeModifierString(const GrGLSLCaps* glslCaps, TypeModifier t) {
+        GrGLSLGeneration gen = glslCaps->generation();
         switch (t) {
             case kNone_TypeModifier:
                 return "";
-            case kAttribute_TypeModifier: // fall through
-            case kVaryingIn_TypeModifier: // fall through
             case kIn_TypeModifier:
                 return "in";
             case kInOut_TypeModifier:
                 return "inout";
-            case kVaryingOut_TypeModifier: // fall through
             case kOut_TypeModifier:
                 return "out";
             case kUniform_TypeModifier:
                 return "uniform";
+            case kAttribute_TypeModifier:
+                return k110_GrGLSLGeneration == gen ? "attribute" : "in";
+            case kVaryingIn_TypeModifier:
+                return k110_GrGLSLGeneration == gen ? "varying" : "in";
+            case kVaryingOut_TypeModifier:
+                return k110_GrGLSLGeneration == gen ? "varying" : "out";
             default:
                 SkFAIL("Unknown shader variable type modifier.");
                 return ""; // suppress warning
diff --git a/src/gpu/instanced/InstanceProcessor.cpp b/src/gpu/instanced/InstanceProcessor.cpp
index 82116c4522..480155b683 100644
--- a/src/gpu/instanced/InstanceProcessor.cpp
+++ b/src/gpu/instanced/InstanceProcessor.cpp
@@ -107,10 +107,10 @@ public:
 
     void initParams(const SamplerHandle paramsBuffer) {
         fParamsBuffer = paramsBuffer;
+        fVertexBuilder->definef("PARAMS_IDX_MASK", "0x%xu", kParamsIdx_InfoMask);
         fVertexBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
-        fVertexBuilder->codeAppendf("int paramsIdx = int(%s & 0x%x);",
-                                    this->attr(Attrib::kInstanceInfo),
-                                    kParamsIdx_InfoMask);
+        fVertexBuilder->codeAppendf("int paramsIdx = int(%s & PARAMS_IDX_MASK);",
+                                    this->attr(Attrib::kInstanceInfo));
     }
 
     const char* attr(Attrib attr) const { return fInstProc.getAttrib((int)attr).fName; }
@@ -224,10 +224,10 @@ void GLSLInstanceProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
         v->codeAppendf("mat2x3 shapeMatrix = mat2x3(%s, %s);",
                        inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
     } else {
-        v->defineConstantf("int", "PERSPECTIVE_FLAG", "0x%x", kPerspective_InfoFlag);
+        v->definef("PERSPECTIVE_FLAG", "0x%xu", kPerspective_InfoFlag);
         v->codeAppendf("mat3 shapeMatrix = mat3(%s, %s, vec3(0, 0, 1));",
                        inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
-        v->codeAppendf("if (0 != (%s & PERSPECTIVE_FLAG)) {",
+        v->codeAppendf("if (0u != (%s & PERSPECTIVE_FLAG)) {",
                        inputs.attr(Attrib::kInstanceInfo));
         v->codeAppend (    "shapeMatrix[2] = ");
         inputs.fetchNextParam(kVec3f_GrSLType);
@@ -237,7 +237,7 @@ void GLSLInstanceProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
 
     bool hasSingleShapeType = SkIsPow2(ip.batchInfo().fShapeTypes);
     if (!hasSingleShapeType) {
-        v->defineConstant("SHAPE_TYPE_BIT", kShapeType_InfoBit);
+        v->define("SHAPE_TYPE_BIT", kShapeType_InfoBit);
         v->codeAppendf("uint shapeType = %s >> SHAPE_TYPE_BIT;",
                        inputs.attr(Attrib::kInstanceInfo));
     }
@@ -285,8 +285,8 @@ void GLSLInstanceProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     if (ip.batchInfo().fInnerShapeTypes) {
         bool hasSingleInnerShapeType = SkIsPow2(ip.batchInfo().fInnerShapeTypes);
         if (!hasSingleInnerShapeType) {
-            v->defineConstantf("int", "INNER_SHAPE_TYPE_MASK", "0x%x", kInnerShapeType_InfoMask);
-            v->defineConstant("INNER_SHAPE_TYPE_BIT", kInnerShapeType_InfoBit);
+            v->definef("INNER_SHAPE_TYPE_MASK", "0x%xu", kInnerShapeType_InfoMask);
+            v->define("INNER_SHAPE_TYPE_BIT", kInnerShapeType_InfoBit);
             v->codeAppendf("uint innerShapeType = ((%s & INNER_SHAPE_TYPE_MASK) >> "
                                                   "INNER_SHAPE_TYPE_BIT);",
                            inputs.attr(Attrib::kInstanceInfo));
@@ -346,13 +346,13 @@ void GLSLInstanceProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     }
 
     if (usedShapeDefinitions & kOval_ShapeFlag) {
-        v->defineConstant("OVAL_SHAPE_TYPE", (int)ShapeType::kOval);
+        v->definef("OVAL_SHAPE_TYPE", "%du", (int)ShapeType::kOval);
     }
     if (usedShapeDefinitions & kSimpleRRect_ShapeFlag) {
-        v->defineConstant("SIMPLE_R_RECT_SHAPE_TYPE", (int)ShapeType::kSimpleRRect);
+        v->definef("SIMPLE_R_RECT_SHAPE_TYPE", "%du", (int)ShapeType::kSimpleRRect);
     }
     if (usedShapeDefinitions & kNinePatch_ShapeFlag) {
-        v->defineConstant("NINE_PATCH_SHAPE_TYPE", (int)ShapeType::kNinePatch);
+        v->definef("NINE_PATCH_SHAPE_TYPE", "%du", (int)ShapeType::kNinePatch);
     }
     SkASSERT(!(usedShapeDefinitions & (kRect_ShapeFlag | kComplexRRect_ShapeFlag)));
 
@@ -367,8 +367,8 @@ void GLSLInstanceProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
                        inputs.attr(Attrib::kLocalRect), inputs.attr(Attrib::kLocalRect));
     }
     if (ip.batchInfo().fHasLocalMatrix && ip.batchInfo().fHasParams) {
-        v->defineConstantf("int", "LOCAL_MATRIX_FLAG", "0x%x", kLocalMatrix_InfoFlag);
-        v->codeAppendf("if (0 != (%s & LOCAL_MATRIX_FLAG)) {",
+        v->definef("LOCAL_MATRIX_FLAG", "0x%xu", kLocalMatrix_InfoFlag);
+        v->codeAppendf("if (0u != (%s & LOCAL_MATRIX_FLAG)) {",
                        inputs.attr(Attrib::kInstanceInfo));
         if (!ip.batchInfo().fUsesLocalCoords) {
             inputs.skipParams(2);
@@ -1179,7 +1179,7 @@ void GLSLInstanceProcessor::BackendMultisample::onInit(GrGLSLVaryingHandler* var
             }
         }
         if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
-           v->defineConstantf("int", "SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
+           v->definef("SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
            varyingHandler->addFlatVarying("earlyAccept", &fEarlyAccept, kHigh_GrSLPrecision);
         }
     }
@@ -1360,10 +1360,10 @@ void GLSLInstanceProcessor::BackendMultisample::onSetupInnerSimpleRRect(GrGLSLVe
 void GLSLInstanceProcessor::BackendMultisample::onEmitCode(GrGLSLVertexBuilder*,
                                                            GrGLSLPPFragmentBuilder* f,
                                                            const char*, const char*) {
-    f->defineConstant("SAMPLE_COUNT", fEffectiveSampleCnt);
+    f->define("SAMPLE_COUNT", fEffectiveSampleCnt);
     if (this->isMixedSampled()) {
-        f->defineConstantf("int", "SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
-        f->defineConstantf("int", "SAMPLE_MASK_MSB", "0x%x", 1 << (fEffectiveSampleCnt - 1));
+        f->definef("SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
+        f->definef("SAMPLE_MASK_MSB", "0x%x", 1 << (fEffectiveSampleCnt - 1));
     }
 
     if (kRect_ShapeFlag != (fBatchInfo.fShapeTypes | fBatchInfo.fInnerShapeTypes)) {