diff --git a/src/gpu/effects/GrAARectEffect.cpp b/src/gpu/effects/GrAARectEffect.cpp
index 21d621d..649bb7c 100644
--- a/src/gpu/effects/GrAARectEffect.cpp
+++ b/src/gpu/effects/GrAARectEffect.cpp
@@ -20,13 +20,13 @@
     GrGLSLAARectEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrAARectEffect&    _outer      = args.fFp.cast<GrAARectEffect>();
+        const GrAARectEffect& _outer = args.fFp.cast<GrAARectEffect>();
         (void)_outer;
         auto edgeType = _outer.edgeType();
         (void)edgeType;
         auto rect = _outer.rect();
         (void)rect;
-        prevRect        = float4(-1.0);
+        prevRect = float4(-1.0);
         fRectUniformVar = args.fUniformHandler->addUniform(
                 kFragment_GrShaderFlag, kFloat4_GrSLType, "rectUniform");
         fragBuilder->codeAppendf(
@@ -59,9 +59,9 @@
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
-        const GrAARectEffect& _outer   = _proc.cast<GrAARectEffect>();
-        auto                  edgeType = _outer.edgeType();
+                   const GrFragmentProcessor& _proc) override {
+        const GrAARectEffect& _outer = _proc.cast<GrAARectEffect>();
+        auto edgeType = _outer.edgeType();
         (void)edgeType;
         auto rect = _outer.rect();
         (void)rect;
@@ -74,23 +74,21 @@
             prevRect = newRect;
         }
     }
-    SkRect        prevRect = float4(0);
+    SkRect prevRect = float4(0);
     UniformHandle fRectUniformVar;
 };
 GrGLSLFragmentProcessor* GrAARectEffect::onCreateGLSLInstance() const {
     return new GrGLSLAARectEffect();
 }
-void GrAARectEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrAARectEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                            GrProcessorKeyBuilder* b) const {
     b->add32((int32_t)fEdgeType);
 }
 bool GrAARectEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrAARectEffect& that = other.cast<GrAARectEffect>();
     (void)that;
-    if (fEdgeType != that.fEdgeType)
-        return false;
-    if (fRect != that.fRect)
-        return false;
+    if (fEdgeType != that.fEdgeType) return false;
+    if (fRect != that.fRect) return false;
     return true;
 }
 GrAARectEffect::GrAARectEffect(const GrAARectEffect& src)
@@ -103,7 +101,7 @@
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrAARectEffect);
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrAARectEffect::TestCreate(GrProcessorTestData* d) {
-    SkRect                               rect = SkRect::MakeLTRB(d->fRandom->nextSScalar1(),
+    SkRect rect = SkRect::MakeLTRB(d->fRandom->nextSScalar1(),
                                    d->fRandom->nextSScalar1(),
                                    d->fRandom->nextSScalar1(),
                                    d->fRandom->nextSScalar1());
diff --git a/src/gpu/effects/GrAARectEffect.h b/src/gpu/effects/GrAARectEffect.h
index b7d47b8..94974e2 100644
--- a/src/gpu/effects/GrAARectEffect.h
+++ b/src/gpu/effects/GrAARectEffect.h
@@ -15,14 +15,14 @@
 #include "GrCoordTransform.h"
 class GrAARectEffect : public GrFragmentProcessor {
 public:
-    const GrClipEdgeType&                       edgeType() const { return fEdgeType; }
-    const SkRect&                               rect() const { return fRect; }
+    const GrClipEdgeType& edgeType() const { return fEdgeType; }
+    const SkRect& rect() const { return fRect; }
     static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType edgeType, SkRect rect) {
         return std::unique_ptr<GrFragmentProcessor>(new GrAARectEffect(edgeType, rect));
     }
     GrAARectEffect(const GrAARectEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "AARectEffect"; }
+    const char* name() const override { return "AARectEffect"; }
 
 private:
     GrAARectEffect(GrClipEdgeType edgeType, SkRect rect)
@@ -34,8 +34,8 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    GrClipEdgeType              fEdgeType;
-    SkRect                      fRect;
+    GrClipEdgeType fEdgeType;
+    SkRect fRect;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrAlphaThresholdFragmentProcessor.cpp b/src/gpu/effects/GrAlphaThresholdFragmentProcessor.cpp
index 3daa736..a60afd2 100644
--- a/src/gpu/effects/GrAlphaThresholdFragmentProcessor.cpp
+++ b/src/gpu/effects/GrAlphaThresholdFragmentProcessor.cpp
@@ -29,7 +29,7 @@
 public:
     GrGLSLAlphaThresholdFragmentProcessor() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*                 fragBuilder = args.fFragBuilder;
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
         const GrAlphaThresholdFragmentProcessor& _outer =
                 args.fFp.cast<GrAlphaThresholdFragmentProcessor>();
         (void)_outer;
@@ -37,10 +37,10 @@
         (void)innerThreshold;
         auto outerThreshold = _outer.outerThreshold();
         (void)outerThreshold;
-        fInnerThresholdVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, "innerThreshold");
-        fOuterThresholdVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, "outerThreshold");
+        fInnerThresholdVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                              kHalf_GrSLType, "innerThreshold");
+        fOuterThresholdVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                              kHalf_GrSLType, "outerThreshold");
         SkString sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
         fragBuilder->codeAppendf(
                 "half4 color = %s;\nhalf4 mask_color = texture(%s, %s).%s;\nif (mask_color.w < "
@@ -57,13 +57,12 @@
                 args.fUniformHandler->getUniformCStr(fOuterThresholdVar),
                 args.fUniformHandler->getUniformCStr(fInnerThresholdVar),
                 args.fUniformHandler->getUniformCStr(fInnerThresholdVar),
-                args.fUniformHandler->getUniformCStr(fInnerThresholdVar),
-                args.fOutputColor);
+                args.fUniformHandler->getUniformCStr(fInnerThresholdVar), args.fOutputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrAlphaThresholdFragmentProcessor& _outer =
                 _proc.cast<GrAlphaThresholdFragmentProcessor>();
         {
@@ -77,17 +76,14 @@
 GrGLSLFragmentProcessor* GrAlphaThresholdFragmentProcessor::onCreateGLSLInstance() const {
     return new GrGLSLAlphaThresholdFragmentProcessor();
 }
-void GrAlphaThresholdFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrAlphaThresholdFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                               GrProcessorKeyBuilder* b) const {}
 bool GrAlphaThresholdFragmentProcessor::onIsEqual(const GrFragmentProcessor& other) const {
     const GrAlphaThresholdFragmentProcessor& that = other.cast<GrAlphaThresholdFragmentProcessor>();
     (void)that;
-    if (fMask != that.fMask)
-        return false;
-    if (fInnerThreshold != that.fInnerThreshold)
-        return false;
-    if (fOuterThreshold != that.fOuterThreshold)
-        return false;
+    if (fMask != that.fMask) return false;
+    if (fInnerThreshold != that.fInnerThreshold) return false;
+    if (fOuterThreshold != that.fOuterThreshold) return false;
     return true;
 }
 GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
@@ -113,16 +109,16 @@
         GrProcessorTestData* testData) {
     sk_sp<GrTextureProxy> maskProxy = testData->textureProxy(GrProcessorUnitTest::kAlphaTextureIdx);
     // Make the inner and outer thresholds be in (0, 1) exclusive and be sorted correctly.
-    float     innerThresh = testData->fRandom->nextUScalar1() * .99f + 0.005f;
-    float     outerThresh = testData->fRandom->nextUScalar1() * .99f + 0.005f;
-    const int kMaxWidth   = 1000;
-    const int kMaxHeight  = 1000;
-    uint32_t  width       = testData->fRandom->nextULessThan(kMaxWidth);
-    uint32_t  height      = testData->fRandom->nextULessThan(kMaxHeight);
-    uint32_t  x           = testData->fRandom->nextULessThan(kMaxWidth - width);
-    uint32_t  y           = testData->fRandom->nextULessThan(kMaxHeight - height);
-    SkIRect   bounds      = SkIRect::MakeXYWH(x, y, width, height);
-    return GrAlphaThresholdFragmentProcessor::Make(
-            std::move(maskProxy), innerThresh, outerThresh, bounds);
+    float innerThresh = testData->fRandom->nextUScalar1() * .99f + 0.005f;
+    float outerThresh = testData->fRandom->nextUScalar1() * .99f + 0.005f;
+    const int kMaxWidth = 1000;
+    const int kMaxHeight = 1000;
+    uint32_t width = testData->fRandom->nextULessThan(kMaxWidth);
+    uint32_t height = testData->fRandom->nextULessThan(kMaxHeight);
+    uint32_t x = testData->fRandom->nextULessThan(kMaxWidth - width);
+    uint32_t y = testData->fRandom->nextULessThan(kMaxHeight - height);
+    SkIRect bounds = SkIRect::MakeXYWH(x, y, width, height);
+    return GrAlphaThresholdFragmentProcessor::Make(std::move(maskProxy), innerThresh, outerThresh,
+                                                   bounds);
 }
 #endif
diff --git a/src/gpu/effects/GrAlphaThresholdFragmentProcessor.h b/src/gpu/effects/GrAlphaThresholdFragmentProcessor.h
index fdb6627..74811d3 100644
--- a/src/gpu/effects/GrAlphaThresholdFragmentProcessor.h
+++ b/src/gpu/effects/GrAlphaThresholdFragmentProcessor.h
@@ -16,13 +16,13 @@
 class GrAlphaThresholdFragmentProcessor : public GrFragmentProcessor {
 public:
     inline OptimizationFlags optFlags(float outerThreshold);
-    float                    innerThreshold() const { return fInnerThreshold; }
-    float                    outerThreshold() const { return fOuterThreshold; }
+    float innerThreshold() const { return fInnerThreshold; }
+    float outerThreshold() const { return fOuterThreshold; }
 
     static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> mask,
-                                                     float                 innerThreshold,
-                                                     float                 outerThreshold,
-                                                     const SkIRect&        bounds) {
+                                                     float innerThreshold,
+                                                     float outerThreshold,
+                                                     const SkIRect& bounds) {
         return std::unique_ptr<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
                 mask, innerThreshold, outerThreshold, bounds));
     }
@@ -31,10 +31,8 @@
     const char* name() const override { return "AlphaThresholdFragmentProcessor"; }
 
 private:
-    GrAlphaThresholdFragmentProcessor(sk_sp<GrTextureProxy> mask,
-                                      float                 innerThreshold,
-                                      float                 outerThreshold,
-                                      const SkIRect&        bounds)
+    GrAlphaThresholdFragmentProcessor(sk_sp<GrTextureProxy> mask, float innerThreshold,
+                                      float outerThreshold, const SkIRect& bounds)
             : INHERITED(kGrAlphaThresholdFragmentProcessor_ClassID, kNone_OptimizationFlags)
             , fMask(std::move(mask))
             , fInnerThreshold(innerThreshold)
@@ -50,10 +48,10 @@
     bool onIsEqual(const GrFragmentProcessor&) const override;
     const TextureSampler& onTextureSampler(int) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    TextureSampler              fMask;
-    float                       fInnerThreshold;
-    float                       fOuterThreshold;
-    GrCoordTransform            fMaskCoordTransform;
+    TextureSampler fMask;
+    float fInnerThreshold;
+    float fOuterThreshold;
+    GrCoordTransform fMaskCoordTransform;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
index b861cd5..6406e4e 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
@@ -19,7 +19,7 @@
 public:
     GrGLSLBlurredEdgeFragmentProcessor() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*              fragBuilder = args.fFragBuilder;
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
         const GrBlurredEdgeFragmentProcessor& _outer =
                 args.fFp.cast<GrBlurredEdgeFragmentProcessor>();
         (void)_outer;
@@ -30,27 +30,24 @@
                 "exp((-factor * factor) * 4.0) - 0.017999999999999999;\n        break;\n    case "
                 "1:\n        factor = smoothstep(1.0, 0.0, factor);\n        break;\n}\n%s = "
                 "half4(factor);\n",
-                args.fInputColor,
-                (int)_outer.mode(),
-                args.fOutputColor);
+                args.fInputColor, (int)_outer.mode(), args.fOutputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {}
+                   const GrFragmentProcessor& _proc) override {}
 };
 GrGLSLFragmentProcessor* GrBlurredEdgeFragmentProcessor::onCreateGLSLInstance() const {
     return new GrGLSLBlurredEdgeFragmentProcessor();
 }
