Revert "Revert "Revert "Switched highp float to highfloat and mediump float to half."""

This reverts commit 05d5a13fea6246648de7e41358ed338d53c85ea2.

Reason for revert: looks like it broke filterfastbounds

Original change's description:
> Revert "Revert "Switched highp float to highfloat and mediump float to half.""
> 
> This reverts commit 1d816b92bb7cf2258007f3f74ffd143b89f25d01.
> 
> Bug: skia:
> Change-Id: I388b5e5e9bf619db48297a80c9a80c039f26c9f1
> Reviewed-on: https://skia-review.googlesource.com/46464
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Ethan Nicholas <ethannicholas@google.com>

TBR=bsalomon@google.com,ethannicholas@google.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: skia:
Change-Id: Iddf6aef2ab084aa73da7ceebdfc303a1d2b80cde
Reviewed-on: https://skia-review.googlesource.com/47441
Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>

15 files changed, 293 insertions, 253 deletions

diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.cpp b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
index 3611e16948..aebb7d35e8 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.cpp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
@@ -36,25 +36,24 @@ public:
         (void)_outer;
         fColorSpaceHelper.emitCode(args.fUniformHandler, _outer.colorXform().get());
         fInnerThresholdVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, kDefault_GrSLPrecision, "innerThreshold");
+                kFragment_GrShaderFlag, kFloat_GrSLType, kDefault_GrSLPrecision, "innerThreshold");
         fOuterThresholdVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, kDefault_GrSLPrecision, "outerThreshold");
+                kFragment_GrShaderFlag, kFloat_GrSLType, kDefault_GrSLPrecision, "outerThreshold");
         SkString sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
         SkString sk_TransformedCoords2D_1 = fragBuilder->ensureCoords2D(args.fTransformedCoords[1]);
         fragBuilder->codeAppendf(
-                "half4 _tmpVar1;half4 color = %stexture(%s, %s).%s%s;\nhalf4 mask_color = "
-                "texture(%s, %s).%s;\nif (highfloat(mask_color.w) < 0.5) {\n    if (color.w > %s) "
-                "{\n        half scale = %s / color.w;\n        color.xyz *= scale;\n        "
-                "color.w = %s;\n    }\n} else if (color.w < %s) {\n    half scale = highfloat(%s) "
-                "/ max(0.001, highfloat(color.w));\n    color.xyz *= scale;\n    color.w = "
-                "%s;\n}\n%s = color;\n",
+                "float4 _tmpVar1;float4 color = %stexture(%s, %s).%s%s;\nfloat4 mask_color = "
+                "texture(%s, %s).%s;\nif (mask_color.w < 0.5) {\n    if (color.w > %s) {\n        "
+                "float scale = %s / color.w;\n        color.xyz *= scale;\n        color.w = %s;\n "
+                "   }\n} else if (color.w < %s) {\n    float scale = %s / max(0.001, color.w);\n   "
+                " color.xyz *= scale;\n    color.w = %s;\n}\n%s = color;\n",
                 fColorSpaceHelper.isValid() ? "(_tmpVar1 = " : "",
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 sk_TransformedCoords2D_0.c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str(),
                 fColorSpaceHelper.isValid()
-                        ? SkStringPrintf(", half4(clamp((%s * half4(_tmpVar1.rgb, 1.0)).rgb, 0.0, "
-                                         "_tmpVar1.a), _tmpVar1.a))",
+                        ? SkStringPrintf(", float4(clamp((%s * float4(_tmpVar1.rgb, 1.0)).rgb, "
+                                         "0.0, _tmpVar1.a), _tmpVar1.a))",
                                          args.fUniformHandler->getUniformCStr(
                                                  fColorSpaceHelper.gamutXformUniform()))
                                   .c_str()
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.fp b/src/effects/GrAlphaThresholdFragmentProcessor.fp
index c3b3fbf5d5..481549e6b5 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.fp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.fp
@@ -1,8 +1,8 @@
 in uniform sampler2D image;
 in uniform colorSpaceXform colorXform;
 in uniform sampler2D mask;
-in uniform half innerThreshold;
-in uniform half outerThreshold;
+in uniform float innerThreshold;
+in uniform float outerThreshold;
 
 @class {
     inline OptimizationFlags optFlags(float outerThreshold);
@@ -49,16 +49,16 @@ in uniform half outerThreshold;
 }
 
 void main() {
-    half4 color = texture(image, sk_TransformedCoords2D[0], colorXform);
-    half4 mask_color = texture(mask, sk_TransformedCoords2D[1]);
+    float4 color = texture(image, sk_TransformedCoords2D[0], colorXform);
+    float4 mask_color = texture(mask, sk_TransformedCoords2D[1]);
     if (mask_color.a < 0.5) {
         if (color.a > outerThreshold) {
-            half scale = outerThreshold / color.a;
+            float scale = outerThreshold / color.a;
             color.rgb *= scale;
             color.a = outerThreshold;
         }
     } else if (color.a < innerThreshold) {
-        half scale = innerThreshold / max(0.001, color.a);
+        float scale = innerThreshold / max(0.001, color.a);
         color.rgb *= scale;
         color.a = innerThreshold;
     }
diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
index b3d28f490a..75d73bdbd0 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -263,20 +263,19 @@ public:
         const GrCircleBlurFragmentProcessor& _outer =
                 args.fFp.cast<GrCircleBlurFragmentProcessor>();
         (void)_outer;
-        fCircleDataVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+        fCircleDataVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
                                                           kDefault_GrSLPrecision, "circleData");
         fragBuilder->codeAppendf(
-                "half2 vec = half2(half((sk_FragCoord.x - highfloat(%s.x)) * highfloat(%s.w)), "
-                "half((sk_FragCoord.y - highfloat(%s.y)) * highfloat(%s.w)));\nhalf dist = "
-                "highfloat(length(vec)) + (0.5 - highfloat(%s.z)) * highfloat(%s.w);\n%s = %s * "
-                "texture(%s, highfloat2(half2(dist, 0.5))).%s.w;\n",
+                "float2 vec = float2((sk_FragCoord.x - %s.x) * %s.w, (sk_FragCoord.y - %s.y) * "
+                "%s.w);\nfloat dist = length(vec) + (0.5 - %s.z) * %s.w;\n%s = %s * texture(%s, "
+                "float2(dist, 0.5)).%s.w;\n",
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar), args.fOutputColor,
-                args.fInputColor ? args.fInputColor : "half4(1)",
+                args.fInputColor ? args.fInputColor : "float4(1)",
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str());
     }
diff --git a/src/effects/GrCircleBlurFragmentProcessor.fp b/src/effects/GrCircleBlurFragmentProcessor.fp
index d91bad8440..856a468b6c 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.fp
+++ b/src/effects/GrCircleBlurFragmentProcessor.fp
@@ -1,13 +1,13 @@
-in half4 circleRect;
-in half textureRadius;
-in half solidRadius;
+in float4 circleRect;
+in float textureRadius;
+in float solidRadius;
 in uniform sampler2D blurProfileSampler;
 
 // The data is formatted as:
 // x, y - the center of the circle
 // z    - inner radius that should map to 0th entry in the texture.
 // w    - the inverse of the distance over which the texture is stretched.
-uniform half4 circleData;
+uniform float4 circleData;
 
 @optimizationFlags {
     kCompatibleWithCoverageAsAlpha_OptimizationFlag
@@ -273,10 +273,10 @@ uniform half4 circleData;
 void main() {
     // We just want to compute "(length(vec) - circleData.z + 0.5) * circleData.w" but need to
     // rearrange for precision.
-    half2 vec = half2((sk_FragCoord.x - circleData.x) * circleData.w,
-                      (sk_FragCoord.y - circleData.y) * circleData.w);
-    half dist = length(vec) + (0.5 - circleData.z) * circleData.w;
-    sk_OutColor = sk_InColor * texture(blurProfileSampler, half2(dist, 0.5)).a;
+    float2 vec = float2((sk_FragCoord.x - circleData.x) * circleData.w,
+                    (sk_FragCoord.y - circleData.y) * circleData.w);
+    float dist = length(vec) + (0.5 - circleData.z) * circleData.w;
+    sk_OutColor = sk_InColor * texture(blurProfileSampler, float2(dist, 0.5)).a;
 }
 
 @test(testData) {
diff --git a/src/effects/SkArithmeticImageFilter.cpp b/src/effects/SkArithmeticImageFilter.cpp
index 1bc3d06f22..8c0f1ef4c9 100644
--- a/src/effects/SkArithmeticImageFilter.cpp
+++ b/src/effects/SkArithmeticImageFilter.cpp
@@ -302,18 +302,18 @@ private:
                 SkString dstColor("dstColor");
                 this->emitChild(0, &dstColor, args);
 
-                fKUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
-                                                         "k");
+                fKUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
+                                                         kDefault_GrSLPrecision, "k");
                 const char* kUni = args.fUniformHandler->getUniformCStr(fKUni);
 
                 // We don't try to optimize for this case at all
                 if (!args.fInputColor) {
-                    fragBuilder->codeAppend("const half4 src = half4(1);");
+                    fragBuilder->codeAppend("const float4 src = float4(1);");
                 } else {
-                    fragBuilder->codeAppendf("half4 src = %s;", args.fInputColor);
+                    fragBuilder->codeAppendf("float4 src = %s;", args.fInputColor);
                 }
 
