Style bikeshed - remove extraneous whitespace

src/gpu/batches/GrPLSPathRenderer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPLSPathRenderer.h"
 
 #include "SkChunkAlloc.h"
@@ skipping 18 matching lines @@
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "glsl/GrGLSLPLSPathRendering.h"
 
 GrPLSPathRenderer::GrPLSPathRenderer() {
 }
 
 struct PLSVertex {
     SkPoint  fPos;
     // for triangles, these are the three triangle vertices
-    // for quads, vert1 is the texture UV coords, and vert2 and vert3 are the line segment 
+    // for quads, vert1 is the texture UV coords, and vert2 and vert3 are the line segment
     // comprising the flat edge of the quad
     SkPoint  fVert1;
     SkPoint  fVert2;
     SkPoint  fVert3;
     int fWinding;
 };
 typedef SkTArray<PLSVertex, true> PLSVertices;
 
 typedef SkTArray<SkPoint, true> FinishVertices;
 
 static const float kCubicTolerance = 0.5f;
 static const float kConicTolerance = 0.5f;
 
 static const float kBloatSize = 1.0f;
 
 static const float kBloatLimit = 640000.0f;
 
 #define kQuadNumVertices 5
 static void add_quad(SkPoint pts[3], PLSVertices& vertices) {
-    SkPoint normal = SkPoint::Make(pts[0].fY - pts[2].fY, 
+    SkPoint normal = SkPoint::Make(pts[0].fY - pts[2].fY,
                                    pts[2].fX - pts[0].fX);
     normal.setLength(kBloatSize);
     SkScalar cross = (pts[1] - pts[0]).cross(pts[2] - pts[0]);
     if (cross < 0) {
         normal = -normal;
     }
     PLSVertex quad[kQuadNumVertices];
     quad[0].fPos = pts[0] + normal;
     quad[1].fPos = pts[0] - normal;
     quad[2].fPos = pts[1] - normal;
@@ skipping 55 matching lines @@
     result[2] = pts[2];
     if (!outset(&result[2], -line3, -line2)) {
         return false;
     }
     pts[0] = result[0];
     pts[1] = result[1];
     pts[2] = result[2];
     return true;
 }
 
-static bool get_geometry(const SkPath& path, const SkMatrix& m, PLSVertices& triVertices, 
+static bool get_geometry(const SkPath& path, const SkMatrix& m, PLSVertices& triVertices,
                          PLSVertices& quadVertices, GrResourceProvider* resourceProvider,
                          SkRect bounds) {
     SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
     SkScalar tol = GrPathUtils::scaleToleranceToSrc(screenSpaceTol, m, bounds);
     int contourCnt;
     int maxPts = GrPathUtils::worstCasePointCount(path, &contourCnt, tol);
     if (maxPts <= 0) {
         return 0;
     }
     SkPath linesOnlyPath;
@@ skipping 139 matching lines @@
             GrGLSLVertexBuilder* vsBuilder = args.fVertBuilder;
             GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             varyingHandler->emitAttributes(te);
 
             this->setupPosition(vsBuilder, gpArgs, te.inPosition()->fName);
 
             GrGLSLVertToFrag v1(kVec2f_GrSLType);
             varyingHandler->addVarying("Vertex1", &v1, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", 
+            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);",
                                    v1.vsOut(),
-                                   te.inVertex1()->fName, 
+                                   te.inVertex1()->fName,
                                    te.inVertex1()->fName);
 
             GrGLSLVertToFrag v2(kVec2f_GrSLType);
             varyingHandler->addVarying("Vertex2", &v2, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", 
+            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);",
                                    v2.vsOut(),
-                                   te.inVertex2()->fName, 
+                                   te.inVertex2()->fName,
                                    te.inVertex2()->fName);
 
             GrGLSLVertToFrag v3(kVec2f_GrSLType);
             varyingHandler->addVarying("Vertex3", &v3, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", 
+            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);",
                                    v3.vsOut(),
-                                   te.inVertex3()->fName, 
+                                   te.inVertex3()->fName,
                                    te.inVertex3()->fName);
 
             GrGLSLVertToFrag delta1(kVec2f_GrSLType);
             varyingHandler->addVarying("delta1", &delta1, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;", 
+            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
                                    delta1.vsOut(), v1.vsOut(), v2.vsOut(), v2.vsOut(), v1.vsOut());
 
             GrGLSLVertToFrag delta2(kVec2f_GrSLType);
             varyingHandler->addVarying("delta2", &delta2, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;", 
+            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
                                    delta2.vsOut(), v2.vsOut(), v3.vsOut(), v3.vsOut(), v2.vsOut());
 
             GrGLSLVertToFrag delta3(kVec2f_GrSLType);
             varyingHandler->addVarying("delta3", &delta3, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;", 
+            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
                                    delta3.vsOut(), v3.vsOut(), v1.vsOut(), v1.vsOut(), v3.vsOut());
 
             GrGLSLVertToFrag windings(kInt_GrSLType);
             varyingHandler->addFlatVarying("windings", &windings, kLow_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;", 
+            vsBuilder->codeAppendf("%s = %s;",
                                    windings.vsOut(), te.inWindings()->fName);
 
             // emit transforms
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar, 
-                                 te.inPosition()->fName, te.localMatrix(), args.fTransformsIn, 
+            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
+                                 te.inPosition()->fName, te.localMatrix(), args.fTransformsIn,
                                  args.fTransformsOut);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
             SkAssertResult(fsBuilder->enableFeature(
                            GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLSLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
-            // Compute four subsamples, each shifted a quarter pixel along x and y from 
-            // gl_FragCoord. The oriented box positioning of the subsamples is of course not 
+            // Compute four subsamples, each shifted a quarter pixel along x and y from
+            // gl_FragCoord. The oriented box positioning of the subsamples is of course not
             // optimal, but it greatly simplifies the math and this simplification is necessary for
             // performance reasons.
-            fsBuilder->codeAppendf("highp vec2 firstSample = %s.xy - vec2(0.25);", 
+            fsBuilder->codeAppendf("highp vec2 firstSample = %s.xy - vec2(0.25);",
                                    fsBuilder->fragmentPosition());
             fsBuilder->codeAppendf("highp vec2 delta1 = %s;", delta1.fsIn());
             fsBuilder->codeAppendf("highp vec2 delta2 = %s;", delta2.fsIn());
             fsBuilder->codeAppendf("highp vec2 delta3 = %s;", delta3.fsIn());
             // Check whether first sample is inside the triangle by computing three dot products. If
             // all are < 0, we're inside. The first vector in each case is half of what it is
             // "supposed" to be, because we re-use them later as adjustment factors for which half
             // is the correct value, so we multiply the dots by two to compensate.
-            fsBuilder->codeAppendf("highp float d1 = dot(delta1, (firstSample - %s).yx) * 2.0;", 
+            fsBuilder->codeAppendf("highp float d1 = dot(delta1, (firstSample - %s).yx) * 2.0;",
                                    v1.fsIn());
-            fsBuilder->codeAppendf("highp float d2 = dot(delta2, (firstSample - %s).yx) * 2.0;", 
+            fsBuilder->codeAppendf("highp float d2 = dot(delta2, (firstSample - %s).yx) * 2.0;",
                                    v2.fsIn());
-            fsBuilder->codeAppendf("highp float d3 = dot(delta3, (firstSample - %s).yx) * 2.0;", 
+            fsBuilder->codeAppendf("highp float d3 = dot(delta3, (firstSample - %s).yx) * 2.0;",
                                    v3.fsIn());
             fsBuilder->codeAppend("highp float dmax = max(d1, max(d2, d3));");
             fsBuilder->codeAppendf("pls.windings[0] += (dmax <= 0.0) ? %s : 0;", windings.fsIn());
             // for subsequent samples, we don't recalculate the entire dot product -- just adjust it
             // to the value it would have if we did recompute it.
             fsBuilder->codeAppend("d1 += delta1.x;");
             fsBuilder->codeAppend("d2 += delta2.x;");
             fsBuilder->codeAppend("d3 += delta3.x;");
             fsBuilder->codeAppend("dmax = max(d1, max(d2, d3));");
             fsBuilder->codeAppendf("pls.windings[1] += (dmax <= 0.0) ? %s : 0;", windings.fsIn());
@@ skipping 40 matching lines @@
 
     virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override {
         return new GLSLProcessor(*this);
     }
 
 private:
     PLSAATriangleEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
         : fLocalMatrix(localMatrix)
         , fUsesLocalCoords(usesLocalCoords) {
         this->initClassID<PLSAATriangleEffect>();
-        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType, 
+        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                        kHigh_GrSLPrecision));
-        fInVertex1 = &this->addVertexAttrib(Attribute("inVertex1", kVec2f_GrVertexAttribType, 
+        fInVertex1 = &this->addVertexAttrib(Attribute("inVertex1", kVec2f_GrVertexAttribType,
                                                       kHigh_GrSLPrecision));
-        fInVertex2 = &this->addVertexAttrib(Attribute("inVertex2", kVec2f_GrVertexAttribType, 
+        fInVertex2 = &this->addVertexAttrib(Attribute("inVertex2", kVec2f_GrVertexAttribType,
                                                       kHigh_GrSLPrecision));
-        fInVertex3 = &this->addVertexAttrib(Attribute("inVertex3", kVec2f_GrVertexAttribType, 
+        fInVertex3 = &this->addVertexAttrib(Attribute("inVertex3", kVec2f_GrVertexAttribType,
                                                       kHigh_GrSLPrecision));
-        fInWindings = &this->addVertexAttrib(Attribute("inWindings", kInt_GrVertexAttribType, 
+        fInWindings = &this->addVertexAttrib(Attribute("inWindings", kInt_GrVertexAttribType,
                                                        kLow_GrSLPrecision));
         this->setWillReadFragmentPosition();
     }
 
     const Attribute* fInPosition;
     const Attribute* fInVertex1;
     const Attribute* fInVertex2;
     const Attribute* fInVertex3;
     const Attribute* fInWindings;
     SkMatrix         fLocalMatrix;
     bool             fUsesLocalCoords;
-    
+
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
  * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
  * two components of the vertex attribute. Coverage is based on signed
@@ skipping 36 matching lines @@
 
             // emit attributes
             varyingHandler->emitAttributes(qe);
 
             GrGLSLVertToFrag uv(kVec2f_GrSLType);
             varyingHandler->addVarying("uv", &uv, kHigh_GrSLPrecision);
             vsBuilder->codeAppendf("%s = %s;", uv.vsOut(), qe.inUV()->fName);
 
             GrGLSLVertToFrag ep1(kVec2f_GrSLType);
             varyingHandler->addVarying("endpoint1", &ep1, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", ep1.vsOut(), 
+            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", ep1.vsOut(),
                                   qe.inEndpoint1()->fName, qe.inEndpoint1()->fName);
 
             GrGLSLVertToFrag ep2(kVec2f_GrSLType);
             varyingHandler->addVarying("endpoint2", &ep2, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", ep2.vsOut(), 
+            vsBuilder->codeAppendf("%s = vec2(%s.x, %s.y);", ep2.vsOut(),
                                   qe.inEndpoint2()->fName, qe.inEndpoint2()->fName);
 
             GrGLSLVertToFrag delta(kVec2f_GrSLType);
             varyingHandler->addVarying("delta", &delta, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;", 
-                                   delta.vsOut(), ep1.vsOut(), ep2.vsOut(), ep2.vsOut(), 
+            vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
+                                   delta.vsOut(), ep1.vsOut(), ep2.vsOut(), ep2.vsOut(),
                                    ep1.vsOut());
 
             GrGLSLVertToFrag windings(kInt_GrSLType);
             varyingHandler->addFlatVarying("windings", &windings, kLow_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;", 
+            vsBuilder->codeAppendf("%s = %s;",
                                    windings.vsOut(), qe.inWindings()->fName);
 
             // Setup position
             this->setupPosition(vsBuilder, gpArgs, qe.inPosition()->fName);
 
             // emit transforms
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar, 
-                                 qe.inPosition()->fName, qe.localMatrix(), args.fTransformsIn, 
+            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
+                                 qe.inPosition()->fName, qe.localMatrix(), args.fTransformsIn,
                                  args.fTransformsOut);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
             SkAssertResult(fsBuilder->enableFeature(
                            GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLSLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             static const int QUAD_ARGS = 2;
             GrGLSLShaderVar inQuadArgs[QUAD_ARGS] = {
                 GrGLSLShaderVar("dot", kFloat_GrSLType, 0, kHigh_GrSLPrecision),
                 GrGLSLShaderVar("uv", kVec2f_GrSLType, 0, kHigh_GrSLPrecision)
             };
             SkString inQuadName;
 
             const char* inQuadCode = "if (uv.x * uv.x <= uv.y) {"
                                      "return dot >= 0.0;"
                                      "} else {"
                                      "return false;"
                                      "}";
-            fsBuilder->emitFunction(kBool_GrSLType, "in_quad", QUAD_ARGS, inQuadArgs, inQuadCode, 
+            fsBuilder->emitFunction(kBool_GrSLType, "in_quad", QUAD_ARGS, inQuadArgs, inQuadCode,
                                     &inQuadName);
             fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
             // keep the derivative instructions outside the conditional
             fsBuilder->codeAppendf("highp vec2 uvdX = dFdx(%s);", uv.fsIn());
             fsBuilder->codeAppendf("highp vec2 uvdY = dFdy(%s);", uv.fsIn());
             fsBuilder->codeAppend("highp vec2 uvIncX = uvdX * 0.45 + uvdY * -0.1;");
             fsBuilder->codeAppend("highp vec2 uvIncY = uvdX * 0.1 + uvdY * 0.55;");
-            fsBuilder->codeAppendf("highp vec2 uv = %s.xy - uvdX * 0.35 - uvdY * 0.25;", 
+            fsBuilder->codeAppendf("highp vec2 uv = %s.xy - uvdX * 0.35 - uvdY * 0.25;",
                                    uv.fsIn());
             fsBuilder->codeAppendf("highp vec2 firstSample = %s.xy - vec2(0.25);",
                                    fsBuilder->fragmentPosition());
-            fsBuilder->codeAppendf("highp float d = dot(%s, (firstSample - %s).yx) * 2.0;", 
+            fsBuilder->codeAppendf("highp float d = dot(%s, (firstSample - %s).yx) * 2.0;",
                                    delta.fsIn(), ep1.fsIn());
-            fsBuilder->codeAppendf("pls.windings[0] += %s(d, uv) ? %s : 0;", inQuadName.c_str(), 
+            fsBuilder->codeAppendf("pls.windings[0] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
                                    windings.fsIn());
             fsBuilder->codeAppend("uv += uvIncX;");
             fsBuilder->codeAppendf("d += %s.x;", delta.fsIn());
-            fsBuilder->codeAppendf("pls.windings[1] += %s(d, uv) ? %s : 0;", inQuadName.c_str(), 
+            fsBuilder->codeAppendf("pls.windings[1] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
                                    windings.fsIn());
             fsBuilder->codeAppend("uv += uvIncY;");
             fsBuilder->codeAppendf("d += %s.y;", delta.fsIn());
-            fsBuilder->codeAppendf("pls.windings[2] += %s(d, uv) ? %s : 0;", inQuadName.c_str(), 
+            fsBuilder->codeAppendf("pls.windings[2] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
                                    windings.fsIn());
             fsBuilder->codeAppend("uv -= uvIncX;");
             fsBuilder->codeAppendf("d -= %s.x;", delta.fsIn());
-            fsBuilder->codeAppendf("pls.windings[3] += %s(d, uv) ? %s : 0;", inQuadName.c_str(), 
+            fsBuilder->codeAppendf("pls.windings[3] += %s(d, uv) ? %s : 0;", inQuadName.c_str(),
                                    windings.fsIn());
         }
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrGLSLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const PLSQuadEdgeEffect& qee = gp.cast<PLSQuadEdgeEffect>();
             uint32_t key = 0;
             key |= qee.usesLocalCoords() && qee.localMatrix().hasPerspective() ? 0x1 : 0x0;
             b->add32(key);
@@ skipping 21 matching lines @@
 
     virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override {
         return new GLSLProcessor(*this);
     }
 
 private:
     PLSQuadEdgeEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
         : fLocalMatrix(localMatrix)
         , fUsesLocalCoords(usesLocalCoords) {
         this->initClassID<PLSQuadEdgeEffect>();
-        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType, 
+        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                        kHigh_GrSLPrecision));
-        fInUV = &this->addVertexAttrib(Attribute("inUV", kVec2f_GrVertexAttribType, 
+        fInUV = &this->addVertexAttrib(Attribute("inUV", kVec2f_GrVertexAttribType,
                                                  kHigh_GrSLPrecision));
-        fInEndpoint1 = &this->addVertexAttrib(Attribute("inEndpoint1", kVec2f_GrVertexAttribType, 
+        fInEndpoint1 = &this->addVertexAttrib(Attribute("inEndpoint1", kVec2f_GrVertexAttribType,
                                                         kHigh_GrSLPrecision));
-        fInEndpoint2 = &this->addVertexAttrib(Attribute("inEndpoint2", kVec2f_GrVertexAttribType, 
+        fInEndpoint2 = &this->addVertexAttrib(Attribute("inEndpoint2", kVec2f_GrVertexAttribType,
                                                         kHigh_GrSLPrecision));
-        fInWindings  = &this->addVertexAttrib(Attribute("inWindings", kInt_GrVertexAttribType, 
+        fInWindings  = &this->addVertexAttrib(Attribute("inWindings", kInt_GrVertexAttribType,
                                                         kLow_GrSLPrecision));
         this->setWillReadFragmentPosition();
     }
 
     const Attribute* fInPosition;
     const Attribute* fInUV;
     const Attribute* fInEndpoint1;
     const Attribute* fInEndpoint2;
     const Attribute* fInWindings;
     SkMatrix         fLocalMatrix;
     bool             fUsesLocalCoords;
-    
+
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 class PLSFinishEffect : public GrGeometryProcessor {
 public:
 
     static GrGeometryProcessor* Create(GrColor color, bool useEvenOdd, const SkMatrix& localMatrix,
                                        bool usesLocalCoords) {
         return new PLSFinishEffect(color, useEvenOdd, localMatrix, usesLocalCoords);
     }
 
     virtual ~PLSFinishEffect() {}
 
     const char* name() const override { return "PLSFinish"; }
 
     const Attribute* inPosition() const { return fInPosition; }
     GrColor color() const { return fColor; }
     bool colorIgnored() const { return GrColor_ILLEGAL == fColor; }
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
     bool usesLocalCoords() const { return fUsesLocalCoords; }
-    
-    GrPixelLocalStorageState getPixelLocalStorageState() const override { 
+
+    GrPixelLocalStorageState getPixelLocalStorageState() const override {
         return GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState;
     }
 
     const char* getDestColorOverride() const override {
-        return GR_GL_PLS_DSTCOLOR_NAME; 
+        return GR_GL_PLS_DSTCOLOR_NAME;
     }
 
     class GLSLProcessor : public GrGLSLGeometryProcessor {
     public:
         GLSLProcessor(const GrGeometryProcessor&) {}
 
         void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
             const PLSFinishEffect& fe = args.fGP.cast<PLSFinishEffect>();
             GrGLSLVertexBuilder* vsBuilder = args.fVertBuilder;
             GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             fUseEvenOdd = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                    kFloat_GrSLType, kLow_GrSLPrecision, 
+                                                    kFloat_GrSLType, kLow_GrSLPrecision,
                                                     "useEvenOdd");
             const char* useEvenOdd = uniformHandler->getUniformCStr(fUseEvenOdd);
 
             varyingHandler->emitAttributes(fe);
             this->setupPosition(vsBuilder, gpArgs, fe.inPosition()->fName);
-            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar, 
-                                 fe.inPosition()->fName, fe.localMatrix(), args.fTransformsIn, 
+            this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
+                                 fe.inPosition()->fName, fe.localMatrix(), args.fTransformsIn,
                                  args.fTransformsOut);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
             SkAssertResult(fsBuilder->enableFeature(
                            GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
             fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
             fsBuilder->codeAppend("float coverage;");
             fsBuilder->codeAppendf("if (%s != 0.0) {", useEvenOdd);
             fsBuilder->codeAppend("coverage = float(abs(pls.windings[0]) % 2) * 0.25;");
             fsBuilder->codeAppend("coverage += float(abs(pls.windings[1]) % 2) * 0.25;");
             fsBuilder->codeAppend("coverage += float(abs(pls.windings[2]) % 2) * 0.25;");
             fsBuilder->codeAppend("coverage += float(abs(pls.windings[3]) % 2) * 0.25;");
             fsBuilder->codeAppend("} else {");
             fsBuilder->codeAppend("coverage = pls.windings[0] != 0 ? 0.25 : 0.0;");
             fsBuilder->codeAppend("coverage += pls.windings[1] != 0 ? 0.25 : 0.0;");
             fsBuilder->codeAppend("coverage += pls.windings[2] != 0 ? 0.25 : 0.0;");
             fsBuilder->codeAppend("coverage += pls.windings[3] != 0 ? 0.25 : 0.0;");
             fsBuilder->codeAppend("}");
             if (!fe.colorIgnored()) {
-                this->setupUniformColor(fsBuilder, uniformHandler, args.fOutputColor, 
+                this->setupUniformColor(fsBuilder, uniformHandler, args.fOutputColor,
                                         &fColorUniform);
             }
             fsBuilder->codeAppendf("%s = vec4(coverage);", args.fOutputCoverage);
             fsBuilder->codeAppendf("%s = vec4(1.0, 0.0, 1.0, 1.0);", args.fOutputColor);
         }
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrGLSLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const PLSFinishEffect& fe = gp.cast<PLSFinishEffect>();
@@ skipping 32 matching lines @@
     virtual void getGLSLProcessorKey(const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override {
         GLSLProcessor::GenKey(*this, caps, b);
     }
 
     virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override {
         return new GLSLProcessor(*this);
     }
 
 private:
-    PLSFinishEffect(GrColor color, bool useEvenOdd, const SkMatrix& localMatrix, 
+    PLSFinishEffect(GrColor color, bool useEvenOdd, const SkMatrix& localMatrix,
                     bool usesLocalCoords)
         : fColor(color)
         , fUseEvenOdd(useEvenOdd)
         , fLocalMatrix(localMatrix)
         , fUsesLocalCoords(usesLocalCoords) {
         this->initClassID<PLSFinishEffect>();
-        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType, 
+        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                        kHigh_GrSLPrecision));
     }
 
     const Attribute* fInPosition;
     GrColor          fColor;
     bool             fUseEvenOdd;
     SkMatrix         fLocalMatrix;
     bool             fUsesLocalCoords;
 
     typedef GrGeometryProcessor INHERITED;
@@ skipping 17 matching lines @@
         SkMatrix fViewMatrix;
         SkPath fPath;
     };
 
     static GrDrawBatch* Create(const Geometry& geometry) {
         return new PLSPathBatch(geometry);
     }
 
     const char* name() const override { return "PLSBatch"; }
 
-    void computePipelineOptimizations(GrInitInvariantOutput* color, 
+    void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
         overrides->fUsePLSDstRead = true;
     }
 
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any color overrides
@@ skipping 93 matching lines @@
                 for (int i = 0; i < quadVertices.count(); ++i) {
                     quadVerts[i] = quadVertices[i];
                 }
                 mesh.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex,
                           quadVertices.count());
                 target->initDraw(quadProcessor);
                 target->draw(mesh);
             }
 
             SkAutoTUnref<GrGeometryProcessor> finishProcessor(
-                    PLSFinishEffect::Create(this->color(), 
-                                            pathPtr->getFillType() == 
+                    PLSFinishEffect::Create(this->color(),
+                                            pathPtr->getFillType() ==
                                                                 SkPath::FillType::kEvenOdd_FillType,
-                                            invert, 
+                                            invert,
                                             this->usesLocalCoords()));
             const GrBuffer* rectVertexBuffer;
             size_t finishStride = finishProcessor->getVertexStride();
             int firstRectVertex;
             static const int kRectVertexCount = 6;
             SkPoint* rectVerts = reinterpret_cast<SkPoint*>(target->makeVertexSpace(
                     finishStride, kRectVertexCount, &rectVertexBuffer, &firstRectVertex));
             if (!rectVerts) {
                 SkDebugf("Could not allocate vertices\n");
                 return;
@@ skipping 74 matching lines @@
 DRAW_BATCH_TEST_DEFINE(PLSPathBatch) {
     PLSPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return PLSPathBatch::Create(geometry);
 }
 
 #endif