-void GrBlurredEdgeFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrBlurredEdgeFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                            GrProcessorKeyBuilder* b) const {
     b->add32((int32_t)fMode);
 }
 bool GrBlurredEdgeFragmentProcessor::onIsEqual(const GrFragmentProcessor& other) const {
     const GrBlurredEdgeFragmentProcessor& that = other.cast<GrBlurredEdgeFragmentProcessor>();
     (void)that;
-    if (fMode != that.fMode)
-        return false;
+    if (fMode != that.fMode) return false;
     return true;
 }
 GrBlurredEdgeFragmentProcessor::GrBlurredEdgeFragmentProcessor(
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
index 44cc36d..71376d7 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
@@ -16,7 +16,7 @@
 class GrBlurredEdgeFragmentProcessor : public GrFragmentProcessor {
 public:
     enum class Mode { kGaussian = 0, kSmoothStep = 1 };
-    const Mode&                                 mode() const { return fMode; }
+    const Mode& mode() const { return fMode; }
     static std::unique_ptr<GrFragmentProcessor> Make(Mode mode) {
         return std::unique_ptr<GrFragmentProcessor>(new GrBlurredEdgeFragmentProcessor(mode));
     }
@@ -32,7 +32,7 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    Mode                        fMode;
+    Mode fMode;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrCircleBlurFragmentProcessor.cpp b/src/gpu/effects/GrCircleBlurFragmentProcessor.cpp
index 50e63f5..08a4535 100644
--- a/src/gpu/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/gpu/effects/GrCircleBlurFragmentProcessor.cpp
@@ -16,8 +16,8 @@
 // kernel values.
 static float make_unnormalized_half_kernel(float* halfKernel, int halfKernelSize, float sigma) {
     const float invSigma = 1.f / sigma;
-    const float b        = -0.5f * invSigma * invSigma;
-    float       tot      = 0.0f;
+    const float b = -0.5f * invSigma * invSigma;
+    float tot = 0.0f;
     // Compute half kernel values at half pixel steps out from the center.
     float t = 0.5f;
     for (int i = 0; i < halfKernelSize; ++i) {
@@ -31,13 +31,11 @@
 
 // Create a Gaussian half-kernel (right side) and a summed area table given a sigma and number
 // of discrete steps. The half kernel is normalized to sum to 0.5.
-static void make_half_kernel_and_summed_table(float* halfKernel,
-                                              float* summedHalfKernel,
-                                              int    halfKernelSize,
-                                              float  sigma) {
+static void make_half_kernel_and_summed_table(float* halfKernel, float* summedHalfKernel,
+                                              int halfKernelSize, float sigma) {
     // The half kernel should sum to 0.5 not 1.0.
     const float tot = 2.f * make_unnormalized_half_kernel(halfKernel, halfKernelSize, sigma);
-    float       sum = 0.f;
+    float sum = 0.f;
     for (int i = 0; i < halfKernelSize; ++i) {
         halfKernel[i] /= tot;
         sum += halfKernel[i];
@@ -47,12 +45,8 @@
 
 // Applies the 1D half kernel vertically at points along the x axis to a circle centered at the
 // origin with radius circleR.
-void apply_kernel_in_y(float*       results,
-                       int          numSteps,
-                       float        firstX,
-                       float        circleR,
-                       int          halfKernelSize,
-                       const float* summedHalfKernelTable) {
+void apply_kernel_in_y(float* results, int numSteps, float firstX, float circleR,
+                       int halfKernelSize, const float* summedHalfKernelTable) {
     float x = firstX;
     for (int i = 0; i < numSteps; ++i, x += 1.f) {
         if (x < -circleR || x > circleR) {
@@ -71,7 +65,7 @@
             results[i] = 0.5f;
         } else {
             float yFrac = y - yInt;
-            results[i]  = (1.f - yFrac) * summedHalfKernelTable[yInt] +
+            results[i] = (1.f - yFrac) * summedHalfKernelTable[yInt] +
                          yFrac * summedHalfKernelTable[yInt + 1];
         }
     }
@@ -81,10 +75,7 @@
 // This relies on having a half kernel computed for the Gaussian and a table of applications of
 // the half kernel in y to columns at (evalX - halfKernel, evalX - halfKernel + 1, ..., evalX +
 // halfKernel) passed in as yKernelEvaluations.
-static uint8_t eval_at(float        evalX,
-                       float        circleR,
-                       const float* halfKernel,
-                       int          halfKernelSize,
+static uint8_t eval_at(float evalX, float circleR, const float* halfKernel, int halfKernelSize,
                        const float* yKernelEvaluations) {
     float acc = 0;
 
@@ -115,10 +106,8 @@
 // the size of the profile being computed. Then for each of the n profile entries we walk out k
 // steps in each horizontal direction multiplying the corresponding y evaluation by the half
 // kernel entry and sum these values to compute the profile entry.
-static void create_circle_profile(uint8_t* weights,
-                                  float    sigma,
-                                  float    circleR,
-                                  int      profileTextureWidth) {
+static void create_circle_profile(uint8_t* weights, float sigma, float circleR,
+                                  int profileTextureWidth) {
     const int numSteps = profileTextureWidth;
 
     // The full kernel is 6 sigmas wide.
@@ -130,9 +119,9 @@
     int numYSteps = numSteps + 2 * halfKernelSize;
 
     SkAutoTArray<float> bulkAlloc(halfKernelSize + halfKernelSize + numYSteps);
-    float*              halfKernel   = bulkAlloc.get();
-    float*              summedKernel = bulkAlloc.get() + halfKernelSize;
-    float*              yEvals       = bulkAlloc.get() + 2 * halfKernelSize;
+    float* halfKernel = bulkAlloc.get();
+    float* summedKernel = bulkAlloc.get() + halfKernelSize;
+    float* yEvals = bulkAlloc.get() + 2 * halfKernelSize;
     make_half_kernel_and_summed_table(halfKernel, summedKernel, halfKernelSize, sigma);
 
     float firstX = -halfKernelSize + 0.5f;
@@ -140,7 +129,7 @@
 
     for (int i = 0; i < numSteps - 1; ++i) {
         float evalX = i + 0.5f;
-        weights[i]  = eval_at(evalX, circleR, halfKernel, halfKernelSize, yEvals + i);
+        weights[i] = eval_at(evalX, circleR, halfKernel, halfKernelSize, yEvals + i);
     }
     // Ensure the tail of the Gaussian goes to zero.
     weights[numSteps - 1] = 0;
@@ -149,14 +138,14 @@
 static void create_half_plane_profile(uint8_t* profile, int profileWidth) {
     SkASSERT(!(profileWidth & 0x1));
     // The full kernel is 6 sigmas wide.
-    float sigma          = profileWidth / 6.f;
-    int   halfKernelSize = profileWidth / 2;
+    float sigma = profileWidth / 6.f;
+    int halfKernelSize = profileWidth / 2;
 
     SkAutoTArray<float> halfKernel(halfKernelSize);
 
     // The half kernel should sum to 0.5.
     const float tot = 2.f * make_unnormalized_half_kernel(halfKernel.get(), halfKernelSize, sigma);
-    float       sum = 0.f;
+    float sum = 0.f;
     // Populate the profile from the right edge to the middle.
     for (int i = 0; i < halfKernelSize; ++i) {
         halfKernel[halfKernelSize - i - 1] /= tot;
@@ -174,10 +163,8 @@
 }
 
 static sk_sp<GrTextureProxy> create_profile_texture(GrProxyProvider* proxyProvider,
-                                                    const SkRect&    circle,
-                                                    float            sigma,
-                                                    float*           solidRadius,
-                                                    float*           textureRadius) {
+                                                    const SkRect& circle, float sigma,
+                                                    float* solidRadius, float* textureRadius) {
     float circleR = circle.width() / 2.0f;
     if (circleR < SK_ScalarNearlyZero) {
         return nullptr;
@@ -190,14 +177,14 @@
     // Guassian and the profile texture is a just a Gaussian evaluation. However, we haven't yet
     // implemented this latter optimization.
     sigmaToCircleRRatio = SkTMin(sigmaToCircleRRatio, 8.f);
-    SkFixed               sigmaToCircleRRatioFixed;
+    SkFixed sigmaToCircleRRatioFixed;
     static const SkScalar kHalfPlaneThreshold = 0.1f;
-    bool                  useHalfPlaneApprox  = false;
+    bool useHalfPlaneApprox = false;
     if (sigmaToCircleRRatio <= kHalfPlaneThreshold) {
-        useHalfPlaneApprox       = true;
+        useHalfPlaneApprox = true;
         sigmaToCircleRRatioFixed = 0;
-        *solidRadius             = circleR - 3 * sigma;
-        *textureRadius           = 6 * sigma;
+        *solidRadius = circleR - 3 * sigma;
+        *textureRadius = 6 * sigma;
     } else {
         // Convert to fixed point for the key.
         sigmaToCircleRRatioFixed = SkScalarToFixed(sigmaToCircleRRatio);
@@ -205,14 +192,14 @@
         // shave off more than we do.
         sigmaToCircleRRatioFixed &= ~0xff;
         sigmaToCircleRRatio = SkFixedToScalar(sigmaToCircleRRatioFixed);
-        sigma               = circleR * sigmaToCircleRRatio;
-        *solidRadius        = 0;
-        *textureRadius      = circleR + 3 * sigma;
+        sigma = circleR * sigmaToCircleRRatio;
+        *solidRadius = 0;
+        *textureRadius = circleR + 3 * sigma;
     }
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-    GrUniqueKey                      key;
-    GrUniqueKey::Builder             builder(&key, kDomain, 1, "1-D Circular Blur");
+    GrUniqueKey key;
+    GrUniqueKey::Builder builder(&key, kDomain, 1, "1-D Circular Blur");
     builder[0] = sigmaToCircleRRatioFixed;
     builder.finish();
 
@@ -231,15 +218,15 @@
         } else {
             // Rescale params to the size of the texture we're creating.
             SkScalar scale = kProfileTextureWidth / *textureRadius;
-            create_circle_profile(
-                    bm.getAddr8(0, 0), sigma * scale, circleR * scale, kProfileTextureWidth);
+            create_circle_profile(bm.getAddr8(0, 0), sigma * scale, circleR * scale,
+                                  kProfileTextureWidth);
         }
 
         bm.setImmutable();
         sk_sp<SkImage> image = SkImage::MakeFromBitmap(bm);
 
-        blurProfile = proxyProvider->createTextureProxy(
-                std::move(image), kNone_GrSurfaceFlags, 1, SkBudgeted::kYes, SkBackingFit::kExact);
+        blurProfile = proxyProvider->createTextureProxy(std::move(image), kNone_GrSurfaceFlags, 1,
+                                                        SkBudgeted::kYes, SkBackingFit::kExact);
         if (!blurProfile) {
             return nullptr;
         }
@@ -252,11 +239,9 @@
 }
 
 std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(
-        GrProxyProvider* proxyProvider,
-        const SkRect&    circle,
-        float            sigma) {
-    float                 solidRadius;
-    float                 textureRadius;
+        GrProxyProvider* proxyProvider, const SkRect& circle, float sigma) {
+    float solidRadius;
+    float textureRadius;
     sk_sp<GrTextureProxy> profile(
             create_profile_texture(proxyProvider, circle, sigma, &solidRadius, &textureRadius));
     if (!profile) {
@@ -275,7 +260,7 @@
 public:
     GrGLSLCircleBlurFragmentProcessor() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*             fragBuilder = args.fFragBuilder;
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
         const GrCircleBlurFragmentProcessor& _outer =
                 args.fFp.cast<GrCircleBlurFragmentProcessor>();
         (void)_outer;
@@ -285,8 +270,8 @@
         (void)textureRadius;
         auto solidRadius = _outer.solidRadius();
         (void)solidRadius;
-        fCircleDataVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf4_GrSLType, "circleData");
+        fCircleDataVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+                                                          "circleData");
         fragBuilder->codeAppendf(
                 "half2 vec = half2(half((sk_FragCoord.x - float(%s.x)) * float(%s.w)), "
                 "half((sk_FragCoord.y - float(%s.y)) * float(%s.w)));\nhalf dist = length(vec) + "
@@ -296,8 +281,7 @@
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
                 args.fUniformHandler->getUniformCStr(fCircleDataVar),
-                args.fUniformHandler->getUniformCStr(fCircleDataVar),
-                args.fOutputColor,
+                args.fUniformHandler->getUniformCStr(fCircleDataVar), args.fOutputColor,
                 args.fInputColor,
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str());
@@ -305,24 +289,21 @@
 
 private:
     void onSetData(const GrGLSLProgramDataManager& data,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrCircleBlurFragmentProcessor& _outer = _proc.cast<GrCircleBlurFragmentProcessor>();
-        auto                                 circleRect = _outer.circleRect();
+        auto circleRect = _outer.circleRect();
         (void)circleRect;
         auto textureRadius = _outer.textureRadius();
         (void)textureRadius;
         auto solidRadius = _outer.solidRadius();
         (void)solidRadius;
         GrSurfaceProxy& blurProfileSamplerProxy = *_outer.textureSampler(0).proxy();
-        GrTexture&      blurProfileSampler      = *blurProfileSamplerProxy.peekTexture();
+        GrTexture& blurProfileSampler = *blurProfileSamplerProxy.peekTexture();
         (void)blurProfileSampler;
         UniformHandle& circleData = fCircleDataVar;
         (void)circleData;
 
-        data.set4f(circleData,
-                   circleRect.centerX(),
-                   circleRect.centerY(),
-                   solidRadius,
+        data.set4f(circleData, circleRect.centerX(), circleRect.centerY(), solidRadius,
                    1.f / textureRadius);
     }
     UniformHandle fCircleDataVar;
@@ -330,19 +311,15 @@
 GrGLSLFragmentProcessor* GrCircleBlurFragmentProcessor::onCreateGLSLInstance() const {
     return new GrGLSLCircleBlurFragmentProcessor();
 }
-void GrCircleBlurFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrCircleBlurFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                           GrProcessorKeyBuilder* b) const {}
 bool GrCircleBlurFragmentProcessor::onIsEqual(const GrFragmentProcessor& other) const {
     const GrCircleBlurFragmentProcessor& that = other.cast<GrCircleBlurFragmentProcessor>();
     (void)that;
-    if (fCircleRect != that.fCircleRect)
-        return false;
-    if (fTextureRadius != that.fTextureRadius)
-        return false;
-    if (fSolidRadius != that.fSolidRadius)
-        return false;
-    if (fBlurProfileSampler != that.fBlurProfileSampler)
-        return false;
+    if (fCircleRect != that.fCircleRect) return false;
+    if (fTextureRadius != that.fTextureRadius) return false;
+    if (fSolidRadius != that.fSolidRadius) return false;
+    if (fBlurProfileSampler != that.fBlurProfileSampler) return false;
     return true;
 }
 GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(
@@ -365,9 +342,9 @@
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::TestCreate(
         GrProcessorTestData* testData) {
-    SkScalar wh     = testData->fRandom->nextRangeScalar(100.f, 1000.f);
-    SkScalar sigma  = testData->fRandom->nextRangeF(1.f, 10.f);
-    SkRect   circle = SkRect::MakeWH(wh, wh);
+    SkScalar wh = testData->fRandom->nextRangeScalar(100.f, 1000.f);
+    SkScalar sigma = testData->fRandom->nextRangeF(1.f, 10.f);
+    SkRect circle = SkRect::MakeWH(wh, wh);
     return GrCircleBlurFragmentProcessor::Make(testData->proxyProvider(), circle, sigma);
 }
 #endif
diff --git a/src/gpu/effects/GrCircleBlurFragmentProcessor.h b/src/gpu/effects/GrCircleBlurFragmentProcessor.h
index 337928a..7a53b01 100644
--- a/src/gpu/effects/GrCircleBlurFragmentProcessor.h
+++ b/src/gpu/effects/GrCircleBlurFragmentProcessor.h
@@ -16,20 +16,17 @@
 class GrCircleBlurFragmentProcessor : public GrFragmentProcessor {
 public:
     const SkRect& circleRect() const { return fCircleRect; }
-    float         textureRadius() const { return fTextureRadius; }
-    float         solidRadius() const { return fSolidRadius; }
+    float textureRadius() const { return fTextureRadius; }
+    float solidRadius() const { return fSolidRadius; }
 
-    static std::unique_ptr<GrFragmentProcessor> Make(GrProxyProvider*,
-                                                     const SkRect& circle,
-                                                     float         sigma);
+    static std::unique_ptr<GrFragmentProcessor> Make(GrProxyProvider*, const SkRect& circle,
+                                                     float sigma);
     GrCircleBlurFragmentProcessor(const GrCircleBlurFragmentProcessor& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
     const char* name() const override { return "CircleBlurFragmentProcessor"; }
 
 private:
-    GrCircleBlurFragmentProcessor(SkRect                circleRect,
-                                  float                 textureRadius,
-                                  float                 solidRadius,
+    GrCircleBlurFragmentProcessor(SkRect circleRect, float textureRadius, float solidRadius,
                                   sk_sp<GrTextureProxy> blurProfileSampler)
             : INHERITED(kGrCircleBlurFragmentProcessor_ClassID,
                         (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
@@ -44,10 +41,10 @@
     bool onIsEqual(const GrFragmentProcessor&) const override;
     const TextureSampler& onTextureSampler(int) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    SkRect                      fCircleRect;
-    float                       fTextureRadius;
-    float                       fSolidRadius;
-    TextureSampler              fBlurProfileSampler;
+    SkRect fCircleRect;
+    float fTextureRadius;
+    float fSolidRadius;
+    TextureSampler fBlurProfileSampler;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrCircleEffect.cpp b/src/gpu/effects/GrCircleEffect.cpp
index d71975d..b6b05e5 100644
--- a/src/gpu/effects/GrCircleEffect.cpp
+++ b/src/gpu/effects/GrCircleEffect.cpp
@@ -20,7 +20,7 @@
     GrGLSLCircleEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrCircleEffect&    _outer      = args.fFp.cast<GrCircleEffect>();
+        const GrCircleEffect& _outer = args.fFp.cast<GrCircleEffect>();
         (void)_outer;
         auto edgeType = _outer.edgeType();
         (void)edgeType;
@@ -38,27 +38,22 @@
                 "sk_FragCoord.xy) * float(%s.w))) * float(%s.z));\n}\n@if ((%d == 1 || %d == 3) || "
                 "%d == 4) {\n    d = clamp(d, 0.0, 1.0);\n} else {\n    d = d > 0.5 ? 1.0 : "
                 "0.0;\n}\n%s = %s * d;\n",
-                prevRadius,
-                (int)_outer.edgeType(),
-                (int)_outer.edgeType(),
+                prevRadius, (int)_outer.edgeType(), (int)_outer.edgeType(),
                 args.fUniformHandler->getUniformCStr(fCircleVar),
                 args.fUniformHandler->getUniformCStr(fCircleVar),
                 args.fUniformHandler->getUniformCStr(fCircleVar),
                 args.fUniformHandler->getUniformCStr(fCircleVar),
                 args.fUniformHandler->getUniformCStr(fCircleVar),
-                args.fUniformHandler->getUniformCStr(fCircleVar),
-                (int)_outer.edgeType(),
-                (int)_outer.edgeType(),
-                (int)_outer.edgeType(),
-                args.fOutputColor,
+                args.fUniformHandler->getUniformCStr(fCircleVar), (int)_outer.edgeType(),
+                (int)_outer.edgeType(), (int)_outer.edgeType(), args.fOutputColor,
                 args.fInputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
-        const GrCircleEffect& _outer   = _proc.cast<GrCircleEffect>();
-        auto                  edgeType = _outer.edgeType();
+                   const GrFragmentProcessor& _proc) override {
+        const GrCircleEffect& _outer = _proc.cast<GrCircleEffect>();
+        auto edgeType = _outer.edgeType();
         (void)edgeType;
         auto center = _outer.center();
         (void)center;
@@ -77,32 +72,29 @@
             } else {
                 effectiveRadius += 0.5f;
             }
-            pdman.set4f(
-                    circle, center.fX, center.fY, effectiveRadius, SkScalarInvert(effectiveRadius));
+            pdman.set4f(circle, center.fX, center.fY, effectiveRadius,
+                        SkScalarInvert(effectiveRadius));
             prevCenter = center;
             prevRadius = radius;
         }
     }
-    SkPoint       prevCenter = half2(0);
-    float         prevRadius = 0;
+    SkPoint prevCenter = half2(0);
+    float prevRadius = 0;
     UniformHandle fCircleVar;
 };
 GrGLSLFragmentProcessor* GrCircleEffect::onCreateGLSLInstance() const {
     return new GrGLSLCircleEffect();
 }
-void GrCircleEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrCircleEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                            GrProcessorKeyBuilder* b) const {
     b->add32((int32_t)fEdgeType);
 }
 bool GrCircleEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrCircleEffect& that = other.cast<GrCircleEffect>();
     (void)that;
-    if (fEdgeType != that.fEdgeType)
-        return false;
-    if (fCenter != that.fCenter)
-        return false;
-    if (fRadius != that.fRadius)
-        return false;
+    if (fEdgeType != that.fEdgeType) return false;
+    if (fCenter != that.fCenter) return false;
+    if (fRadius != that.fRadius) return false;
     return true;
 }
 GrCircleEffect::GrCircleEffect(const GrCircleEffect& src)
@@ -117,9 +109,9 @@
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrCircleEffect::TestCreate(GrProcessorTestData* testData) {
     SkPoint center;
-    center.fX             = testData->fRandom->nextRangeScalar(0.f, 1000.f);
-    center.fY             = testData->fRandom->nextRangeScalar(0.f, 1000.f);
-    SkScalar       radius = testData->fRandom->nextRangeF(1.f, 1000.f);
+    center.fX = testData->fRandom->nextRangeScalar(0.f, 1000.f);
+    center.fY = testData->fRandom->nextRangeScalar(0.f, 1000.f);
+    SkScalar radius = testData->fRandom->nextRangeF(1.f, 1000.f);
     GrClipEdgeType et;
     do {
         et = (GrClipEdgeType)testData->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
diff --git a/src/gpu/effects/GrCircleEffect.h b/src/gpu/effects/GrCircleEffect.h
index cff33ab..686591a 100644
--- a/src/gpu/effects/GrCircleEffect.h
+++ b/src/gpu/effects/GrCircleEffect.h
@@ -16,12 +16,11 @@
 class GrCircleEffect : public GrFragmentProcessor {
 public:
     const GrClipEdgeType& edgeType() const { return fEdgeType; }
-    const SkPoint&        center() const { return fCenter; }
-    float                 radius() const { return fRadius; }
+    const SkPoint& center() const { return fCenter; }
+    float radius() const { return fRadius; }
 
-    static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType edgeType,
-                                                     SkPoint        center,
-                                                     float          radius) {
+    static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType edgeType, SkPoint center,
+                                                     float radius) {
         // A radius below half causes the implicit insetting done by this processor to become
         // inverted. We could handle this case by making the processor code more complicated.
         if (radius < .5f && GrProcessorEdgeTypeIsInverseFill(edgeType)) {
@@ -31,7 +30,7 @@
     }
     GrCircleEffect(const GrCircleEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "CircleEffect"; }
+    const char* name() const override { return "CircleEffect"; }
 
 private:
     GrCircleEffect(GrClipEdgeType edgeType, SkPoint center, float radius)
@@ -44,9 +43,9 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    GrClipEdgeType              fEdgeType;
-    SkPoint                     fCenter;
-    float                       fRadius;
+    GrClipEdgeType fEdgeType;
+    SkPoint fCenter;
+    float fRadius;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index b94a7b1..158ff90 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -19,8 +19,8 @@
 public:
     GrGLSLConfigConversionEffect() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*        fragBuilder = args.fFragBuilder;
-        const GrConfigConversionEffect& _outer      = args.fFp.cast<GrConfigConversionEffect>();
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrConfigConversionEffect& _outer = args.fFp.cast<GrConfigConversionEffect>();
         (void)_outer;
         auto pmConversion = _outer.pmConversion();
         (void)pmConversion;
@@ -31,34 +31,26 @@
                 "%s.xyz = floor((%s.xyz * %s.w) * 255.0 + 0.5) / 255.0;\n        break;\n    case "
                 "1:\n        %s.xyz = %s.w <= 0.0 ? half3(0.0) : floor((%s.xyz / %s.w) * 255.0 + "
                 "0.5) / 255.0;\n        break;\n}\n",
-                args.fOutputColor,
-                args.fInputColor,
-                (int)_outer.pmConversion(),
-                args.fOutputColor,
-                args.fOutputColor,
-                args.fOutputColor,
-                args.fOutputColor,
-                args.fOutputColor,
-                args.fOutputColor,
-                args.fOutputColor);
+                args.fOutputColor, args.fInputColor, (int)_outer.pmConversion(), args.fOutputColor,
+                args.fOutputColor, args.fOutputColor, args.fOutputColor, args.fOutputColor,
+                args.fOutputColor, args.fOutputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {}
+                   const GrFragmentProcessor& _proc) override {}
 };
 GrGLSLFragmentProcessor* GrConfigConversionEffect::onCreateGLSLInstance() const {
     return new GrGLSLConfigConversionEffect();
 }
-void GrConfigConversionEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrConfigConversionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                      GrProcessorKeyBuilder* b) const {
     b->add32((int32_t)fPmConversion);
 }
 bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrConfigConversionEffect& that = other.cast<GrConfigConversionEffect>();
     (void)that;
-    if (fPmConversion != that.fPmConversion)
-        return false;
+    if (fPmConversion != that.fPmConversion) return false;
     return true;
 }
 GrConfigConversionEffect::GrConfigConversionEffect(const GrConfigConversionEffect& src)
diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h
index 4906943..b182765 100644
--- a/src/gpu/effects/GrConfigConversionEffect.h
+++ b/src/gpu/effects/GrConfigConversionEffect.h
@@ -22,15 +22,15 @@
 class GrConfigConversionEffect : public GrFragmentProcessor {
 public:
     static bool TestForPreservingPMConversions(GrContext* context) {
-        static constexpr int           kSize      = 256;
-        static constexpr GrPixelConfig kConfig    = kRGBA_8888_GrPixelConfig;
-        static constexpr SkColorType   kColorType = kRGBA_8888_SkColorType;
-        const GrBackendFormat          format =
+        static constexpr int kSize = 256;
+        static constexpr GrPixelConfig kConfig = kRGBA_8888_GrPixelConfig;
+        static constexpr SkColorType kColorType = kRGBA_8888_SkColorType;
+        const GrBackendFormat format =
                 context->priv().caps()->getBackendFormatFromColorType(kColorType);
         SkAutoTMalloc<uint32_t> data(kSize * kSize * 3);
-        uint32_t*               srcData    = data.get();
-        uint32_t*               firstRead  = data.get() + kSize * kSize;
-        uint32_t*               secondRead = data.get() + 2 * kSize * kSize;
+        uint32_t* srcData = data.get();
+        uint32_t* firstRead = data.get() + kSize * kSize;
+        uint32_t* secondRead = data.get() + 2 * kSize * kSize;
 
         // Fill with every possible premultiplied A, color channel value. There will be 256-y
         // duplicate values in row y. We set r, g, and b to the same value since they are handled
@@ -38,10 +38,10 @@
         for (int y = 0; y < kSize; ++y) {
             for (int x = 0; x < kSize; ++x) {
                 uint8_t* color = reinterpret_cast<uint8_t*>(&srcData[kSize * y + x]);
-                color[3]       = y;
-                color[2]       = SkTMin(x, y);
-                color[1]       = SkTMin(x, y);
-                color[0]       = SkTMin(x, y);
+                color[3] = y;
+                color[2] = SkTMin(x, y);
+                color[1] = SkTMin(x, y);
+                color[0] = SkTMin(x, y);
             }
         }
         memset(firstRead, 0, kSize * kSize * sizeof(uint32_t));
@@ -82,9 +82,9 @@
         // from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data.
         // We then verify that two reads produced the same values.
 
-        GrPaint                              paint1;
-        GrPaint                              paint2;
-        GrPaint                              paint3;
+        GrPaint paint1;
+        GrPaint paint2;
+        GrPaint paint3;
         std::unique_ptr<GrFragmentProcessor> pmToUPM(
                 new GrConfigConversionEffect(PMConversion::kToUnpremul));
         std::unique_ptr<GrFragmentProcessor> upmToPM(
@@ -94,8 +94,8 @@
         paint1.addColorFragmentProcessor(pmToUPM->clone());
         paint1.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-        readRTC->fillRectToRect(
-                GrNoClip(), std::move(paint1), GrAA::kNo, SkMatrix::I(), kRect, kRect);
+        readRTC->fillRectToRect(GrNoClip(), std::move(paint1), GrAA::kNo, SkMatrix::I(), kRect,
+                                kRect);
         if (!readRTC->readPixels(ii, firstRead, 0, 0, 0)) {
             return false;
         }
@@ -108,15 +108,15 @@
         paint2.addColorFragmentProcessor(std::move(upmToPM));
         paint2.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-        tempRTC->fillRectToRect(
-                GrNoClip(), std::move(paint2), GrAA::kNo, SkMatrix::I(), kRect, kRect);
+        tempRTC->fillRectToRect(GrNoClip(), std::move(paint2), GrAA::kNo, SkMatrix::I(), kRect,
+                                kRect);
 
         paint3.addColorTextureProcessor(tempRTC->asTextureProxyRef(), SkMatrix::I());
         paint3.addColorFragmentProcessor(std::move(pmToUPM));
         paint3.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-        readRTC->fillRectToRect(
-                GrNoClip(), std::move(paint3), GrAA::kNo, SkMatrix::I(), kRect, kRect);
+        readRTC->fillRectToRect(GrNoClip(), std::move(paint3), GrAA::kNo, SkMatrix::I(), kRect,
+                                kRect);
 
         if (!readRTC->readPixels(ii, secondRead, 0, 0, 0)) {
             return false;
@@ -145,7 +145,7 @@
     }
     GrConfigConversionEffect(const GrConfigConversionEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "ConfigConversionEffect"; }
+    const char* name() const override { return "ConfigConversionEffect"; }
 
 private:
     GrConfigConversionEffect(PMConversion pmConversion)
@@ -155,7 +155,7 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    PMConversion                fPmConversion;
+    PMConversion fPmConversion;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
index b8daeab..ed1ab7e 100644
--- a/src/gpu/effects/GrConstColorProcessor.cpp
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -19,8 +19,8 @@
 public:
     GrGLSLConstColorProcessor() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*     fragBuilder = args.fFragBuilder;
-        const GrConstColorProcessor& _outer      = args.fFp.cast<GrConstColorProcessor>();
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrConstColorProcessor& _outer = args.fFp.cast<GrConstColorProcessor>();
         (void)_outer;
         auto color = _outer.color();
         (void)color;
@@ -32,20 +32,16 @@
                 "@switch (%d) {\n    case 0:\n        %s = %s;\n        break;\n    case 1:\n      "
                 "  %s = %s * %s;\n        break;\n    case 2:\n        %s = %s.w * %s;\n        "
                 "break;\n}\n",
-                (int)_outer.mode(),
-                args.fOutputColor,
-                args.fUniformHandler->getUniformCStr(fColorVar),
-                args.fOutputColor,
-                args.fInputColor,
-                args.fUniformHandler->getUniformCStr(fColorVar),
-                args.fOutputColor,
-                args.fInputColor,
+                (int)_outer.mode(), args.fOutputColor,
+                args.fUniformHandler->getUniformCStr(fColorVar), args.fOutputColor,
+                args.fInputColor, args.fUniformHandler->getUniformCStr(fColorVar),
+                args.fOutputColor, args.fInputColor,
                 args.fUniformHandler->getUniformCStr(fColorVar));
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrConstColorProcessor& _outer = _proc.cast<GrConstColorProcessor>();
         {
             const SkPMColor4f& colorValue = _outer.color();
@@ -55,23 +51,21 @@
             }
         }
     }
-    SkPMColor4f   fColorPrev = {SK_FloatNaN, SK_FloatNaN, SK_FloatNaN, SK_FloatNaN};
+    SkPMColor4f fColorPrev = {SK_FloatNaN, SK_FloatNaN, SK_FloatNaN, SK_FloatNaN};
     UniformHandle fColorVar;
 };
 GrGLSLFragmentProcessor* GrConstColorProcessor::onCreateGLSLInstance() const {
     return new GrGLSLConstColorProcessor();
 }
-void GrConstColorProcessor::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrConstColorProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                   GrProcessorKeyBuilder* b) const {
     b->add32((int32_t)fMode);
 }
 bool GrConstColorProcessor::onIsEqual(const GrFragmentProcessor& other) const {
     const GrConstColorProcessor& that = other.cast<GrConstColorProcessor>();
     (void)that;
-    if (fColor != that.fColor)
-        return false;
-    if (fMode != that.fMode)
-        return false;
+    if (fColor != that.fColor) return false;
+    if (fMode != that.fMode) return false;
     return true;
 }
 GrConstColorProcessor::GrConstColorProcessor(const GrConstColorProcessor& src)
@@ -85,20 +79,22 @@
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
     SkPMColor4f color;
-    int         colorPicker = d->fRandom->nextULessThan(3);
+    int colorPicker = d->fRandom->nextULessThan(3);
     switch (colorPicker) {
         case 0: {
             uint32_t a = d->fRandom->nextULessThan(0x100);
             uint32_t r = d->fRandom->nextULessThan(a + 1);
             uint32_t g = d->fRandom->nextULessThan(a + 1);
             uint32_t b = d->fRandom->nextULessThan(a + 1);
-            color      = SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(r, g, b, a));
+            color = SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(r, g, b, a));
             break;
         }
-        case 1: color = SK_PMColor4fTRANSPARENT; break;
+        case 1:
+            color = SK_PMColor4fTRANSPARENT;
+            break;
         case 2:
             uint32_t c = d->fRandom->nextULessThan(0x100);
-            color      = SkPMColor4f::FromBytes_RGBA(c | (c << 8) | (c << 16) | (c << 24));
+            color = SkPMColor4f::FromBytes_RGBA(c | (c << 8) | (c << 16) | (c << 24));
             break;
     }
     InputMode mode = static_cast<InputMode>(d->fRandom->nextULessThan(kInputModeCnt));
diff --git a/src/gpu/effects/GrConstColorProcessor.h b/src/gpu/effects/GrConstColorProcessor.h
index e692475..ca166f2 100644
--- a/src/gpu/effects/GrConstColorProcessor.h
+++ b/src/gpu/effects/GrConstColorProcessor.h
@@ -32,21 +32,24 @@
 
     SkPMColor4f constantOutputForConstantInput(const SkPMColor4f& input) const override {
         switch (fMode) {
-            case InputMode::kIgnore: return fColor;
-            case InputMode::kModulateA: return fColor * input.fA;
-            case InputMode::kModulateRGBA: return fColor * input;
+            case InputMode::kIgnore:
+                return fColor;
+            case InputMode::kModulateA:
+                return fColor * input.fA;
+            case InputMode::kModulateRGBA:
+                return fColor * input;
         }
         SK_ABORT("Unexpected mode");
         return SK_PMColor4fTRANSPARENT;
     }
-    const SkPMColor4f&                          color() const { return fColor; }
-    const InputMode&                            mode() const { return fMode; }
+    const SkPMColor4f& color() const { return fColor; }
+    const InputMode& mode() const { return fMode; }
     static std::unique_ptr<GrFragmentProcessor> Make(SkPMColor4f color, InputMode mode) {
         return std::unique_ptr<GrFragmentProcessor>(new GrConstColorProcessor(color, mode));
     }
     GrConstColorProcessor(const GrConstColorProcessor& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "ConstColorProcessor"; }
+    const char* name() const override { return "ConstColorProcessor"; }
 
 private:
     GrConstColorProcessor(SkPMColor4f color, InputMode mode)
@@ -57,8 +60,8 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    SkPMColor4f                 fColor;
-    InputMode                   fMode;
+    SkPMColor4f fColor;
+    InputMode fMode;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrEllipseEffect.cpp b/src/gpu/effects/GrEllipseEffect.cpp
index 2588a7e..b064490 100644
--- a/src/gpu/effects/GrEllipseEffect.cpp
+++ b/src/gpu/effects/GrEllipseEffect.cpp
@@ -20,7 +20,7 @@
     GrGLSLEllipseEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrEllipseEffect&   _outer      = args.fFp.cast<GrEllipseEffect>();
+        const GrEllipseEffect& _outer = args.fFp.cast<GrEllipseEffect>();
         (void)_outer;
         auto edgeType = _outer.edgeType();
         (void)edgeType;
@@ -28,13 +28,13 @@
         (void)center;
         auto radii = _outer.radii();
         (void)radii;
-        prevRadii   = float2(-1.0);
-        useScale    = !sk_Caps.floatIs32Bits;
-        fEllipseVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kFloat4_GrSLType, "ellipse");
+        prevRadii = float2(-1.0);
+        useScale = !sk_Caps.floatIs32Bits;
+        fEllipseVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType,
+                                                       "ellipse");
         if (useScale) {
-            fScaleVar = args.fUniformHandler->addUniform(
-                    kFragment_GrShaderFlag, kFloat2_GrSLType, "scale");
+            fScaleVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kFloat2_GrSLType,
+                                                         "scale");
         }
         fragBuilder->codeAppendf(
                 "float2 prevCenter;\nfloat2 prevRadii = float2(%f, %f);\nbool useScale = "
@@ -44,9 +44,7 @@
                 "= implicit * inversesqrt(grad_dot);\n@if (useScale) {\n    approx_dist *= "
                 "%s.x;\n}\nhalf alpha;\n@switch (%d) {\n    case 0:\n        alpha = approx_dist > "
                 "0.0 ? 0.0 : 1.0;\n        break;\n    case 1:\n        alph",
-                prevRadii.fX,
-                prevRadii.fY,
-                (useScale ? "true" : "false"),
+                prevRadii.fX, prevRadii.fY, (useScale ? "true" : "false"),
                 args.fUniformHandler->getUniformCStr(fEllipseVar),
                 fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) : "float2(0)",
                 args.fUniformHandler->getUniformCStr(fEllipseVar),
@@ -57,15 +55,14 @@
                 "  alpha = approx_dist > 0.0 ? 1.0 : 0.0;\n        break;\n    case 3:\n        "
                 "alpha = clamp(0.5 + half(approx_dist), 0.0, 1.0);\n        break;\n    default:\n "
                 "       discard;\n}\n%s = %s * alpha;\n",
-                args.fOutputColor,
-                args.fInputColor);
+                args.fOutputColor, args.fInputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
-        const GrEllipseEffect& _outer   = _proc.cast<GrEllipseEffect>();
-        auto                   edgeType = _outer.edgeType();
+                   const GrFragmentProcessor& _proc) override {
+        const GrEllipseEffect& _outer = _proc.cast<GrEllipseEffect>();
+        auto edgeType = _outer.edgeType();
         (void)edgeType;
         auto center = _outer.center();
         (void)center;
@@ -98,31 +95,28 @@
             }
             pdman.set4f(ellipse, center.fX, center.fY, invRXSqd, invRYSqd);
             prevCenter = center;
-            prevRadii  = radii;
+            prevRadii = radii;
         }
     }
-    SkPoint       prevCenter = float2(0);
-    SkPoint       prevRadii  = float2(0);
-    bool          useScale   = false;
+    SkPoint prevCenter = float2(0);
+    SkPoint prevRadii = float2(0);
+    bool useScale = false;
     UniformHandle fEllipseVar;
     UniformHandle fScaleVar;
 };
 GrGLSLFragmentProcessor* GrEllipseEffect::onCreateGLSLInstance() const {
     return new GrGLSLEllipseEffect();
 }