-                fragBuilder->codeAppendf("half4 dst = %s;", dstColor.c_str());
+                fragBuilder->codeAppendf("float4 dst = %s;", dstColor.c_str());
                 fragBuilder->codeAppendf("%s = %s.x * src * dst + %s.y * src + %s.z * dst + %s.w;",
                                          args.fOutputColor, kUni, kUni, kUni, kUni);
                 fragBuilder->codeAppendf("%s = clamp(%s, 0.0, 1.0);\n", args.fOutputColor,
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 861a66d54b..2fc10ede40 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -862,12 +862,12 @@ void OutputRectBlurProfileLookup(GrGLSLFPFragmentBuilder* fragBuilder,
                                  const char *profileSize, const char *loc,
                                  const char *blurred_width,
                                  const char *sharp_width) {
-    fragBuilder->codeAppendf("half %s;", output);
+    fragBuilder->codeAppendf("float %s;", output);
     fragBuilder->codeAppendf("{");
-    fragBuilder->codeAppendf("half coord = ((abs(%s - 0.5 * %s) - 0.5 * %s)) / %s;",
+    fragBuilder->codeAppendf("float coord = ((abs(%s - 0.5 * %s) - 0.5 * %s)) / %s;",
                            loc, blurred_width, sharp_width, profileSize);
     fragBuilder->codeAppendf("%s = ", output);
-    fragBuilder->appendTextureLookup(sampler, "half2(coord,0.5)");
+    fragBuilder->appendTextureLookup(sampler, "float2(coord,0.5)");
     fragBuilder->codeAppend(".a;");
     fragBuilder->codeAppendf("}");
 }
@@ -889,41 +889,49 @@ void GrGLRectBlurEffect::emitCode(EmitArgs& args) {
     const char *rectName;
     const char *profileSizeName;
 
-    const char* floatType = rbe.precision() == kHigh_GrSLPrecision ? "highfloat" : "half";
+    SkString precisionString;
+    if (args.fShaderCaps->usesPrecisionModifiers()) {
+        precisionString.printf("%s ", GrGLSLPrecisionString(rbe.precision()));
+    }
     fProxyRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                   rbe.precision() == kHigh_GrSLPrecision ?
-                                                             kHighFloat4_GrSLType : kHalf4_GrSLType,
+                                                   kVec4f_GrSLType,
+                                                   rbe.precision(),
                                                    "proxyRect",
                                                    &rectName);
     fProfileSizeUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                     kHalf_GrSLType,
+                                                     kFloat_GrSLType,
+                                                     kDefault_GrSLPrecision,
                                                      "profileSize",
                                                      &profileSizeName);
 
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
 
     if (args.fInputColor) {
-        fragBuilder->codeAppendf("half4 src=%s;", args.fInputColor);
+        fragBuilder->codeAppendf("float4 src=%s;", args.fInputColor);
     } else {
-        fragBuilder->codeAppendf("half4 src=half4(1);");
+        fragBuilder->codeAppendf("float4 src=float4(1);");
     }
 
-    fragBuilder->codeAppendf("%s2 translatedPos = sk_FragCoord.xy - %s.xy;", floatType, rectName);
-    fragBuilder->codeAppendf("%s width = %s.z - %s.x;", floatType, rectName, rectName);
-    fragBuilder->codeAppendf("%s height = %s.w - %s.y;", floatType, rectName, rectName);
+    fragBuilder->codeAppendf("%s float2 translatedPos = sk_FragCoord.xy - %s.xy;",
+                             precisionString.c_str(), rectName);
+    fragBuilder->codeAppendf("%s float width = %s.z - %s.x;", precisionString.c_str(), rectName,
+                             rectName);
+    fragBuilder->codeAppendf("%s float height = %s.w - %s.y;", precisionString.c_str(), rectName,
+                             rectName);
 
-    fragBuilder->codeAppendf("%s2 smallDims = half2(width - %s, height - %s);", floatType,
-                             profileSizeName, profileSizeName);
-    fragBuilder->codeAppendf("%s center = 2.0 * floor(%s/2.0 + .25) - 1.0;", floatType,
-                             profileSizeName);
-    fragBuilder->codeAppendf("%s2 wh = smallDims - half2(center,center);", floatType);
+    fragBuilder->codeAppendf("%s float2 smallDims = float2(width - %s, height - %s);",
+                             precisionString.c_str(), profileSizeName, profileSizeName);
+    fragBuilder->codeAppendf("%s float center = 2.0 * floor(%s/2.0 + .25) - 1.0;",
+                             precisionString.c_str(), profileSizeName);
+    fragBuilder->codeAppendf("%s float2 wh = smallDims - float2(center,center);",
+                             precisionString.c_str());
 
     OutputRectBlurProfileLookup(fragBuilder, args.fTexSamplers[0], "horiz_lookup", profileSizeName,
                                 "translatedPos.x", "width", "wh.x");
     OutputRectBlurProfileLookup(fragBuilder, args.fTexSamplers[0], "vert_lookup", profileSizeName,
                                 "translatedPos.y", "height", "wh.y");
 
-    fragBuilder->codeAppendf("half final = horiz_lookup * vert_lookup;");
+    fragBuilder->codeAppendf("float final = horiz_lookup * vert_lookup;");
     fragBuilder->codeAppendf("%s = src * final;", args.fOutputColor);
 }
 
@@ -1269,15 +1277,18 @@ void GrGLRRectBlurEffect::emitCode(EmitArgs& args) {
     // components x, y, z, and w, respectively.
 
     fProxyRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                   kHalf4_GrSLType,
+                                                   kVec4f_GrSLType,
+                                                   kDefault_GrSLPrecision,
                                                    "proxyRect",
                                                    &rectName);
     fCornerRadiusUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                      kHalf_GrSLType,
+                                                      kFloat_GrSLType,
+                                                      kDefault_GrSLPrecision,
                                                       "cornerRadius",
                                                       &cornerRadiusName);
     fBlurRadiusUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                    kHalf_GrSLType,
+                                                    kFloat_GrSLType,
+                                                    kDefault_GrSLPrecision,
                                                     "blurRadius",
                                                     &blurRadiusName);
 
