Added GrGLFragmentProcessor::EmitArgs struct for use with emitCode()

src/effects/SkColorFilters.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitRow.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
@@ skipping 148 matching lines @@
     const char* name() const override { return "ModeColorFilterEffect"; }
 
     SkXfermode::Mode mode() const { return fMode; }
     GrColor color() const { return fColor; }
 
     class GLProcessor : public GrGLFragmentProcessor {
     public:
         GLProcessor(const GrProcessor&) {
         }
 
-        virtual void emitCode(GrGLFPBuilder* builder,
-                              const GrFragmentProcessor& fp,
-                              const char* outputColor,
-                              const char* inputColor,
-                              const TransformedCoordsArray&,
-                              const TextureSamplerArray&) override {
-            SkXfermode::Mode mode = fp.cast<ModeColorFilterEffect>().mode();
+        virtual void emitCode(EmitArgs& args) override {
+            SkXfermode::Mode mode = args.fFp.cast<ModeColorFilterEffect>().mode();
 
             SkASSERT(SkXfermode::kDst_Mode != mode);
             const char* colorFilterColorUniName = NULL;
-            if (fp.cast<ModeColorFilterEffect>().willUseFilterColor()) {
-                fFilterColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+            if (args.fFp.cast<ModeColorFilterEffect>().willUseFilterColor()) {
+                fFilterColorUni = args.fBuilder->addUniform(
+                                                      GrGLProgramBuilder::kFragment_Visibility,
                                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                       "FilterColor",
                                                       &colorFilterColorUniName);
             }
 
             GrGLSLExpr4 filter =
                 color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniName),
-                                        GrGLSLExpr4(inputColor));
+                                        GrGLSLExpr4(args.fInputColor));
 
-            builder->getFragmentShaderBuilder()->
-                    codeAppendf("\t%s = %s;\n", outputColor, filter.c_str());
+            args.fBuilder->getFragmentShaderBuilder()->
+                    codeAppendf("\t%s = %s;\n", args.fOutputColor, filter.c_str());
         }
 
         static void GenKey(const GrProcessor& fp, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const ModeColorFilterEffect& colorModeFilter = fp.cast<ModeColorFilterEffect>();
             // The SL code does not depend on filter color at the moment, so no need to represent it
             // in the key.
             b->add32(colorModeFilter.mode());
         }
 
@@ skipping 264 matching lines @@
                     byte_to_scale(SkColorGetG(mul)),
                     byte_to_scale(SkColorGetB(mul)),
                     1);
     matrix.postTranslate(SkIntToScalar(SkColorGetR(add)),
                          SkIntToScalar(SkColorGetG(add)),
                          SkIntToScalar(SkColorGetB(add)),
                          0);
     return SkColorMatrixFilter::Create(matrix);
 }