-void GrEllipseEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrEllipseEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
     b->add32((int32_t)fEdgeType);
 }
 bool GrEllipseEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrEllipseEffect& that = other.cast<GrEllipseEffect>();
     (void)that;
-    if (fEdgeType != that.fEdgeType)
-        return false;
-    if (fCenter != that.fCenter)
-        return false;
-    if (fRadii != that.fRadii)
-        return false;
+    if (fEdgeType != that.fEdgeType) return false;
+    if (fCenter != that.fCenter) return false;
+    if (fRadii != that.fRadii) return false;
     return true;
 }
 GrEllipseEffect::GrEllipseEffect(const GrEllipseEffect& src)
@@ -137,15 +131,15 @@
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrEllipseEffect::TestCreate(GrProcessorTestData* testData) {
     SkPoint center;
-    center.fX         = testData->fRandom->nextRangeScalar(0.f, 1000.f);
-    center.fY         = testData->fRandom->nextRangeScalar(0.f, 1000.f);
-    SkScalar       rx = testData->fRandom->nextRangeF(0.f, 1000.f);
-    SkScalar       ry = testData->fRandom->nextRangeF(0.f, 1000.f);
+    center.fX = testData->fRandom->nextRangeScalar(0.f, 1000.f);
+    center.fY = testData->fRandom->nextRangeScalar(0.f, 1000.f);
+    SkScalar rx = testData->fRandom->nextRangeF(0.f, 1000.f);
+    SkScalar ry = testData->fRandom->nextRangeF(0.f, 1000.f);
     GrClipEdgeType et;
     do {
         et = (GrClipEdgeType)testData->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
     } while (GrClipEdgeType::kHairlineAA == et);
-    return GrEllipseEffect::Make(
-            et, center, SkPoint::Make(rx, ry), *testData->caps()->shaderCaps());
+    return GrEllipseEffect::Make(et, center, SkPoint::Make(rx, ry),
+                                 *testData->caps()->shaderCaps());
 }
 #endif
