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

This reverts commit 88d99c63878c2d3d340120f0321676f72afcb4f0.

Reason for revert: Believed to be causing unit test failures in Chrome roll:

https://build.chromium.org/p/tryserver.chromium.android/builders/linux_android_rel_ng/builds/364433
https://luci-logdog.appspot.com/v/?s=chromium%2Fbb%2Ftryserver.chromium.android%2Flinux_android_rel_ng%2F364433%2F%2B%2Frecipes%2Fsteps%2Fcontent_browsertests__with_patch__on_Android%2F0%2Flogs%2FWebRtcCaptureFromElementBrowserTest.VerifyCanvasWebGLCaptureColor%2F0

Original change's description:
> Switched highp float to highfloat and mediump float to half.
> 
> The ultimate goal is to end up with "float" and "half", but this
> intermediate step uses "highfloat" so that it is clear if I missed a
> "float" somewhere. Once this lands, a subsequent CL will switch all
> "highfloats" back to "floats".
> 
> Bug: skia:
> Change-Id: Ia13225c7a0a0a2901e07665891c473d2500ddcca
> Reviewed-on: https://skia-review.googlesource.com/31000
> Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
> Reviewed-by: Brian Salomon <bsalomon@google.com>

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

Change-Id: I8bfa97547ac3920d433665f161d27df3f15c83aa
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/35705
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>

1 files changed, 41 insertions, 37 deletions

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);