Push usage of GrColor4f into OverrideInput

src/gpu/GrFragmentProcessor.cpp

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
@@ skipping 241 matching lines @@
     };
     if (!fp) {
         return nullptr;
     }
     return sk_sp<GrFragmentProcessor>(new PremulFragmentProcessor(std::move(fp)));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentProcessor> fp,
-                                                              GrColor color) {
+                                                              GrColor4f color) {
     class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
     public:
-        ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor color)
+        ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
             : fColor(color) {
             this->initClassID<ReplaceInputFragmentProcessor>();
             this->registerChildProcessor(std::move(child));
         }
 
         const char* name() const override { return "Replace Color"; }
 
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 GLFP() : fHaveSetColor(false) {}
                 void emitCode(EmitArgs& args) override {
                     const char* colorName;
                     fColorUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
                                                                  kVec4f_GrSLType,
                                                                  kDefault_GrSLPrecision,
                                                                  "Color", &colorName);
                     this->emitChild(0, colorName, args);
                 }
 
             private:
                 void onSetData(const GrGLSLProgramDataManager& pdman,
                                const GrProcessor& fp) override {
-                    GrColor color = fp.cast<ReplaceInputFragmentProcessor>().fColor;
+                    GrColor4f color = fp.cast<ReplaceInputFragmentProcessor>().fColor;
                     if (!fHaveSetColor || color != fPreviousColor) {
-                        static const float scale = 1.f / 255.f;
-                        float floatColor[4] = {
-                            GrColorUnpackR(color) * scale,
-                            GrColorUnpackG(color) * scale,
-                            GrColorUnpackB(color) * scale,
-                            GrColorUnpackA(color) * scale,
-                        };
-                        pdman.set4fv(fColorUni, 1, floatColor);
+                        pdman.set4fv(fColorUni, 1, color.fRGBA);
                         fPreviousColor = color;
                         fHaveSetColor = true;
                     }
                 }
 
                 GrGLSLProgramDataManager::UniformHandle fColorUni;
-                bool    fHaveSetColor;
-                GrColor fPreviousColor;
+                bool      fHaveSetColor;
+                GrColor4f fPreviousColor;
             };
 
             return new GLFP;
         }
 
     private:
         void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override
         {}
 
         bool onIsEqual(const GrFragmentProcessor& that) const override {
             return fColor == that.cast<ReplaceInputFragmentProcessor>().fColor;
         }
 
         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
-            inout->setToOther(kRGBA_GrColorComponentFlags, fColor,
+            inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor(),
                               GrInvariantOutput::kWillNot_ReadInput);
             this->childProcessor(0).computeInvariantOutput(inout);
         }
 
-        GrColor fColor;
+        GrColor4f fColor;
     };
 
     GrInvariantOutput childOut(0x0, kNone_GrColorComponentFlags, false);
     fp->computeInvariantOutput(&childOut);
     if (childOut.willUseInputColor()) {
         return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
     } else {
         return fp;
     }
 }
@@ skipping 76 matching lines @@
     } else {
         series += firstIdx;
         cnt -= firstIdx;
     }
 
     if (1 == cnt) {
         return series[0];
     }
     return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(series, cnt));
 }