diff --git a/src/gpu/effects/GrEllipseEffect.h b/src/gpu/effects/GrEllipseEffect.h
index 0d2da34..ca1574d 100644
--- a/src/gpu/effects/GrEllipseEffect.h
+++ b/src/gpu/effects/GrEllipseEffect.h
@@ -18,13 +18,11 @@
 class GrEllipseEffect : public GrFragmentProcessor {
 public:
     const GrClipEdgeType& edgeType() const { return fEdgeType; }
-    const SkPoint&        center() const { return fCenter; }
-    const SkPoint&        radii() const { return fRadii; }
+    const SkPoint& center() const { return fCenter; }
+    const SkPoint& radii() const { return fRadii; }
 
-    static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType      edgeType,
-                                                     SkPoint             center,
-                                                     SkPoint             radii,
-                                                     const GrShaderCaps& caps) {
+    static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType edgeType, SkPoint center,
+                                                     SkPoint radii, const GrShaderCaps& caps) {
         // Small radii produce bad results on devices without full float.
         if (!caps.floatIs32Bits() && (radii.fX < 0.5f || radii.fY < 0.5f)) {
             return nullptr;
@@ -33,7 +31,7 @@
     }
     GrEllipseEffect(const GrEllipseEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "EllipseEffect"; }
+    const char* name() const override { return "EllipseEffect"; }
 
 private:
     GrEllipseEffect(GrClipEdgeType edgeType, SkPoint center, SkPoint radii)
@@ -46,9 +44,9 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    GrClipEdgeType              fEdgeType;
-    SkPoint                     fCenter;
-    SkPoint                     fRadii;
+    GrClipEdgeType fEdgeType;
+    SkPoint fCenter;
+    SkPoint fRadii;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrLumaColorFilterEffect.cpp b/src/gpu/effects/GrLumaColorFilterEffect.cpp
index a0ab559..d0b1e1c 100644
--- a/src/gpu/effects/GrLumaColorFilterEffect.cpp
+++ b/src/gpu/effects/GrLumaColorFilterEffect.cpp
@@ -19,24 +19,23 @@
 public:
     GrGLSLLumaColorFilterEffect() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*       fragBuilder = args.fFragBuilder;
-        const GrLumaColorFilterEffect& _outer      = args.fFp.cast<GrLumaColorFilterEffect>();
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrLumaColorFilterEffect& _outer = args.fFp.cast<GrLumaColorFilterEffect>();
         (void)_outer;
         fragBuilder->codeAppendf(
                 "\nhalf luma = clamp(dot(half3(0.21260000000000001, 0.71519999999999995, 0.0722), "
                 "%s.xyz), 0.0, 1.0);\n%s = half4(0.0, 0.0, 0.0, luma);\n",
-                args.fInputColor,
-                args.fOutputColor);
+                args.fInputColor, args.fOutputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {}
+                   const GrFragmentProcessor& _proc) override {}
 };
 GrGLSLFragmentProcessor* GrLumaColorFilterEffect::onCreateGLSLInstance() const {
     return new GrGLSLLumaColorFilterEffect();
 }