@@ -1285,10 +1296,10 @@ void GrGLRRectBlurEffect::emitCode(EmitArgs& args) {
 
     // warp the fragment position to the appropriate part of the 9patch blur texture
 
-    fragBuilder->codeAppendf("half2 rectCenter = (%s.xy + %s.zw)/2.0;", rectName, rectName);
-    fragBuilder->codeAppendf("half2 translatedFragPos = sk_FragCoord.xy - %s.xy;", rectName);
-    fragBuilder->codeAppendf("half threshold = %s + 2.0*%s;", cornerRadiusName, blurRadiusName);
-    fragBuilder->codeAppendf("half2 middle = %s.zw - %s.xy - 2.0*threshold;", rectName, rectName);
+    fragBuilder->codeAppendf("float2 rectCenter = (%s.xy + %s.zw)/2.0;", rectName, rectName);
+    fragBuilder->codeAppendf("float2 translatedFragPos = sk_FragCoord.xy - %s.xy;", rectName);
+    fragBuilder->codeAppendf("float threshold = %s + 2.0*%s;", cornerRadiusName, blurRadiusName);
+    fragBuilder->codeAppendf("float2 middle = %s.zw - %s.xy - 2.0*threshold;", rectName, rectName);
 
     fragBuilder->codeAppendf(
            "if (translatedFragPos.x >= threshold && translatedFragPos.x < (middle.x+threshold)) {");
@@ -1304,8 +1315,8 @@ void GrGLRRectBlurEffect::emitCode(EmitArgs& args) {
     fragBuilder->codeAppendf("translatedFragPos.y -= middle.y - 1.0;");
     fragBuilder->codeAppendf("}");
 
-    fragBuilder->codeAppendf("half2 proxyDims = half2(2.0*threshold+1.0);");
-    fragBuilder->codeAppendf("half2 texCoord = translatedFragPos / proxyDims;");
+    fragBuilder->codeAppendf("float2 proxyDims = float2(2.0*threshold+1.0);");
+    fragBuilder->codeAppendf("float2 texCoord = translatedFragPos / proxyDims;");
 
     fragBuilder->codeAppendf("%s = ", args.fOutputColor);
     fragBuilder->appendTextureLookupAndModulate(args.fInputColor, args.fTexSamplers[0], "texCoord");
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 0ba6a296cf..2c26cce69f 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -552,7 +552,8 @@ void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
     const GrDisplacementMapEffect& displacementMap = args.fFp.cast<GrDisplacementMapEffect>();
     const GrTextureDomain& domain = displacementMap.domain();
 
-    fScaleUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType, "Scale");
+    fScaleUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                 kVec2f_GrSLType, kDefault_GrSLPrecision, "Scale");
     const char* scaleUni = args.fUniformHandler->getUniformCStr(fScaleUni);
     const char* dColor = "dColor";
     const char* cCoords = "cCoords";
@@ -563,17 +564,17 @@ void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
     fColorSpaceHelper.emitCode(args.fUniformHandler, displacementMap.colorSpaceXform());
 
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-    fragBuilder->codeAppendf("\t\thalf4 %s = ", dColor);
+    fragBuilder->codeAppendf("\t\tfloat4 %s = ", dColor);
     fragBuilder->appendTextureLookup(args.fTexSamplers[0], args.fTransformedCoords[0].c_str(),
                                    args.fTransformedCoords[0].getType());
     fragBuilder->codeAppend(";\n");
 
     // Unpremultiply the displacement
     fragBuilder->codeAppendf(
-        "\t\t%s.rgb = (%s.a < %s) ? half3(0.0) : clamp(%s.rgb / %s.a, 0.0, 1.0);",
+        "\t\t%s.rgb = (%s.a < %s) ? float3(0.0) : clamp(%s.rgb / %s.a, 0.0, 1.0);",
         dColor, dColor, nearZero, dColor, dColor);
     SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[1]);
