Refactor various gradient effect classes

src/effects/gradients/SkLinearGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "SkLinearGradient.h"
 #include "SkRefCnt.h"
@@ skipping 329 matching lines @@
 }
 
 #if SK_SUPPORT_GPU
 
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "SkGr.h"
 
 /////////////////////////////////////////////////////////////////////
 
-class GrGLLinearGradient : public GrGLGradientEffect {
-public:
-
-    GrGLLinearGradient(const GrProcessor&) {}
-
-    virtual ~GrGLLinearGradient() { }
-
-    virtual void emitCode(EmitArgs&) override;
-
-    static void GenKey(const GrProcessor& processor, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
-        b->add32(GenBaseGradientKey(processor));
-    }
-
-private:
-
-    typedef GrGLGradientEffect INHERITED;
-};
-
-/////////////////////////////////////////////////////////////////////
-
 class GrLinearGradient : public GrGradientEffect {
 public:
+    class GLSLLinearProcessor;
 
     static sk_sp<GrFragmentProcessor> Make(GrContext* ctx,
                                            const SkLinearGradient& shader,
                                            const SkMatrix& matrix,
                                            SkShader::TileMode tm) {
         return sk_sp<GrFragmentProcessor>(new GrLinearGradient(ctx, shader, matrix, tm));
     }
 
     virtual ~GrLinearGradient() { }
 
     const char* name() const override { return "Linear Gradient"; }
 
 private:
     GrLinearGradient(GrContext* ctx,
                      const SkLinearGradient& shader,
                      const SkMatrix& matrix,
                      SkShader::TileMode tm)
         : INHERITED(ctx, shader, matrix, tm) {
         this->initClassID<GrLinearGradient>();
     }
 
-    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
-        return new GrGLLinearGradient(*this);
-    }
+    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
-                                       GrProcessorKeyBuilder* b) const override {
-        GrGLLinearGradient::GenKey(*this, caps, b);
-    }
+                                       GrProcessorKeyBuilder* b) const override;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrGradientEffect INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////
 
+class GrLinearGradient::GLSLLinearProcessor : public GrGradientEffect::GLSLProcessor {
+public:
+
+    GLSLLinearProcessor(const GrProcessor&) {}
+
+    virtual ~GLSLLinearProcessor() { }
+
+    virtual void emitCode(EmitArgs&) override;
+
+    static void GenKey(const GrProcessor& processor, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
+        b->add32(GenBaseGradientKey(processor));
+    }
+
+private:

[bsalomon, 2016/08/09 13:47:05]

Don't need newlines after public, protected, private (though keep the newline
before private here)

+
+    typedef GrGradientEffect::GLSLProcessor INHERITED;
+};
+
+/////////////////////////////////////////////////////////////////////
+
+GrGLSLFragmentProcessor* GrLinearGradient::onCreateGLSLInstance() const {
+    return new GrLinearGradient::GLSLLinearProcessor(*this);
+}
+
+void GrLinearGradient::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
+                                             GrProcessorKeyBuilder* b) const {
+    GrLinearGradient::GLSLLinearProcessor::GenKey(*this, caps, b);
+}
+
+/////////////////////////////////////////////////////////////////////
+
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrLinearGradient);
 
 sk_sp<GrFragmentProcessor> GrLinearGradient::TestCreate(GrProcessorTestData* d) {
     SkPoint points[] = {{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()},
                         {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}};
 
     SkColor colors[kMaxRandomGradientColors];
     SkScalar stopsArray[kMaxRandomGradientColors];
     SkScalar* stops = stopsArray;
     SkShader::TileMode tm;
     int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm);
     auto shader = SkGradientShader::MakeLinear(points, colors, stops, colorCount, tm);
     SkMatrix viewMatrix = GrTest::TestMatrix(d->fRandom);
     sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(SkShader::AsFPArgs(
         d->fContext, &viewMatrix, NULL, kNone_SkFilterQuality, nullptr,
         SkSourceGammaTreatment::kRespect));
     GrAlwaysAssert(fp);
     return fp;
 }
 
 /////////////////////////////////////////////////////////////////////
 
-void GrGLLinearGradient::emitCode(EmitArgs& args) {
+void GrLinearGradient::GLSLLinearProcessor::emitCode(EmitArgs& args) {
     const GrLinearGradient& ge = args.fFp.cast<GrLinearGradient>();
     this->emitUniforms(args.fUniformHandler, ge);
     SkString t = args.fFragBuilder->ensureFSCoords2D(args.fCoords, 0);
     t.append(".x");
     this->emitColor(args.fFragBuilder,
                     args.fUniformHandler,
                     args.fGLSLCaps,
-                    ge, t.c_str(),
+                    ge,
+                    t.c_str(),
                     args.fOutputColor,
                     args.fInputColor,
                     args.fTexSamplers);
 }
 
 /////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> SkLinearGradient::asFragmentProcessor(const AsFPArgs& args) const {
     SkASSERT(args.fContext);
 
@@ skipping 303 matching lines @@
             this->shade4_dx_clamp<false, true>(dstC, count, fx, dx, invDx, dither);
         }
     } else {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
         }
     }
 }