-void GrLumaColorFilterEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrLumaColorFilterEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                     GrProcessorKeyBuilder* b) const {}
 bool GrLumaColorFilterEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrLumaColorFilterEffect& that = other.cast<GrLumaColorFilterEffect>();
diff --git a/src/gpu/effects/GrLumaColorFilterEffect.h b/src/gpu/effects/GrLumaColorFilterEffect.h
index d3c30af..c93f6a3 100644
--- a/src/gpu/effects/GrLumaColorFilterEffect.h
+++ b/src/gpu/effects/GrLumaColorFilterEffect.h
@@ -27,7 +27,7 @@
     }
     GrLumaColorFilterEffect(const GrLumaColorFilterEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "LumaColorFilterEffect"; }
+    const char* name() const override { return "LumaColorFilterEffect"; }
 
 private:
     GrLumaColorFilterEffect()
diff --git a/src/gpu/effects/GrMagnifierEffect.cpp b/src/gpu/effects/GrMagnifierEffect.cpp
index 26d6b2c..4bef44d 100644
--- a/src/gpu/effects/GrMagnifierEffect.cpp
+++ b/src/gpu/effects/GrMagnifierEffect.cpp
@@ -20,7 +20,7 @@
     GrGLSLMagnifierEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrMagnifierEffect& _outer      = args.fFp.cast<GrMagnifierEffect>();
+        const GrMagnifierEffect& _outer = args.fFp.cast<GrMagnifierEffect>();
         (void)_outer;
         auto bounds = _outer.bounds();
         (void)bounds;
@@ -72,7 +72,7 @@
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrMagnifierEffect& _outer = _proc.cast<GrMagnifierEffect>();
         {
             pdman.set1f(fXInvZoomVar, (_outer.xInvZoom()));
@@ -81,7 +81,7 @@
             pdman.set1f(fYInvInsetVar, (_outer.yInvInset()));
         }
         GrSurfaceProxy& srcProxy = *_outer.textureSampler(0).proxy();
-        GrTexture&      src      = *srcProxy.peekTexture();
+        GrTexture& src = *srcProxy.peekTexture();
         (void)src;
         auto bounds = _outer.bounds();
         (void)bounds;
@@ -135,25 +135,18 @@
 GrGLSLFragmentProcessor* GrMagnifierEffect::onCreateGLSLInstance() const {
     return new GrGLSLMagnifierEffect();
 }
-void GrMagnifierEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrMagnifierEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                               GrProcessorKeyBuilder* b) const {}
 bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrMagnifierEffect& that = other.cast<GrMagnifierEffect>();
     (void)that;
-    if (fSrc != that.fSrc)
-        return false;
-    if (fBounds != that.fBounds)
-        return false;
-    if (fSrcRect != that.fSrcRect)
-        return false;
-    if (fXInvZoom != that.fXInvZoom)
-        return false;
-    if (fYInvZoom != that.fYInvZoom)
-        return false;
-    if (fXInvInset != that.fXInvInset)
-        return false;
-    if (fYInvInset != that.fYInvInset)
-        return false;
+    if (fSrc != that.fSrc) return false;
+    if (fBounds != that.fBounds) return false;
+    if (fSrcRect != that.fSrcRect) return false;
+    if (fXInvZoom != that.fXInvZoom) return false;
+    if (fYInvZoom != that.fYInvZoom) return false;
+    if (fXInvInset != that.fXInvInset) return false;
+    if (fYInvInset != that.fYInvInset) return false;
     return true;
 }
 GrMagnifierEffect::GrMagnifierEffect(const GrMagnifierEffect& src)
@@ -178,16 +171,16 @@
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
-    sk_sp<GrTextureProxy> proxy      = d->textureProxy(0);
-    const int             kMaxWidth  = 200;
-    const int             kMaxHeight = 200;
-    const SkScalar        kMaxInset  = 20.0f;
-    uint32_t              width      = d->fRandom->nextULessThan(kMaxWidth);
-    uint32_t              height     = d->fRandom->nextULessThan(kMaxHeight);
-    SkScalar              inset      = d->fRandom->nextRangeScalar(1.0f, kMaxInset);
+    sk_sp<GrTextureProxy> proxy = d->textureProxy(0);
+    const int kMaxWidth = 200;
+    const int kMaxHeight = 200;
+    const SkScalar kMaxInset = 20.0f;
+    uint32_t width = d->fRandom->nextULessThan(kMaxWidth);
+    uint32_t height = d->fRandom->nextULessThan(kMaxHeight);
+    SkScalar inset = d->fRandom->nextRangeScalar(1.0f, kMaxInset);
 