-    fragBuilder->codeAppendf("\t\thighfloat2 %s = %s + %s*(%s.",
+    fragBuilder->codeAppendf("\t\tfloat2 %s = %s + %s*(%s.",
                              cCoords, coords2D.c_str(), scaleUni, dColor);
 
     switch (displacementMap.xChannelSelector()) {
@@ -611,7 +612,7 @@ void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
       default:
         SkDEBUGFAIL("Unknown Y channel selector");
     }
-    fragBuilder->codeAppend("-half2(0.5));\t\t");
+    fragBuilder->codeAppend("-float2(0.5));\t\t");
 
     fGLDomain.sampleTexture(fragBuilder,
                             args.fUniformHandler,
diff --git a/src/effects/SkHighContrastFilter.cpp b/src/effects/SkHighContrastFilter.cpp
index 7618861c5f..3de7603c74 100644
--- a/src/effects/SkHighContrastFilter.cpp
+++ b/src/effects/SkHighContrastFilter.cpp
@@ -247,46 +247,47 @@ void GLHighContrastFilterEffect::GenKey(
 
 void GLHighContrastFilterEffect::emitCode(EmitArgs& args) {
     const char* contrast;
-    fContrastUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+    fContrastUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                    kFloat_GrSLType, kDefault_GrSLPrecision,
                                                     "contrast", &contrast);
 
     if (nullptr == args.fInputColor) {
-        args.fInputColor = "half4(1)";
+        args.fInputColor = "float4(1)";
     }
 
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
 
-    fragBuilder->codeAppendf("half4 color = %s;", args.fInputColor);
+    fragBuilder->codeAppendf("float4 color = %s;", args.fInputColor);
 
     // Unpremultiply. The max() is to guard against 0 / 0.
-    fragBuilder->codeAppendf("half nonZeroAlpha = max(color.a, 0.00001);");
-    fragBuilder->codeAppendf("color = half4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
+    fragBuilder->codeAppendf("float nonZeroAlpha = max(color.a, 0.00001);");
+    fragBuilder->codeAppendf("color = float4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
 
     // Grayscale.
     if (fConfig.fGrayscale) {
-        fragBuilder->codeAppendf("half luma = dot(color, half4(%f, %f, %f, 0));",
+        fragBuilder->codeAppendf("float luma = dot(color, float4(%f, %f, %f, 0));",
                                  SK_LUM_COEFF_R, SK_LUM_COEFF_G, SK_LUM_COEFF_B);
-        fragBuilder->codeAppendf("color = half4(luma, luma, luma, 0);");
+        fragBuilder->codeAppendf("color = float4(luma, luma, luma, 0);");
     }
 
     if (fConfig.fInvertStyle == InvertStyle::kInvertBrightness) {
-        fragBuilder->codeAppendf("color = half4(1, 1, 1, 1) - color;");
+        fragBuilder->codeAppendf("color = float4(1, 1, 1, 1) - color;");
     }
 
     if (fConfig.fInvertStyle == InvertStyle::kInvertLightness) {
         // Convert from RGB to HSL.
-        fragBuilder->codeAppendf("half fmax = max(color.r, max(color.g, color.b));");
-        fragBuilder->codeAppendf("half fmin = min(color.r, min(color.g, color.b));");
-        fragBuilder->codeAppendf("half l = (fmax + fmin) / 2;");
+        fragBuilder->codeAppendf("float fmax = max(color.r, max(color.g, color.b));");
+        fragBuilder->codeAppendf("float fmin = min(color.r, min(color.g, color.b));");
+        fragBuilder->codeAppendf("float l = (fmax + fmin) / 2;");
 
-        fragBuilder->codeAppendf("half h;");
-        fragBuilder->codeAppendf("half s;");
+        fragBuilder->codeAppendf("float h;");
+        fragBuilder->codeAppendf("float s;");
 
         fragBuilder->codeAppendf("if (fmax == fmin) {");
         fragBuilder->codeAppendf("  h = 0;");
         fragBuilder->codeAppendf("  s = 0;");
         fragBuilder->codeAppendf("} else {");
-        fragBuilder->codeAppendf("  half d = fmax - fmin;");
+        fragBuilder->codeAppendf("  float d = fmax - fmin;");
         fragBuilder->codeAppendf("  s = l > 0.5 ?");
         fragBuilder->codeAppendf("      d / (2 - fmax - fmin) :");
         fragBuilder->codeAppendf("      d / (fmax + fmin);");
@@ -304,11 +305,11 @@ void GLHighContrastFilterEffect::emitCode(EmitArgs& args) {
         // Convert back from HSL to RGB.
         SkString hue2rgbFuncName;
         static const GrShaderVar gHue2rgbArgs[] = {
-            GrShaderVar("p", kHalf_GrSLType),
-            GrShaderVar("q", kHalf_GrSLType),
-            GrShaderVar("t", kHalf_GrSLType),
+            GrShaderVar("p", kFloat_GrSLType),
+            GrShaderVar("q", kFloat_GrSLType),
+            GrShaderVar("t", kFloat_GrSLType),
         };
-        fragBuilder->emitFunction(kHalf_GrSLType,
+        fragBuilder->emitFunction(kFloat_GrSLType,
                                   "hue2rgb",
                                   SK_ARRAY_COUNT(gHue2rgbArgs),
                                   gHue2rgbArgs,
@@ -325,10 +326,10 @@ void GLHighContrastFilterEffect::emitCode(EmitArgs& args) {
                                   "return p;",
                                   &hue2rgbFuncName);
         fragBuilder->codeAppendf("if (s == 0) {");
-        fragBuilder->codeAppendf("  color = half4(l, l, l, 0);");
+        fragBuilder->codeAppendf("  color = float4(l, l, l, 0);");
         fragBuilder->codeAppendf("} else {");
-        fragBuilder->codeAppendf("  half q = l < 0.5 ? l * (1 + s) : l + s - l * s;");
-        fragBuilder->codeAppendf("  half p = 2 * l - q;");
+        fragBuilder->codeAppendf("  float q = l < 0.5 ? l * (1 + s) : l + s - l * s;");
+        fragBuilder->codeAppendf("  float p = 2 * l - q;");
         fragBuilder->codeAppendf("  color.r = %s(p, q, h + 1/3.);", hue2rgbFuncName.c_str());
         fragBuilder->codeAppendf("  color.g = %s(p, q, h);", hue2rgbFuncName.c_str());
         fragBuilder->codeAppendf("  color.b = %s(p, q, h - 1/3.);", hue2rgbFuncName.c_str());
@@ -337,8 +338,8 @@ void GLHighContrastFilterEffect::emitCode(EmitArgs& args) {
 
     // Contrast.
     fragBuilder->codeAppendf("if (%s != 0) {", contrast);
-    fragBuilder->codeAppendf("  half m = (1 + %s) / (1 - %s);", contrast, contrast);
-    fragBuilder->codeAppendf("  half off = (-0.5 * m + 0.5);");
+    fragBuilder->codeAppendf("  float m = (1 + %s) / (1 - %s);", contrast, contrast);
+    fragBuilder->codeAppendf("  float off = (-0.5 * m + 0.5);");
     fragBuilder->codeAppendf("  color = m * color + off;");
     fragBuilder->codeAppendf("}");
 
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 10056e205d..d9fae43fa8 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -724,7 +724,7 @@ public:
 
     /**
      * This is called by GrGLLightingEffect::emitCode() before either of the two virtual functions
-     * below. It adds a half3 uniform visible in the FS that represents the constant light color.
+     * below. It adds a vec3f uniform visible in the FS that represents the constant light color.
      */
     void emitLightColorUniform(GrGLSLUniformHandler*);
 
@@ -1827,61 +1827,63 @@ void GrGLLightingEffect::emitCode(EmitArgs& args) {
 
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                    kHalf2_GrSLType, "ImageIncrement");
+                                                    kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                                    "ImageIncrement");
     fSurfaceScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                  kHalf_GrSLType, "SurfaceScale");
+                                                  kFloat_GrSLType, kDefault_GrSLPrecision,
+                                                  "SurfaceScale");
     fLight->emitLightColorUniform(uniformHandler);
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString lightFunc;
     this->emitLightFunc(uniformHandler, fragBuilder, &lightFunc);
     static const GrShaderVar gSobelArgs[] =  {
-        GrShaderVar("a", kHalf_GrSLType),
-        GrShaderVar("b", kHalf_GrSLType),
-        GrShaderVar("c", kHalf_GrSLType),
-        GrShaderVar("d", kHalf_GrSLType),
-        GrShaderVar("e", kHalf_GrSLType),
-        GrShaderVar("f", kHalf_GrSLType),
-        GrShaderVar("scale", kHalf_GrSLType),
+        GrShaderVar("a", kFloat_GrSLType),
+        GrShaderVar("b", kFloat_GrSLType),
+        GrShaderVar("c", kFloat_GrSLType),
+        GrShaderVar("d", kFloat_GrSLType),
+        GrShaderVar("e", kFloat_GrSLType),
+        GrShaderVar("f", kFloat_GrSLType),
+        GrShaderVar("scale", kFloat_GrSLType),
     };
     SkString sobelFuncName;
     SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
 
-    fragBuilder->emitFunction(kHalf_GrSLType,
+    fragBuilder->emitFunction(kFloat_GrSLType,
                               "sobel",
                               SK_ARRAY_COUNT(gSobelArgs),
                               gSobelArgs,
                               "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scale;\n",
                               &sobelFuncName);
     static const GrShaderVar gPointToNormalArgs[] =  {
-        GrShaderVar("x", kHalf_GrSLType),
-        GrShaderVar("y", kHalf_GrSLType),
-        GrShaderVar("scale", kHalf_GrSLType),
+        GrShaderVar("x", kFloat_GrSLType),
+        GrShaderVar("y", kFloat_GrSLType),
+        GrShaderVar("scale", kFloat_GrSLType),
     };
     SkString pointToNormalName;
-    fragBuilder->emitFunction(kHalf3_GrSLType,
+    fragBuilder->emitFunction(kVec3f_GrSLType,
                               "pointToNormal",
                               SK_ARRAY_COUNT(gPointToNormalArgs),
                               gPointToNormalArgs,
-                              "\treturn normalize(half3(-x * scale, -y * scale, 1));\n",
+                              "\treturn normalize(float3(-x * scale, -y * scale, 1));\n",
                               &pointToNormalName);
 
     static const GrShaderVar gInteriorNormalArgs[] =  {
-        GrShaderVar("m", kHalf_GrSLType, 9),
-        GrShaderVar("surfaceScale", kHalf_GrSLType),
+        GrShaderVar("m", kFloat_GrSLType, 9),
+        GrShaderVar("surfaceScale", kFloat_GrSLType),
     };
     SkString normalBody = emitNormalFunc(le.boundaryMode(),
                                          pointToNormalName.c_str(),
                                          sobelFuncName.c_str());
     SkString normalName;
-    fragBuilder->emitFunction(kHalf3_GrSLType,
+    fragBuilder->emitFunction(kVec3f_GrSLType,
                               "normal",
                               SK_ARRAY_COUNT(gInteriorNormalArgs),
                               gInteriorNormalArgs,
                               normalBody.c_str(),
                               &normalName);
 
-    fragBuilder->codeAppendf("\t\thighfloat2 coord = %s;\n", coords2D.c_str());
-    fragBuilder->codeAppend("\t\thalf m[9];\n");
+    fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", coords2D.c_str());
+    fragBuilder->codeAppend("\t\tfloat m[9];\n");
 
     const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
     const char* surfScale = uniformHandler->getUniformCStr(fSurfaceScaleUni);
@@ -1890,10 +1892,10 @@ void GrGLLightingEffect::emitCode(EmitArgs& args) {
     for (int dy = 1; dy >= -1; dy--) {
         for (int dx = -1; dx <= 1; dx++) {
             SkString texCoords;
-            texCoords.appendf("coord + half2(%d, %d) * %s", dx, dy, imgInc);
+            texCoords.appendf("coord + float2(%d, %d) * %s", dx, dy, imgInc);
             SkString temp;
             temp.appendf("temp%d", index);
-            fragBuilder->codeAppendf("half4 %s;", temp.c_str());
+            fragBuilder->codeAppendf("float4 %s;", temp.c_str());
             fDomain.sampleTexture(fragBuilder,
                                   args.fUniformHandler,
                                   args.fShaderCaps,
@@ -1905,7 +1907,7 @@ void GrGLLightingEffect::emitCode(EmitArgs& args) {
             index++;
         }
     }
-    fragBuilder->codeAppend("\t\thalf3 surfaceToLight = ");
+    fragBuilder->codeAppend("\t\tfloat3 surfaceToLight = ");
     SkString arg;
     arg.appendf("%s * m[4]", surfScale);
     fLight->emitSurfaceToLight(uniformHandler, fragBuilder, arg.c_str());
@@ -1951,17 +1953,19 @@ void GrGLDiffuseLightingEffect::emitLightFunc(GrGLSLUniformHandler* uniformHandl
                                               GrGLSLFPFragmentBuilder* fragBuilder,
                                               SkString* funcName) {
     const char* kd;
-    fKDUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "KD", &kd);
+    fKDUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                 kFloat_GrSLType, kDefault_GrSLPrecision,
+                                 "KD", &kd);
 
     static const GrShaderVar gLightArgs[] = {
-        GrShaderVar("normal", kHalf3_GrSLType),
-        GrShaderVar("surfaceToLight", kHalf3_GrSLType),
-        GrShaderVar("lightColor", kHalf3_GrSLType)
+        GrShaderVar("normal", kVec3f_GrSLType),
+        GrShaderVar("surfaceToLight", kVec3f_GrSLType),
+        GrShaderVar("lightColor", kVec3f_GrSLType)
     };
     SkString lightBody;
-    lightBody.appendf("\thalf colorScale = %s * dot(normal, surfaceToLight);\n", kd);
-    lightBody.appendf("\treturn half4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n");
-    fragBuilder->emitFunction(kHalf4_GrSLType,
+    lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n", kd);
+    lightBody.appendf("\treturn float4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n");
+    fragBuilder->emitFunction(kVec4f_GrSLType,
                               "light",
                               SK_ARRAY_COUNT(gLightArgs),
                               gLightArgs,
@@ -2047,24 +2051,26 @@ void GrGLSpecularLightingEffect::emitLightFunc(GrGLSLUniformHandler* uniformHand
     const char* ks;
     const char* shininess;
 
-    fKSUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "KS", &ks);
+    fKSUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                        kFloat_GrSLType, kDefault_GrSLPrecision, "KS", &ks);
     fShininessUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                               kHalf_GrSLType,
+                                               kFloat_GrSLType,
+                                               kDefault_GrSLPrecision,
                                                "Shininess",
                                                &shininess);
 
     static const GrShaderVar gLightArgs[] = {
-        GrShaderVar("normal", kHalf3_GrSLType),
-        GrShaderVar("surfaceToLight", kHalf3_GrSLType),
-        GrShaderVar("lightColor", kHalf3_GrSLType)
+        GrShaderVar("normal", kVec3f_GrSLType),
+        GrShaderVar("surfaceToLight", kVec3f_GrSLType),
+        GrShaderVar("lightColor", kVec3f_GrSLType)
     };
     SkString lightBody;
-    lightBody.appendf("\thalf3 halfDir = half3(normalize(surfaceToLight + half3(0, 0, 1)));\n");
-    lightBody.appendf("\thighfloat colorScale = %s * pow(dot(normal, halfDir), %s);\n",
+    lightBody.appendf("\tfloat3 halfDir = float3(normalize(surfaceToLight + float3(0, 0, 1)));\n");
+    lightBody.appendf("\thighp float colorScale = %s * pow(dot(normal, halfDir), %s);\n",
                       ks, shininess);
-    lightBody.appendf("\thalf3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
-    lightBody.appendf("\treturn half4(color, max(max(color.r, color.g), color.b));\n");
-    fragBuilder->emitFunction(kHalf4_GrSLType,
+    lightBody.appendf("\tfloat3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
+    lightBody.appendf("\treturn float4(color, max(max(color.r, color.g), color.b));\n");
+    fragBuilder->emitFunction(kVec4f_GrSLType,
                               "light",
                               SK_ARRAY_COUNT(gLightArgs),
                               gLightArgs,
@@ -2082,7 +2088,9 @@ void GrGLSpecularLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman
 
 ///////////////////////////////////////////////////////////////////////////////
 void GrGLLight::emitLightColorUniform(GrGLSLUniformHandler* uniformHandler) {
-    fColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType, "LightColor");
+    fColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                           kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                           "LightColor");
 }
 
 void GrGLLight::emitLightColor(GrGLSLUniformHandler* uniformHandler,
@@ -2111,7 +2119,8 @@ void GrGLDistantLight::emitSurfaceToLight(GrGLSLUniformHandler* uniformHandler,
                                           GrGLSLFPFragmentBuilder* fragBuilder,
                                           const char* z) {
     const char* dir;
-    fDirectionUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
+    fDirectionUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                               kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                "LightDirection", &dir);
     fragBuilder->codeAppend(dir);
 }
@@ -2130,9 +2139,10 @@ void GrGLPointLight::emitSurfaceToLight(GrGLSLUniformHandler* uniformHandler,
                                         GrGLSLFPFragmentBuilder* fragBuilder,
                                         const char* z) {
     const char* loc;
-    fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
+    fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                              kVec3f_GrSLType, kDefault_GrSLPrecision,
                                               "LightLocation", &loc);
-    fragBuilder->codeAppendf("normalize(%s - half3(sk_FragCoord.xy, %s))",
+    fragBuilder->codeAppendf("normalize(%s - float3(sk_FragCoord.xy, %s))",
                              loc, z);
 }
 
@@ -2155,10 +2165,11 @@ void GrGLSpotLight::emitSurfaceToLight(GrGLSLUniformHandler* uniformHandler,
                                        GrGLSLFPFragmentBuilder* fragBuilder,
                                        const char* z) {
     const char* location;
-    fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
+    fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                              kVec3f_GrSLType, kDefault_GrSLPrecision,
                                               "LightLocation", &location);
 
-    fragBuilder->codeAppendf("normalize(%s - half3(sk_FragCoord.xy, %s))",
+    fragBuilder->codeAppendf("normalize(%s - float3(sk_FragCoord.xy, %s))",
                              location, z);
 }
 
@@ -2173,31 +2184,36 @@ void GrGLSpotLight::emitLightColor(GrGLSLUniformHandler* uniformHandler,
     const char* cosOuter;
     const char* coneScale;
     const char* s;
-    fExponentUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+    fExponentUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                              kFloat_GrSLType, kDefault_GrSLPrecision,
                                               "Exponent", &exponent);
-    fCosInnerConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+    fCosInnerConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                       kFloat_GrSLType, kDefault_GrSLPrecision,
                                                        "CosInnerConeAngle", &cosInner);
-    fCosOuterConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+    fCosOuterConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                       kFloat_GrSLType, kDefault_GrSLPrecision,
                                                        "CosOuterConeAngle", &cosOuter);
-    fConeScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+    fConeScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                               kFloat_GrSLType, kDefault_GrSLPrecision,
                                                "ConeScale", &coneScale);
-    fSUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType, "S", &s);
+    fSUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                       kVec3f_GrSLType, kDefault_GrSLPrecision, "S", &s);
 
     static const GrShaderVar gLightColorArgs[] = {
-        GrShaderVar("surfaceToLight", kHalf3_GrSLType)
+        GrShaderVar("surfaceToLight", kVec3f_GrSLType)
     };
     SkString lightColorBody;
-    lightColorBody.appendf("\thalf cosAngle = -dot(surfaceToLight, %s);\n", s);
+    lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s);
     lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter);
-    lightColorBody.appendf("\t\treturn half3(0);\n");
+    lightColorBody.appendf("\t\treturn float3(0);\n");
     lightColorBody.appendf("\t}\n");
-    lightColorBody.appendf("\thalf scale = pow(cosAngle, %s);\n", exponent);
+    lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent);
     lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner);
     lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n",
                            color, cosOuter, coneScale);
     lightColorBody.appendf("\t}\n");
     lightColorBody.appendf("\treturn %s;\n", color);
-    fragBuilder->emitFunction(kHalf3_GrSLType,
+    fragBuilder->emitFunction(kVec3f_GrSLType,
                               "lightColor",
                               SK_ARRAY_COUNT(gLightColorArgs),
                               gLightColorArgs,
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index ecd1a3a302..5c5edcdd48 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -60,16 +60,16 @@ private:
 
         void emitCode(EmitArgs& args) override {
             if (nullptr == args.fInputColor) {
-                args.fInputColor = "half4(1)";
+                args.fInputColor = "float4(1)";
             }
 
             GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-            fragBuilder->codeAppendf("\thalf luma = dot(half3(%f, %f, %f), %s.rgb);\n",
+            fragBuilder->codeAppendf("\tfloat luma = dot(float3(%f, %f, %f), %s.rgb);\n",
                                      SK_ITU_BT709_LUM_COEFF_R,
                                      SK_ITU_BT709_LUM_COEFF_G,
                                      SK_ITU_BT709_LUM_COEFF_B,
                                      args.fInputColor);
-            fragBuilder->codeAppendf("\t%s = half4(0, 0, 0, luma);\n",
+            fragBuilder->codeAppendf("\t%s = float4(0, 0, 0, luma);\n",
                                      args.fOutputColor);
 
         }
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index d989037319..4af375b553 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -180,44 +180,48 @@ private:
 void GrGLMagnifierEffect::emitCode(EmitArgs& args) {
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     fOffsetVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                            kHalf2_GrSLType, "Offset");
+                                            kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                            "Offset");
     fInvZoomVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                             kHalf2_GrSLType, "InvZoom");
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "InvZoom");
     fInvInsetVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                              kHalf2_GrSLType, "InvInset");
+                                              kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                              "InvInset");
     fBoundsVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                            kHalf4_GrSLType, "Bounds");
+                                            kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                            "Bounds");
 
     const GrMagnifierEffect& zoom = args.fFp.cast<GrMagnifierEffect>();
     fColorSpaceHelper.emitCode(uniformHandler, zoom.colorSpaceXform());
 
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
-    fragBuilder->codeAppendf("\t\thighfloat2 coord = %s;\n", coords2D.c_str());
-    fragBuilder->codeAppendf("\t\thighfloat2 zoom_coord = %s + %s * %s;\n",
+    fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", coords2D.c_str());
+    fragBuilder->codeAppendf("\t\tfloat2 zoom_coord = %s + %s * %s;\n",
                              uniformHandler->getUniformCStr(fOffsetVar),
                              coords2D.c_str(),
                              uniformHandler->getUniformCStr(fInvZoomVar));
     const char* bounds = uniformHandler->getUniformCStr(fBoundsVar);
-    fragBuilder->codeAppendf("\t\thighfloat2 delta = (coord - %s.xy) * %s.zw;\n", bounds, bounds);
-    fragBuilder->codeAppendf("\t\tdelta = min(delta, half2(1.0, 1.0) - delta);\n");
+    fragBuilder->codeAppendf("\t\tfloat2 delta = (coord - %s.xy) * %s.zw;\n", bounds, bounds);
+    fragBuilder->codeAppendf("\t\tdelta = min(delta, float2(1.0, 1.0) - delta);\n");
     fragBuilder->codeAppendf("\t\tdelta = delta * %s;\n",
                              uniformHandler->getUniformCStr(fInvInsetVar));
 
-    fragBuilder->codeAppend("\t\thalf weight = 0.0;\n");
+    fragBuilder->codeAppend("\t\tfloat weight = 0.0;\n");
     fragBuilder->codeAppend("\t\tif (delta.s < 2.0 && delta.t < 2.0) {\n");
-    fragBuilder->codeAppend("\t\t\tdelta = half2(2.0, 2.0) - delta;\n");
-    fragBuilder->codeAppend("\t\t\thalf dist = length(delta);\n");
+    fragBuilder->codeAppend("\t\t\tdelta = float2(2.0, 2.0) - delta;\n");
+    fragBuilder->codeAppend("\t\t\tfloat dist = length(delta);\n");
     fragBuilder->codeAppend("\t\t\tdist = max(2.0 - dist, 0.0);\n");
     fragBuilder->codeAppend("\t\t\tweight = min(dist * dist, 1.0);\n");
     fragBuilder->codeAppend("\t\t} else {\n");
-    fragBuilder->codeAppend("\t\t\thighfloat2 delta_squared = delta * delta;\n");
+    fragBuilder->codeAppend("\t\t\tfloat2 delta_squared = delta * delta;\n");
     fragBuilder->codeAppend("\t\t\tweight = min(min(delta_squared.x, delta_squared.y), 1.0);\n");
     fragBuilder->codeAppend("\t\t}\n");
 
-    fragBuilder->codeAppend("\t\thighfloat2 mix_coord = mix(coord, zoom_coord, weight);\n");
-    fragBuilder->codeAppend("\t\thalf4 output_color = ");
-    fragBuilder->appendTextureLookup(args.fTexSamplers[0], "mix_coord", kHalf2_GrSLType,
+    fragBuilder->codeAppend("\t\tfloat2 mix_coord = mix(coord, zoom_coord, weight);\n");
+    fragBuilder->codeAppend("\t\tfloat4 output_color = ");
+    fragBuilder->appendTextureLookup(args.fTexSamplers[0], "mix_coord", kVec2f_GrSLType,
                                      &fColorSpaceHelper);
     fragBuilder->codeAppend(";\n");
 
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index a67e45a361..629222ddc8 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -212,9 +212,13 @@ void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
     const GrMorphologyEffect& me = args.fFp.cast<GrMorphologyEffect>();
 
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
-    fPixelSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "PixelSize");
+    fPixelSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                               kFloat_GrSLType, kDefault_GrSLPrecision,
+                                               "PixelSize");
     const char* pixelSizeInc = uniformHandler->getUniformCStr(fPixelSizeUni);
-    fRangeUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHighFloat2_GrSLType, "Range");
+    fRangeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                           kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                           "Range");
     const char* range = uniformHandler->getUniformCStr(fRangeUni);
 
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
@@ -222,11 +226,11 @@ void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
     const char* func;
     switch (me.type()) {
         case GrMorphologyEffect::Type::kErode:
-            fragBuilder->codeAppendf("\t\t%s = half4(1, 1, 1, 1);\n", args.fOutputColor);
+            fragBuilder->codeAppendf("\t\t%s = float4(1, 1, 1, 1);\n", args.fOutputColor);
             func = "min";
             break;
         case GrMorphologyEffect::Type::kDilate:
-            fragBuilder->codeAppendf("\t\t%s = half4(0, 0, 0, 0);\n", args.fOutputColor);
+            fragBuilder->codeAppendf("\t\t%s = float4(0, 0, 0, 0);\n", args.fOutputColor);
             func = "max";
             break;
         default:
@@ -251,12 +255,12 @@ void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
     int width = me.width();
 
     // float2 coord = coord2D;
-    fragBuilder->codeAppendf("\t\thighfloat2 coord = %s;\n", coords2D.c_str());
+    fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", coords2D.c_str());
     // coord.x -= radius * pixelSize;
     fragBuilder->codeAppendf("\t\tcoord.%s -= %d.0 * %s; \n", dir, me.radius(), pixelSizeInc);
     if (me.useRange()) {
         // highBound = min(highBound, coord.x + (width-1) * pixelSize);
-        fragBuilder->codeAppendf("\t\thighfloat highBound = min(%s.y, coord.%s + %f * %s);",
+        fragBuilder->codeAppendf("\t\tfloat highBound = min(%s.y, coord.%s + %f * %s);",
                                  range, dir, float(width - 1), pixelSizeInc);
         // coord.x = max(lowBound, coord.x);
         fragBuilder->codeAppendf("\t\tcoord.%s = max(%s.x, coord.%s);", dir, range, dir);
diff --git a/src/effects/SkOverdrawColorFilter.cpp b/src/effects/SkOverdrawColorFilter.cpp
index be5a623396..8ca699e89f 100644
--- a/src/effects/SkOverdrawColorFilter.cpp
+++ b/src/effects/SkOverdrawColorFilter.cpp
@@ -150,49 +150,49 @@ GLOverdrawFragmentProcessor::GLOverdrawFragmentProcessor(const GrColor4f* colors
 void GLOverdrawFragmentProcessor::emitCode(EmitArgs& args) {
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     if (nullptr == args.fInputColor) {
-        fragBuilder->codeAppendf("%s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                     fColors[5].fRGBA[0],
-                                                                     fColors[5].fRGBA[1],
-                                                                     fColors[5].fRGBA[2],
-                                                                     fColors[5].fRGBA[3]);
+        fragBuilder->codeAppendf("%s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                    fColors[5].fRGBA[0],
+                                                                    fColors[5].fRGBA[1],
+                                                                    fColors[5].fRGBA[2],
+                                                                    fColors[5].fRGBA[3]);
     } else {
-        fragBuilder->codeAppendf("half alpha = 255.0 * %s.a;", args.fInputColor);
+        fragBuilder->codeAppendf("float alpha = 255.0 * %s.a;", args.fInputColor);
         fragBuilder->codeAppendf("if (alpha < 0.5) {");
-        fragBuilder->codeAppendf("    %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                         fColors[0].fRGBA[0],
-                                                                         fColors[0].fRGBA[1],
-                                                                         fColors[0].fRGBA[2],
-                                                                         fColors[0].fRGBA[3]);
+        fragBuilder->codeAppendf("    %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                        fColors[0].fRGBA[0],
+                                                                        fColors[0].fRGBA[1],
+                                                                        fColors[0].fRGBA[2],
+                                                                        fColors[0].fRGBA[3]);
         fragBuilder->codeAppendf("} else if (alpha < 1.5) {");
-        fragBuilder->codeAppendf("    %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                         fColors[1].fRGBA[0],
-                                                                         fColors[1].fRGBA[1],
-                                                                         fColors[1].fRGBA[2],
-                                                                         fColors[1].fRGBA[3]);
+        fragBuilder->codeAppendf("    %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                        fColors[1].fRGBA[0],
+                                                                        fColors[1].fRGBA[1],
+                                                                        fColors[1].fRGBA[2],
+                                                                        fColors[1].fRGBA[3]);
         fragBuilder->codeAppendf("} else if (alpha < 2.5) {");
-        fragBuilder->codeAppendf("    %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                         fColors[2].fRGBA[0],
-                                                                         fColors[2].fRGBA[1],
-                                                                         fColors[2].fRGBA[2],
-                                                                         fColors[2].fRGBA[3]);
+        fragBuilder->codeAppendf("    %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                        fColors[2].fRGBA[0],
+                                                                        fColors[2].fRGBA[1],
+                                                                        fColors[2].fRGBA[2],
+                                                                        fColors[2].fRGBA[3]);
         fragBuilder->codeAppendf("} else if (alpha < 3.5) {");
-        fragBuilder->codeAppendf("    %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                         fColors[3].fRGBA[0],
-                                                                         fColors[3].fRGBA[1],
-                                                                         fColors[3].fRGBA[2],
-                                                                         fColors[3].fRGBA[3]);
+        fragBuilder->codeAppendf("    %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                        fColors[3].fRGBA[0],
+                                                                        fColors[3].fRGBA[1],
+                                                                        fColors[3].fRGBA[2],
+                                                                        fColors[3].fRGBA[3]);
         fragBuilder->codeAppendf("} else if (alpha < 4.5) {");
-        fragBuilder->codeAppendf("    %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                         fColors[4].fRGBA[0],
-                                                                         fColors[4].fRGBA[1],
-                                                                         fColors[4].fRGBA[2],
-                                                                         fColors[4].fRGBA[3]);
+        fragBuilder->codeAppendf("    %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                        fColors[4].fRGBA[0],
+                                                                        fColors[4].fRGBA[1],
+                                                                        fColors[4].fRGBA[2],
+                                                                        fColors[4].fRGBA[3]);
         fragBuilder->codeAppendf("} else {");
-        fragBuilder->codeAppendf("    %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
-                                                                         fColors[5].fRGBA[0],
-                                                                         fColors[5].fRGBA[1],
-                                                                         fColors[5].fRGBA[2],
-                                                                         fColors[5].fRGBA[3]);
+        fragBuilder->codeAppendf("    %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
+                                                                        fColors[5].fRGBA[0],
+                                                                        fColors[5].fRGBA[1],
+                                                                        fColors[5].fRGBA[2],
+                                                                        fColors[5].fRGBA[3]);
         fragBuilder->codeAppendf("}");
     }
 }
diff --git a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
index b0e7ca3529..2f045f1c9d 100644
--- a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
+++ b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
@@ -241,7 +241,7 @@ private:
 
             // Positive distance is towards the center of the circle.
             // Map all the cases to the lower right quadrant.
-            fragBuilder->codeAppendf("half2 delta = abs(sk_FragCoord.xy - %s.%s);",
+            fragBuilder->codeAppendf("float2 delta = abs(sk_FragCoord.xy - %s.%s);",
                                      posName, indices);
 
             switch (mode) {
@@ -249,14 +249,14 @@ private:
                     // When a shadow circle gets large we can have some precision issues if
                     // we do "length(delta)/radius". The scaleDist temporary cuts the
                     // delta vector down a bit before invoking length.
-                    fragBuilder->codeAppendf("half scaledDist = length(delta/%s);", radName);
+                    fragBuilder->codeAppendf("float scaledDist = length(delta/%s);", radName);
                     fragBuilder->codeAppendf("%s = clamp((%s.%c/%s - scaledDist), 0.0, 1.0);",
                                              outputName, sizesName, indices[0], radName);
                     break;
                 case kRect_Mode:
                     fragBuilder->codeAppendf(
-                        "half2 rectDist = half2(1.0 - clamp((%s.%c - delta.x)/%s, 0.0, 1.0),"
-                                               "1.0 - clamp((%s.%c - delta.y)/%s, 0.0, 1.0));",
+                        "float2 rectDist = float2(1.0 - clamp((%s.%c - delta.x)/%s, 0.0, 1.0),"
+                                             "1.0 - clamp((%s.%c - delta.y)/%s, 0.0, 1.0));",
                         sizesName, indices[0], radName,
                         sizesName, indices[1], radName);
                     fragBuilder->codeAppendf("%s = clamp(1.0 - length(rectDist), 0.0, 1.0);",
@@ -273,11 +273,11 @@ private:
 
                     //----------------
                     // rect distance computation
-                    fragBuilder->codeAppendf("half xDist = (%s.%c - delta.x) / %s;",
+                    fragBuilder->codeAppendf("float xDist = (%s.%c - delta.x) / %s;",
                                              sizesName, indices[0], radName);
-                    fragBuilder->codeAppendf("half yDist = (%s.%c - delta.y) / %s;",
+                    fragBuilder->codeAppendf("float yDist = (%s.%c - delta.y) / %s;",
                                              sizesName, indices[1], radName);
-                    fragBuilder->codeAppend("half rectDist = clamp(min(xDist, yDist), 0.0, 1.0);");
+                    fragBuilder->codeAppend("float rectDist = clamp(min(xDist, yDist), 0.0, 1.0);");
 
                     //----------------
                     // ice-cream-cone fractional distance computation
@@ -286,59 +286,59 @@ private:
                     // compute the pointy end of the ice cream cone. If it smaller we just want to
                     // use the center of the corner's circle. When using the blurRadius the inset
                     // amount can't exceed the halfwidths of the RRect.
-                    fragBuilder->codeAppendf("half insetDist = min(max(%s, %s.%c),"
+                    fragBuilder->codeAppendf("float insetDist = min(max(%s, %s.%c),"
                                                                    "min(%s.%c, %s.%c));",
                                              radName, radiiName, indices[0],
                                              sizesName, indices[0], sizesName, indices[1]);
                     // "maxValue" is a correction term for if the blurRadius is larger than the
                     // size of the RRect. In that case we don't want to go all the way to black.
-                    fragBuilder->codeAppendf("half maxValue = insetDist/%s;", radName);
+                    fragBuilder->codeAppendf("float maxValue = insetDist/%s;", radName);
 
-                    fragBuilder->codeAppendf("half2 coneBottom = half2(%s.%c - insetDist,"
-                                                                       "%s.%c - insetDist);",
+                    fragBuilder->codeAppendf("float2 coneBottom = float2(%s.%c - insetDist,"
+                                                                    "%s.%c - insetDist);",
                                              sizesName, indices[0], sizesName, indices[1]);
 
-                    fragBuilder->codeAppendf("half2 cornerTop = half2(%s.%c - %s.%c, %s.%c) -"
+                    fragBuilder->codeAppendf("float2 cornerTop = float2(%s.%c - %s.%c, %s.%c) -"
                                                                         "coneBottom;",
                                              sizesName, indices[0], radiiName, indices[0],
                                              sizesName, indices[1]);
-                    fragBuilder->codeAppendf("half2 cornerRight = half2(%s.%c, %s.%c - %s.%c) -"
+                    fragBuilder->codeAppendf("float2 cornerRight = float2(%s.%c, %s.%c - %s.%c) -"
                                                                         "coneBottom;",
                                              sizesName, indices[0],
                                              sizesName, indices[1], radiiName, indices[1]);
 
-                    fragBuilder->codeAppend("half2 ptInConeSpace = delta - coneBottom;");
-                    fragBuilder->codeAppend("half distToPtInConeSpace = length(ptInConeSpace);");
+                    fragBuilder->codeAppend("float2 ptInConeSpace = delta - coneBottom;");
+                    fragBuilder->codeAppend("float distToPtInConeSpace = length(ptInConeSpace);");
 
-                    fragBuilder->codeAppend("half cross1 =  ptInConeSpace.x * cornerTop.y -"
-                                                           "ptInConeSpace.y * cornerTop.x;");
-                    fragBuilder->codeAppend("half cross2 = -ptInConeSpace.x * cornerRight.y + "
-                                                           "ptInConeSpace.y * cornerRight.x;");
+                    fragBuilder->codeAppend("float cross1 =  ptInConeSpace.x * cornerTop.y -"
+                                                            "ptInConeSpace.y * cornerTop.x;");
+                    fragBuilder->codeAppend("float cross2 = -ptInConeSpace.x * cornerRight.y + "
+                                                            "ptInConeSpace.y * cornerRight.x;");
 
-                    fragBuilder->codeAppend("half inCone = step(0.0, cross1) *"
-                                                          "step(0.0, cross2);");
+                    fragBuilder->codeAppend("float inCone = step(0.0, cross1) *"
+                                                           "step(0.0, cross2);");
 
-                    fragBuilder->codeAppendf("half2 cornerCenterInConeSpace = half2(insetDist -"
+                    fragBuilder->codeAppendf("float2 cornerCenterInConeSpace = float2(insetDist -"
                                                                                  "%s.%c);",
                                              radiiName, indices[0]);
 
-                    fragBuilder->codeAppend("half2 connectingVec = ptInConeSpace -"
+                    fragBuilder->codeAppend("float2 connectingVec = ptInConeSpace -"
                                                                         "cornerCenterInConeSpace;");
                     fragBuilder->codeAppend("ptInConeSpace = normalize(ptInConeSpace);");
 
                     // "a" (i.e., dot(ptInConeSpace, ptInConeSpace) should always be 1.0f since
                     // ptInConeSpace is now normalized
-                    fragBuilder->codeAppend("half b = 2.0 * dot(ptInConeSpace, connectingVec);");
-                    fragBuilder->codeAppendf("half c = dot(connectingVec, connectingVec) - "
+                    fragBuilder->codeAppend("float b = 2.0 * dot(ptInConeSpace, connectingVec);");
+                    fragBuilder->codeAppendf("float c = dot(connectingVec, connectingVec) - "
                                                                                    "%s.%c * %s.%c;",
                                              radiiName, indices[0], radiiName, indices[0]);
 
-                    fragBuilder->codeAppend("half fourAC = 4*c;");
+                    fragBuilder->codeAppend("float fourAC = 4*c;");
                     // This max prevents sqrt(-1) when outside the cone
-                    fragBuilder->codeAppend("half bSq = max(b*b, fourAC);");
+                    fragBuilder->codeAppend("float bSq = max(b*b, fourAC);");
 
                     // lop off negative values that are outside the cone
-                    fragBuilder->codeAppend("half coneDist = "
+                    fragBuilder->codeAppend("float coneDist = "
                                                     "max(0.0, 0.5 * (-b + sqrt(bSq - fourAC)));");
                     // make the coneDist a fraction of how far it is from the edge to the
                     // cone's base
@@ -358,38 +358,42 @@ private:
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             const char* positionsUniName = nullptr;
-            fPositionsUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+            fPositionsUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                        "Positions", &positionsUniName);
             const char* sizesUniName = nullptr;
-            fSizesUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
-                                                   kDefault_GrSLPrecision, "Sizes", &sizesUniName);
+            fSizesUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                   kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                                   "Sizes", &sizesUniName);
             const char* radiiUniName = nullptr;
             if (fp.fFirstMode == kSimpleCircular_Mode || fp.fSecondMode == kSimpleCircular_Mode) {
-                fRadiiUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+                fRadiiUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                        "Radii", &radiiUniName);
             }
             const char* radUniName = nullptr;
-            fRadiusUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+            fRadiusUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                    kFloat_GrSLType, kDefault_GrSLPrecision,
                                                     "Radius", &radUniName);
 
-            fragBuilder->codeAppend("half firstDist;");
+            fragBuilder->codeAppend("float firstDist;");
             fragBuilder->codeAppend("{");
             this->emitModeCode(fp.firstMode(), fragBuilder,
                                positionsUniName, sizesUniName, radiiUniName,
                                radUniName, "firstDist", "xy");
             fragBuilder->codeAppend("}");
 
-            fragBuilder->codeAppend("half secondDist;");
+            fragBuilder->codeAppend("float secondDist;");
             fragBuilder->codeAppend("{");
             this->emitModeCode(fp.secondMode(), fragBuilder,
                                positionsUniName, sizesUniName, radiiUniName,
                                radUniName, "secondDist", "zw");
             fragBuilder->codeAppend("}");
 
-            fragBuilder->codeAppend("half2 distVec = half2(1.0 - firstDist, 1.0 - secondDist);");
+            fragBuilder->codeAppend("float2 distVec = float2(1.0 - firstDist, 1.0 - secondDist);");
 
             // Finally use the distance to apply the Gaussian edge
-            fragBuilder->codeAppend("half factor = clamp(length(distVec), 0.0, 1.0);");
+            fragBuilder->codeAppend("float factor = clamp(length(distVec), 0.0, 1.0);");
             fragBuilder->codeAppend("factor = exp(-factor * factor * 4.0) - 0.018;");
             fragBuilder->codeAppendf("%s = factor*%s;",
                                      args.fOutputColor, args.fInputColor);
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 6ebcfa66e8..0cda71394e 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -396,7 +396,8 @@ void GLColorTableEffect::onSetData(const GrGLSLProgramDataManager& pdm,
 
 void GLColorTableEffect::emitCode(EmitArgs& args) {
     const char* yoffsets;
-    fRGBAYValuesUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+    fRGBAYValuesUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                        "yoffsets", &yoffsets);
     static const float kColorScaleFactor = 255.0f / 256.0f;
     static const float kColorOffsetFactor = 1.0f / 512.0f;
@@ -404,14 +405,14 @@ void GLColorTableEffect::emitCode(EmitArgs& args) {
     if (nullptr == args.fInputColor) {
         // the input color is solid white (all ones).
         static const float kMaxValue = kColorScaleFactor + kColorOffsetFactor;
-        fragBuilder->codeAppendf("\t\thalf4 coord = half4(%f, %f, %f, %f);\n",
+        fragBuilder->codeAppendf("\t\tfloat4 coord = float4(%f, %f, %f, %f);\n",
                                  kMaxValue, kMaxValue, kMaxValue, kMaxValue);
 
     } else {
-        fragBuilder->codeAppendf("\t\thalf nonZeroAlpha = max(%s.a, .0001);\n", args.fInputColor);
-        fragBuilder->codeAppendf("\t\thalf4 coord = half4(%s.rgb / nonZeroAlpha, nonZeroAlpha);\n",
+        fragBuilder->codeAppendf("\t\tfloat nonZeroAlpha = max(%s.a, .0001);\n", args.fInputColor);
+        fragBuilder->codeAppendf("\t\tfloat4 coord = float4(%s.rgb / nonZeroAlpha, nonZeroAlpha);\n",
                                  args.fInputColor);
-        fragBuilder->codeAppendf("\t\tcoord = coord * %f + half4(%f, %f, %f, %f);\n",
+        fragBuilder->codeAppendf("\t\tcoord = coord * %f + float4(%f, %f, %f, %f);\n",
                                  kColorScaleFactor,
                                  kColorOffsetFactor, kColorOffsetFactor,
                                  kColorOffsetFactor, kColorOffsetFactor);
@@ -420,22 +421,22 @@ void GLColorTableEffect::emitCode(EmitArgs& args) {
     SkString coord;
 
     fragBuilder->codeAppendf("\t\t%s.a = ", args.fOutputColor);
-    coord.printf("half2(coord.a, %s.a)", yoffsets);
+    coord.printf("float2(coord.a, %s.a)", yoffsets);
     fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
     fragBuilder->codeAppend(".a;\n");
 
     fragBuilder->codeAppendf("\t\t%s.r = ", args.fOutputColor);
-    coord.printf("half2(coord.r, %s.r)", yoffsets);
+    coord.printf("float2(coord.r, %s.r)", yoffsets);
     fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
     fragBuilder->codeAppend(".a;\n");
 
     fragBuilder->codeAppendf("\t\t%s.g = ", args.fOutputColor);
-    coord.printf("half2(coord.g, %s.g)", yoffsets);
+    coord.printf("float2(coord.g, %s.g)", yoffsets);
     fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
     fragBuilder->codeAppend(".a;\n");
 
     fragBuilder->codeAppendf("\t\t%s.b = ", args.fOutputColor);
-    coord.printf("half2(coord.b, %s.b)", yoffsets);
+    coord.printf("float2(coord.b, %s.b)", yoffsets);
     fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
     fragBuilder->codeAppend(".a;\n");