-    SkIRect bounds  = SkIRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight));
-    SkRect  srcRect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
+    SkIRect bounds = SkIRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight));
+    SkRect srcRect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
 
     auto effect = GrMagnifierEffect::Make(std::move(proxy),
                                           bounds,
diff --git a/src/gpu/effects/GrMagnifierEffect.h b/src/gpu/effects/GrMagnifierEffect.h
index 4214dc9..c0c44d7 100644
--- a/src/gpu/effects/GrMagnifierEffect.h
+++ b/src/gpu/effects/GrMagnifierEffect.h
@@ -15,34 +15,25 @@
 #include "GrCoordTransform.h"
 class GrMagnifierEffect : public GrFragmentProcessor {
 public:
-    const SkIRect&                              bounds() const { return fBounds; }
-    const SkRect&                               srcRect() const { return fSrcRect; }
-    float                                       xInvZoom() const { return fXInvZoom; }
-    float                                       yInvZoom() const { return fYInvZoom; }
-    float                                       xInvInset() const { return fXInvInset; }
-    float                                       yInvInset() const { return fYInvInset; }
-    static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> src,
-                                                     SkIRect               bounds,
-                                                     SkRect                srcRect,
-                                                     float                 xInvZoom,
-                                                     float                 yInvZoom,
-                                                     float                 xInvInset,
-                                                     float                 yInvInset) {
+    const SkIRect& bounds() const { return fBounds; }
+    const SkRect& srcRect() const { return fSrcRect; }
+    float xInvZoom() const { return fXInvZoom; }
+    float yInvZoom() const { return fYInvZoom; }
+    float xInvInset() const { return fXInvInset; }
+    float yInvInset() const { return fYInvInset; }
+    static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> src, SkIRect bounds,
+                                                     SkRect srcRect, float xInvZoom, float yInvZoom,
+                                                     float xInvInset, float yInvInset) {
         return std::unique_ptr<GrFragmentProcessor>(new GrMagnifierEffect(
                 src, bounds, srcRect, xInvZoom, yInvZoom, xInvInset, yInvInset));
     }
     GrMagnifierEffect(const GrMagnifierEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "MagnifierEffect"; }
+    const char* name() const override { return "MagnifierEffect"; }
 
 private:
-    GrMagnifierEffect(sk_sp<GrTextureProxy> src,
-                      SkIRect               bounds,
-                      SkRect                srcRect,
-                      float                 xInvZoom,
-                      float                 yInvZoom,
-                      float                 xInvInset,
-                      float                 yInvInset)
+    GrMagnifierEffect(sk_sp<GrTextureProxy> src, SkIRect bounds, SkRect srcRect, float xInvZoom,
+                      float yInvZoom, float xInvInset, float yInvInset)
             : INHERITED(kGrMagnifierEffect_ClassID, kNone_OptimizationFlags)
             , fSrc(std::move(src))
             , fBounds(bounds)
@@ -60,14 +51,14 @@
     bool onIsEqual(const GrFragmentProcessor&) const override;
     const TextureSampler& onTextureSampler(int) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    TextureSampler              fSrc;
-    SkIRect                     fBounds;
-    SkRect                      fSrcRect;
-    float                       fXInvZoom;
-    float                       fYInvZoom;
-    float                       fXInvInset;
-    float                       fYInvInset;
-    GrCoordTransform            fSrcCoordTransform;
+    TextureSampler fSrc;
+    SkIRect fBounds;
+    SkRect fSrcRect;
+    float fXInvZoom;
+    float fYInvZoom;
+    float fXInvInset;
+    float fYInvInset;
+    GrCoordTransform fSrcCoordTransform;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrMixerEffect.cpp b/src/gpu/effects/GrMixerEffect.cpp
index 084cb3f..fb0e50e 100644
--- a/src/gpu/effects/GrMixerEffect.cpp
+++ b/src/gpu/effects/GrMixerEffect.cpp
@@ -20,7 +20,7 @@
     GrGLSLMixerEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrMixerEffect&     _outer      = args.fFp.cast<GrMixerEffect>();
+        const GrMixerEffect& _outer = args.fFp.cast<GrMixerEffect>();
         (void)_outer;
         auto weight = _outer.weight();
         (void)weight;
@@ -38,16 +38,14 @@
             fragBuilder->codeAppendf("half4 %s;", _child1.c_str());
         }
         fragBuilder->codeAppendf("\nhalf4 in1 = %s ? %s : %s;\n%s = mix(in0, in1, %s);\n",
-                                 _outer.fp1_index() >= 0 ? "true" : "false",
-                                 _child1.c_str(),
-                                 args.fInputColor,
-                                 args.fOutputColor,
+                                 _outer.fp1_index() >= 0 ? "true" : "false", _child1.c_str(),
+                                 args.fInputColor, args.fOutputColor,
                                  args.fUniformHandler->getUniformCStr(fWeightVar));
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrMixerEffect& _outer = _proc.cast<GrMixerEffect>();
         { pdman.set1f(fWeightVar, (_outer.weight())); }
     }
@@ -56,13 +54,12 @@
 GrGLSLFragmentProcessor* GrMixerEffect::onCreateGLSLInstance() const {
     return new GrGLSLMixerEffect();
 }
-void GrMixerEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrMixerEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                           GrProcessorKeyBuilder* b) const {}
 bool GrMixerEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrMixerEffect& that = other.cast<GrMixerEffect>();
     (void)that;
-    if (fWeight != that.fWeight)
-        return false;
+    if (fWeight != that.fWeight) return false;
     return true;
 }
 GrMixerEffect::GrMixerEffect(const GrMixerEffect& src)
diff --git a/src/gpu/effects/GrMixerEffect.h b/src/gpu/effects/GrMixerEffect.h
index 6c8ff12..16ce6fc 100644
--- a/src/gpu/effects/GrMixerEffect.h
+++ b/src/gpu/effects/GrMixerEffect.h
@@ -45,28 +45,28 @@
                    c1 = (this->numChildProcessors() > 1)
                                 ? ConstantOutputForConstantInput(this->childProcessor(1), input)
                                 : input;
-        return {c0.fR + (c1.fR - c0.fR) * fWeight,
-                c0.fG + (c1.fG - c0.fG) * fWeight,
-                c0.fB + (c1.fB - c0.fB) * fWeight,
-                c0.fA + (c1.fA - c0.fA) * fWeight};
+        return {c0.fR + (c1.fR - c0.fR) * fWeight, c0.fG + (c1.fG - c0.fG) * fWeight,
+                c0.fB + (c1.fB - c0.fB) * fWeight, c0.fA + (c1.fA - c0.fA) * fWeight};
     }
-    int                                         fp0_index() const { return fFp0_index; }
-    int                                         fp1_index() const { return fFp1_index; }
-    float                                       weight() const { return fWeight; }
+    int fp0_index() const { return fFp0_index; }
+    int fp1_index() const { return fFp1_index; }
+    float weight() const { return fWeight; }
     static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> fp0,
-                                                     std::unique_ptr<GrFragmentProcessor> fp1,
-                                                     float                                weight) {
+                                                     std::unique_ptr<GrFragmentProcessor>
+                                                             fp1,
+                                                     float weight) {
         return std::unique_ptr<GrFragmentProcessor>(
                 new GrMixerEffect(std::move(fp0), std::move(fp1), weight));
     }
     GrMixerEffect(const GrMixerEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "MixerEffect"; }
+    const char* name() const override { return "MixerEffect"; }
 
 private:
     GrMixerEffect(std::unique_ptr<GrFragmentProcessor> fp0,
-                  std::unique_ptr<GrFragmentProcessor> fp1,
-                  float                                weight)
+                  std::unique_ptr<GrFragmentProcessor>
+                          fp1,
+                  float weight)
             : INHERITED(kGrMixerEffect_ClassID, (OptimizationFlags)OptFlags(fp0, fp1))
             , fWeight(weight) {
         SkASSERT(fp0);
@@ -81,9 +81,9 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    int                         fFp0_index = -1;
-    int                         fFp1_index = -1;
-    float                       fWeight;
+    int fFp0_index = -1;
+    int fFp1_index = -1;
+    float fWeight;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrPremulInputFragmentProcessor.cpp b/src/gpu/effects/GrPremulInputFragmentProcessor.cpp
index 5d6033b..846a4f8 100644
--- a/src/gpu/effects/GrPremulInputFragmentProcessor.cpp
+++ b/src/gpu/effects/GrPremulInputFragmentProcessor.cpp
@@ -19,25 +19,22 @@
 public:
     GrGLSLPremulInputFragmentProcessor() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*              fragBuilder = args.fFragBuilder;
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
         const GrPremulInputFragmentProcessor& _outer =
                 args.fFp.cast<GrPremulInputFragmentProcessor>();
         (void)_outer;
-        fragBuilder->codeAppendf("%s = %s;\n%s.xyz *= %s.w;\n",
-                                 args.fOutputColor,
-                                 args.fInputColor,
-                                 args.fOutputColor,
-                                 args.fInputColor);
+        fragBuilder->codeAppendf("%s = %s;\n%s.xyz *= %s.w;\n", args.fOutputColor, args.fInputColor,
+                                 args.fOutputColor, args.fInputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {}
+                   const GrFragmentProcessor& _proc) override {}
 };
 GrGLSLFragmentProcessor* GrPremulInputFragmentProcessor::onCreateGLSLInstance() const {
     return new GrGLSLPremulInputFragmentProcessor();
 }
-void GrPremulInputFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrPremulInputFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                            GrProcessorKeyBuilder* b) const {}
 bool GrPremulInputFragmentProcessor::onIsEqual(const GrFragmentProcessor& other) const {
     const GrPremulInputFragmentProcessor& that = other.cast<GrPremulInputFragmentProcessor>();
diff --git a/src/gpu/effects/GrRRectBlurEffect.cpp b/src/gpu/effects/GrRRectBlurEffect.cpp
index 5bc0e10..ba9d701 100644
--- a/src/gpu/effects/GrRRectBlurEffect.cpp
+++ b/src/gpu/effects/GrRRectBlurEffect.cpp
@@ -11,10 +11,10 @@
 #include "GrRRectBlurEffect.h"
 
 std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::Make(GrRecordingContext* context,
-                                                             float               sigma,
-                                                             float               xformedSigma,
-                                                             const SkRRect&      srcRRect,
-                                                             const SkRRect&      devRRect) {
+                                                             float sigma,
+                                                             float xformedSigma,
+                                                             const SkRRect& srcRRect,
+                                                             const SkRRect& devRRect) {
     SkASSERT(!SkRRectPriv::IsCircle(devRRect) &&
              !devRRect.isRect());  // Should've been caught up-stream
 
@@ -26,26 +26,15 @@
     // Make sure we can successfully ninepatch this rrect -- the blur sigma has to be
     // sufficiently small relative to both the size of the corner radius and the
     // width (and height) of the rrect.
-    SkRRect  rrectToDraw;
-    SkISize  size;
+    SkRRect rrectToDraw;
+    SkISize size;
     SkScalar ignored[kSkBlurRRectMaxDivisions];
-    int      ignoredSize;
+    int ignoredSize;
     uint32_t ignored32;
 
-    bool ninePatchable = SkComputeBlurredRRectParams(srcRRect,
-                                                     devRRect,
-                                                     SkRect::MakeEmpty(),
-                                                     sigma,
-                                                     xformedSigma,
-                                                     &rrectToDraw,
-                                                     &size,
-                                                     ignored,
-                                                     ignored,
-                                                     ignored,
-                                                     ignored,
-                                                     &ignoredSize,
-                                                     &ignoredSize,
-                                                     &ignored32);
+    bool ninePatchable = SkComputeBlurredRRectParams(
+            srcRRect, devRRect, SkRect::MakeEmpty(), sigma, xformedSigma, &rrectToDraw, &size,
+            ignored, ignored, ignored, ignored, &ignoredSize, &ignoredSize, &ignored32);
     if (!ninePatchable) {
         return nullptr;
     }
@@ -57,10 +46,8 @@
     }
 
     return std::unique_ptr<GrFragmentProcessor>(
-            new GrRRectBlurEffect(xformedSigma,
-                                  devRRect.getBounds(),
-                                  SkRRectPriv::GetSimpleRadii(devRRect).fX,
-                                  std::move(mask)));
+            new GrRRectBlurEffect(xformedSigma, devRRect.getBounds(),
+                                  SkRRectPriv::GetSimpleRadii(devRRect).fX, std::move(mask)));
 }
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
@@ -73,7 +60,7 @@
     GrGLSLRRectBlurEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrRRectBlurEffect& _outer      = args.fFp.cast<GrRRectBlurEffect>();
+        const GrRRectBlurEffect& _outer = args.fFp.cast<GrRRectBlurEffect>();
         (void)_outer;
         auto sigma = _outer.sigma();
         (void)sigma;
@@ -81,12 +68,12 @@
         (void)rect;
         auto cornerRadius = _outer.cornerRadius();
         (void)cornerRadius;
-        fCornerRadiusVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, "cornerRadius");
-        fProxyRectVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kFloat4_GrSLType, "proxyRect");
-        fBlurRadiusVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, "blurRadius");
+        fCornerRadiusVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+                                                            "cornerRadius");
+        fProxyRectVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType,
+                                                         "proxyRect");
+        fBlurRadiusVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+                                                          "blurRadius");
         fragBuilder->codeAppendf(
                 "\nhalf2 translatedFragPos = half2(sk_FragCoord.xy - %s.xy);\nhalf threshold = %s "
                 "+ 2.0 * %s;\nhalf2 middle = half2((%s.zw - %s.xy) - float(2.0 * threshold));\nif "
@@ -105,15 +92,14 @@
                 "translatedFragPos.y -= middle.y - 1.0;\n}\nhalf2 proxyDims = half2(2.0 * "
                 "threshold + 1.0);\nhalf2 texCoord = translatedFragPos / proxyDims;\n%s = %s * "
                 "texture(%s, float2(texCoord)).%s;\n",
-                args.fOutputColor,
-                args.fInputColor,
+                args.fOutputColor, args.fInputColor,
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str());
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrRRectBlurEffect& _outer = _proc.cast<GrRRectBlurEffect>();
         { pdman.set1f(fCornerRadiusVar, (_outer.cornerRadius())); }
         auto sigma = _outer.sigma();
@@ -123,7 +109,7 @@
         UniformHandle& cornerRadius = fCornerRadiusVar;
         (void)cornerRadius;
         GrSurfaceProxy& ninePatchSamplerProxy = *_outer.textureSampler(0).proxy();
-        GrTexture&      ninePatchSampler      = *ninePatchSamplerProxy.peekTexture();
+        GrTexture& ninePatchSampler = *ninePatchSamplerProxy.peekTexture();
         (void)ninePatchSampler;
         UniformHandle& proxyRect = fProxyRectVar;
         (void)proxyRect;
@@ -144,19 +130,15 @@
 GrGLSLFragmentProcessor* GrRRectBlurEffect::onCreateGLSLInstance() const {
     return new GrGLSLRRectBlurEffect();
 }
-void GrRRectBlurEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrRRectBlurEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                               GrProcessorKeyBuilder* b) const {}
 bool GrRRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrRRectBlurEffect& that = other.cast<GrRRectBlurEffect>();
     (void)that;
-    if (fSigma != that.fSigma)
-        return false;
-    if (fRect != that.fRect)
-        return false;
-    if (fCornerRadius != that.fCornerRadius)
-        return false;
-    if (fNinePatchSampler != that.fNinePatchSampler)
-        return false;
+    if (fSigma != that.fSigma) return false;
+    if (fRect != that.fRect) return false;
+    if (fCornerRadius != that.fCornerRadius) return false;
+    if (fNinePatchSampler != that.fNinePatchSampler) return false;
     return true;
 }
 GrRRectBlurEffect::GrRRectBlurEffect(const GrRRectBlurEffect& src)
@@ -176,11 +158,11 @@
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect);
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
-    SkScalar w     = d->fRandom->nextRangeScalar(100.f, 1000.f);
-    SkScalar h     = d->fRandom->nextRangeScalar(100.f, 1000.f);
-    SkScalar r     = d->fRandom->nextRangeF(1.f, 9.f);
+    SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f);
+    SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f);
+    SkScalar r = d->fRandom->nextRangeF(1.f, 9.f);
     SkScalar sigma = d->fRandom->nextRangeF(1.f, 10.f);
-    SkRRect  rrect;
+    SkRRect rrect;
     rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
     return GrRRectBlurEffect::Make(d->context(), sigma, sigma, rrect, rrect);
 }
diff --git a/src/gpu/effects/GrRRectBlurEffect.h b/src/gpu/effects/GrRRectBlurEffect.h
index 3b83eff..e4155c4 100644
--- a/src/gpu/effects/GrRRectBlurEffect.h
+++ b/src/gpu/effects/GrRRectBlurEffect.h
@@ -30,19 +30,17 @@
 class GrRRectBlurEffect : public GrFragmentProcessor {
 public:
     static sk_sp<GrTextureProxy> find_or_create_rrect_blur_mask(GrRecordingContext* context,
-                                                                const SkRRect&      rrectToDraw,
-                                                                const SkISize&      size,
-                                                                float               xformedSigma) {
+                                                                const SkRRect& rrectToDraw,
+                                                                const SkISize& size,
+                                                                float xformedSigma) {
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-        GrUniqueKey                      key;
-        GrUniqueKey::Builder             builder(&key, kDomain, 9, "RoundRect Blur Mask");
+        GrUniqueKey key;
+        GrUniqueKey::Builder builder(&key, kDomain, 9, "RoundRect Blur Mask");
         builder[0] = SkScalarCeilToInt(xformedSigma - 1 / 6.0f);
 
         int index = 1;
-        for (auto c : {SkRRect::kUpperLeft_Corner,
-                       SkRRect::kUpperRight_Corner,
-                       SkRRect::kLowerRight_Corner,
-                       SkRRect::kLowerLeft_Corner}) {
+        for (auto c : {SkRRect::kUpperLeft_Corner, SkRRect::kUpperRight_Corner,
+                       SkRRect::kLowerRight_Corner, SkRRect::kLowerLeft_Corner}) {
             SkASSERT(SkScalarIsInt(rrectToDraw.radii(c).fX) &&
                      SkScalarIsInt(rrectToDraw.radii(c).fY));
             builder[index++] = SkScalarCeilToInt(rrectToDraw.radii(c).fX);
@@ -60,26 +58,17 @@
             // TODO: this could be approx but the texture coords will need to be updated
             sk_sp<GrRenderTargetContext> rtc(
                     context->priv().makeDeferredRenderTargetContextWithFallback(
-                            format,
-                            SkBackingFit::kExact,
-                            size.fWidth,
-                            size.fHeight,
-                            kAlpha_8_GrPixelConfig,
-                            nullptr));
+                            format, SkBackingFit::kExact, size.fWidth, size.fHeight,
+                            kAlpha_8_GrPixelConfig, nullptr));
             if (!rtc) {
                 return nullptr;
             }
 
             GrPaint paint;
 
-            rtc->clear(nullptr,
-                       SK_PMColor4fTRANSPARENT,
+            rtc->clear(nullptr, SK_PMColor4fTRANSPARENT,
                        GrRenderTargetContext::CanClearFullscreen::kYes);
-            rtc->drawRRect(GrNoClip(),
-                           std::move(paint),
-                           GrAA::kYes,
-                           SkMatrix::I(),
-                           rrectToDraw,
+            rtc->drawRRect(GrNoClip(), std::move(paint), GrAA::kYes, SkMatrix::I(), rrectToDraw,
                            GrStyle::SimpleFill());
 
             sk_sp<GrTextureProxy> srcProxy(rtc->asTextureProxyRef());
@@ -111,23 +100,21 @@
 
         return mask;
     }
-    float         sigma() const { return fSigma; }
+    float sigma() const { return fSigma; }
     const SkRect& rect() const { return fRect; }
-    float         cornerRadius() const { return fCornerRadius; }
+    float cornerRadius() const { return fCornerRadius; }
 
     static std::unique_ptr<GrFragmentProcessor> Make(GrRecordingContext* context,
-                                                     float               sigma,
-                                                     float               xformedSigma,
-                                                     const SkRRect&      srcRRect,
-                                                     const SkRRect&      devRRect);
+                                                     float sigma,
+                                                     float xformedSigma,
+                                                     const SkRRect& srcRRect,
+                                                     const SkRRect& devRRect);
     GrRRectBlurEffect(const GrRRectBlurEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "RRectBlurEffect"; }
+    const char* name() const override { return "RRectBlurEffect"; }
 
 private:
-    GrRRectBlurEffect(float                 sigma,
-                      SkRect                rect,
-                      float                 cornerRadius,
+    GrRRectBlurEffect(float sigma, SkRect rect, float cornerRadius,
                       sk_sp<GrTextureProxy> ninePatchSampler)
             : INHERITED(kGrRRectBlurEffect_ClassID,
                         (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
@@ -142,10 +129,10 @@
     bool onIsEqual(const GrFragmentProcessor&) const override;
     const TextureSampler& onTextureSampler(int) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    float                       fSigma;
-    SkRect                      fRect;
-    float                       fCornerRadius;
-    TextureSampler              fNinePatchSampler;
+    float fSigma;
+    SkRect fRect;
+    float fCornerRadius;
+    TextureSampler fNinePatchSampler;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrRectBlurEffect.cpp b/src/gpu/effects/GrRectBlurEffect.cpp
index d2c02b2..7ccaa34 100644
--- a/src/gpu/effects/GrRectBlurEffect.cpp
+++ b/src/gpu/effects/GrRectBlurEffect.cpp
@@ -20,7 +20,7 @@
     GrGLSLRectBlurEffect() {}
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        const GrRectBlurEffect&  _outer      = args.fFp.cast<GrRectBlurEffect>();
+        const GrRectBlurEffect& _outer = args.fFp.cast<GrRectBlurEffect>();
         (void)_outer;
         auto rect = _outer.rect();
         (void)rect;
@@ -34,15 +34,15 @@
         fRectVar =
                 args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType, "rect");
         if (!highPrecision) {
-            fProxyRectHalfVar = args.fUniformHandler->addUniform(
-                    kFragment_GrShaderFlag, kHalf4_GrSLType, "proxyRectHalf");
+            fProxyRectHalfVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                                 kHalf4_GrSLType, "proxyRectHalf");
         }
         if (highPrecision) {
             fProxyRectFloatVar = args.fUniformHandler->addUniform(
                     kFragment_GrShaderFlag, kFloat4_GrSLType, "proxyRectFloat");
         }
-        fProfileSizeVar = args.fUniformHandler->addUniform(
-                kFragment_GrShaderFlag, kHalf_GrSLType, "profileSize");
+        fProfileSizeVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+                                                           "profileSize");
         fragBuilder->codeAppendf(
                 "/* key */ bool highPrecision = %s;\n@if (highPrecision) {\n    float2 "
                 "translatedPos = sk_FragCoord.xy - %s.xy;\n    float width = %s.z - %s.x;\n    "
@@ -51,8 +51,7 @@
                 "1.0);\n    float2 wh = smallDims - float2(center, center);\n    half hcoord = "
                 "half((abs(translatedPos.x - 0.5 * width) - 0.5 * wh.x) / float(%s));\n    half "
                 "hlookup = texture(%s, float2(float(hcoord), 0.5)).",
-                (highPrecision ? "true" : "false"),
-                args.fUniformHandler->getUniformCStr(fRectVar),
+                (highPrecision ? "true" : "false"), args.fUniformHandler->getUniformCStr(fRectVar),
                 args.fUniformHandler->getUniformCStr(fRectVar),
                 args.fUniformHandler->getUniformCStr(fRectVar),
                 args.fUniformHandler->getUniformCStr(fRectVar),
@@ -74,9 +73,7 @@
                 args.fUniformHandler->getUniformCStr(fProfileSizeVar),
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str(),
-                args.fOutputColor,
-                args.fInputColor,
-                args.fUniformHandler->getUniformCStr(fRectVar),
+                args.fOutputColor, args.fInputColor, args.fUniformHandler->getUniformCStr(fRectVar),
                 args.fUniformHandler->getUniformCStr(fRectVar),
                 args.fUniformHandler->getUniformCStr(fRectVar),
                 args.fUniformHandler->getUniformCStr(fRectVar),
@@ -96,13 +93,12 @@
                 args.fUniformHandler->getUniformCStr(fProfileSizeVar),
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str(),
-                args.fOutputColor,
-                args.fInputColor);
+                args.fOutputColor, args.fInputColor);
     }
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {
+                   const GrFragmentProcessor& _proc) override {
         const GrRectBlurEffect& _outer = _proc.cast<GrRectBlurEffect>();
         { pdman.set4fv(fRectVar, 1, reinterpret_cast<const float*>(&(_outer.rect()))); }
         UniformHandle& rect = fRectVar;
@@ -110,7 +106,7 @@
         auto sigma = _outer.sigma();
         (void)sigma;
         GrSurfaceProxy& blurProfileProxy = *_outer.textureSampler(0).proxy();
-        GrTexture&      blurProfile      = *blurProfileProxy.peekTexture();
+        GrTexture& blurProfile = *blurProfileProxy.peekTexture();
         (void)blurProfile;
         UniformHandle& proxyRectHalf = fProxyRectHalfVar;
         (void)proxyRectHalf;
@@ -121,7 +117,7 @@
 
         pdman.set1f(profileSize, SkScalarCeilToScalar(6 * sigma));
     }
-    bool          highPrecision = false;
+    bool highPrecision = false;
     UniformHandle fProxyRectHalfVar;
     UniformHandle fProxyRectFloatVar;
     UniformHandle fProfileSizeVar;
@@ -130,17 +126,14 @@
 GrGLSLFragmentProcessor* GrRectBlurEffect::onCreateGLSLInstance() const {
     return new GrGLSLRectBlurEffect();
 }
-void GrRectBlurEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrRectBlurEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                              GrProcessorKeyBuilder* b) const {}
 bool GrRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrRectBlurEffect& that = other.cast<GrRectBlurEffect>();
     (void)that;
-    if (fRect != that.fRect)
-        return false;
-    if (fSigma != that.fSigma)
-        return false;
-    if (fBlurProfile != that.fBlurProfile)
-        return false;
+    if (fRect != that.fRect) return false;
+    if (fSigma != that.fSigma) return false;
+    if (fBlurProfile != that.fBlurProfile) return false;
     return true;
 }
 GrRectBlurEffect::GrRectBlurEffect(const GrRectBlurEffect& src)
@@ -159,12 +152,10 @@
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
 #if GR_TEST_UTILS
 std::unique_ptr<GrFragmentProcessor> GrRectBlurEffect::TestCreate(GrProcessorTestData* data) {
-    float sigma  = data->fRandom->nextRangeF(3, 8);
-    float width  = data->fRandom->nextRangeF(200, 300);
+    float sigma = data->fRandom->nextRangeF(3, 8);
+    float width = data->fRandom->nextRangeF(200, 300);
     float height = data->fRandom->nextRangeF(200, 300);
-    return GrRectBlurEffect::Make(data->proxyProvider(),
-                                  *data->caps()->shaderCaps(),
-                                  SkRect::MakeWH(width, height),
-                                  sigma);
+    return GrRectBlurEffect::Make(data->proxyProvider(), *data->caps()->shaderCaps(),
+                                  SkRect::MakeWH(width, height), sigma);
 }
 #endif
diff --git a/src/gpu/effects/GrRectBlurEffect.h b/src/gpu/effects/GrRectBlurEffect.h
index 4801b8c..017bbbe 100644
--- a/src/gpu/effects/GrRectBlurEffect.h
+++ b/src/gpu/effects/GrRectBlurEffect.h
@@ -21,12 +21,12 @@
 class GrRectBlurEffect : public GrFragmentProcessor {
 public:
     static sk_sp<GrTextureProxy> CreateBlurProfileTexture(GrProxyProvider* proxyProvider,
-                                                          float            sigma) {
+                                                          float sigma) {
         unsigned int profileSize = SkScalarCeilToInt(6 * sigma);
 
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-        GrUniqueKey                      key;
-        GrUniqueKey::Builder             builder(&key, kDomain, 1, "Rect Blur Mask");
+        GrUniqueKey key;
+        GrUniqueKey::Builder builder(&key, kDomain, 1, "Rect Blur Mask");
         builder[0] = profileSize;
         builder.finish();
 
@@ -48,11 +48,9 @@
                 return nullptr;
             }
 
-            blurProfile = proxyProvider->createTextureProxy(std::move(image),
-                                                            kNone_GrSurfaceFlags,
-                                                            1,
-                                                            SkBudgeted::kYes,
-                                                            SkBackingFit::kExact);
+            blurProfile =
+                    proxyProvider->createTextureProxy(std::move(image), kNone_GrSurfaceFlags, 1,
+                                                      SkBudgeted::kYes, SkBackingFit::kExact);
             if (!blurProfile) {
                 return nullptr;
             }
@@ -64,12 +62,11 @@
         return blurProfile;
     }
     const SkRect& rect() const { return fRect; }
-    float         sigma() const { return fSigma; }
+    float sigma() const { return fSigma; }
 
-    static std::unique_ptr<GrFragmentProcessor> Make(GrProxyProvider*    proxyProvider,
-                                                     const GrShaderCaps& caps,
-                                                     const SkRect&       rect,
-                                                     float               sigma) {
+    static std::unique_ptr<GrFragmentProcessor> Make(GrProxyProvider* proxyProvider,
+                                                     const GrShaderCaps& caps, const SkRect& rect,
+                                                     float sigma) {
         if (!caps.floatIs32Bits()) {
             // We promote the rect uniform from half to float when it has large values for
             // precision. If we don't have full float then fail.
@@ -93,20 +90,16 @@
         }
 
         return std::unique_ptr<GrFragmentProcessor>(new GrRectBlurEffect(
-                rect,
-                sigma,
-                std::move(blurProfile),
+                rect, sigma, std::move(blurProfile),
                 GrSamplerState(GrSamplerState::WrapMode::kClamp, GrSamplerState::Filter::kBilerp)));
     }
     GrRectBlurEffect(const GrRectBlurEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "RectBlurEffect"; }
+    const char* name() const override { return "RectBlurEffect"; }
 
 private:
-    GrRectBlurEffect(SkRect                rect,
-                     float                 sigma,
-                     sk_sp<GrTextureProxy> blurProfile,
-                     GrSamplerState        samplerParams)
+    GrRectBlurEffect(SkRect rect, float sigma, sk_sp<GrTextureProxy> blurProfile,
+                     GrSamplerState samplerParams)
             : INHERITED(kGrRectBlurEffect_ClassID,
                         (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fRect(rect)
@@ -119,9 +112,9 @@
     bool onIsEqual(const GrFragmentProcessor&) const override;
     const TextureSampler& onTextureSampler(int) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    SkRect                      fRect;
-    float                       fSigma;
-    TextureSampler              fBlurProfile;
+    SkRect fRect;
+    float fSigma;
+    TextureSampler fBlurProfile;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif
diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp
index c6bc47a..5b70a3e 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.cpp
+++ b/src/gpu/effects/GrSimpleTextureEffect.cpp
@@ -19,16 +19,14 @@
 public:
     GrGLSLSimpleTextureEffect() {}
     void emitCode(EmitArgs& args) override {
-        GrGLSLFPFragmentBuilder*     fragBuilder = args.fFragBuilder;
-        const GrSimpleTextureEffect& _outer      = args.fFp.cast<GrSimpleTextureEffect>();
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrSimpleTextureEffect& _outer = args.fFp.cast<GrSimpleTextureEffect>();
         (void)_outer;
         auto matrix = _outer.matrix();
         (void)matrix;
         SkString sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
         fragBuilder->codeAppendf(
-                "%s = %s * texture(%s, %s).%s;\n",
-                args.fOutputColor,
-                args.fInputColor,
+                "%s = %s * texture(%s, %s).%s;\n", args.fOutputColor, args.fInputColor,
                 fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
                 sk_TransformedCoords2D_0.c_str(),
                 fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str());
@@ -36,20 +34,18 @@
 
 private:
     void onSetData(const GrGLSLProgramDataManager& pdman,
-                   const GrFragmentProcessor&      _proc) override {}
+                   const GrFragmentProcessor& _proc) override {}
 };
 GrGLSLFragmentProcessor* GrSimpleTextureEffect::onCreateGLSLInstance() const {
     return new GrGLSLSimpleTextureEffect();
 }
-void GrSimpleTextureEffect::onGetGLSLProcessorKey(const GrShaderCaps&    caps,
+void GrSimpleTextureEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
                                                   GrProcessorKeyBuilder* b) const {}
 bool GrSimpleTextureEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrSimpleTextureEffect& that = other.cast<GrSimpleTextureEffect>();
     (void)that;
-    if (fImage != that.fImage)
-        return false;
-    if (fMatrix != that.fMatrix)
-        return false;
+    if (fImage != that.fImage) return false;
+    if (fMatrix != that.fMatrix) return false;
     return true;
 }
 GrSimpleTextureEffect::GrSimpleTextureEffect(const GrSimpleTextureEffect& src)
@@ -82,9 +78,9 @@
         wrapModes[1] = GrSamplerState::WrapMode::kClamp;
     }
 
-    GrSamplerState params(wrapModes,
-                          testData->fRandom->nextBool() ? GrSamplerState::Filter::kBilerp
-                                                        : GrSamplerState::Filter::kNearest);
+    GrSamplerState params(wrapModes, testData->fRandom->nextBool()
+                                             ? GrSamplerState::Filter::kBilerp
+                                             : GrSamplerState::Filter::kNearest);
 
     const SkMatrix& matrix = GrTest::TestMatrix(testData->fRandom);
     return GrSimpleTextureEffect::Make(testData->textureProxy(texIdx), matrix, params);
diff --git a/src/gpu/effects/GrSimpleTextureEffect.h b/src/gpu/effects/GrSimpleTextureEffect.h
index f04daf2..5e8730a 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.h
+++ b/src/gpu/effects/GrSimpleTextureEffect.h
@@ -18,38 +18,35 @@
     const SkMatrix44& matrix() const { return fMatrix; }
 
     static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
-                                                     const SkMatrix&       matrix) {
+                                                     const SkMatrix& matrix) {
         return std::unique_ptr<GrFragmentProcessor>(
-                new GrSimpleTextureEffect(std::move(proxy),
-                                          matrix,
+                new GrSimpleTextureEffect(std::move(proxy), matrix,
                                           GrSamplerState(GrSamplerState::WrapMode::kClamp,
                                                          GrSamplerState::Filter::kNearest)));
     }
 
     /* clamp mode */
-    static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy>  proxy,
-                                                     const SkMatrix&        matrix,
+    static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+                                                     const SkMatrix& matrix,
                                                      GrSamplerState::Filter filter) {
         return std::unique_ptr<GrFragmentProcessor>(new GrSimpleTextureEffect(
-                std::move(proxy),
-                matrix,
+                std::move(proxy), matrix,
                 GrSamplerState(GrSamplerState::WrapMode::kClamp, filter)));
     }
 
     static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
-                                                     const SkMatrix&       matrix,
+                                                     const SkMatrix& matrix,
                                                      const GrSamplerState& p) {
         return std::unique_ptr<GrFragmentProcessor>(
                 new GrSimpleTextureEffect(std::move(proxy), matrix, p));
     }
     GrSimpleTextureEffect(const GrSimpleTextureEffect& src);
     std::unique_ptr<GrFragmentProcessor> clone() const override;
-    const char*                          name() const override { return "SimpleTextureEffect"; }
+    const char* name() const override { return "SimpleTextureEffect"; }
 
 private:
-    GrSimpleTextureEffect(sk_sp<GrTextureProxy> image,
-                          SkMatrix44            matrix,
-                          GrSamplerState        samplerParams)
+    GrSimpleTextureEffect(sk_sp<GrTextureProxy> image, SkMatrix44 matrix,
+                          GrSamplerState samplerParams)
             : INHERITED(kGrSimpleTextureEffect_ClassID,
                         (OptimizationFlags)ModulateForSamplerOptFlags(
                                 image->config(),
@@ -68,9 +65,9 @@
     bool onIsEqual(const GrFragmentProcessor&) const override;
     const TextureSampler& onTextureSampler(int) const override;
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
-    TextureSampler              fImage;
-    SkMatrix44                  fMatrix;
-    GrCoordTransform            fImageCoordTransform;
+    TextureSampler fImage;
+    SkMatrix44 fMatrix;
+    GrCoordTransform fImageCoordTransform;
     typedef GrFragmentProcessor INHERITED;
 };
 #endif