Make SkPixelXorXfermode's opColor be SkPMColor

src/effects/SkPixelXorXfermode.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPixelXorXfermode.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
@@ skipping 102 matching lines @@
 
     fragBuilder->codeAppend("}");
 
     fragBuilder->codeAppendf("%s = vec4(red/255.0, green/255.0, blue/255.0, 1.0);", outputColor);
 }
 
 class GLPixelXorFP;
 
 class PixelXorFP : public GrFragmentProcessor {
 public:
-    static const GrFragmentProcessor* Create(SkColor opColor, const GrFragmentProcessor* dst) {
+    static const GrFragmentProcessor* Create(SkPMColor opColor, const GrFragmentProcessor* dst) {
         return new PixelXorFP(opColor, dst);
     }
 
     ~PixelXorFP() override {};
 
     const char* name() const override { return "PixelXor"; }
 
     SkString dumpInfo() const override {
         SkString str;
         str.appendf("Color: 0x%08x", fOpColor);
         return str;
     }
 
-    SkColor opColor() const { return fOpColor; }
+    SkPMColor opColor() const { return fOpColor; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor& fpBase) const override {
         const PixelXorFP& fp = fpBase.cast<PixelXorFP>();
         return fOpColor == fp.fOpColor;
     }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
     }
 
-    PixelXorFP(SkColor opColor, const GrFragmentProcessor* dst)
+    PixelXorFP(SkPMColor opColor, const GrFragmentProcessor* dst)
         : fOpColor(opColor) {
         this->initClassID<PixelXorFP>();
 
         SkASSERT(dst);
         SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst);
         SkASSERT(0 == dstIndex);
     }
 
-    SkColor fOpColor;
+    SkPMColor fOpColor;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
     typedef GrFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLPixelXorFP : public GrGLSLFragmentProcessor {
 public:
     GLPixelXorFP(const PixelXorFP&) {}
@@ skipping 13 matching lines @@
         add_pixelxor_code(fragBuilder, args.fInputColor, dstColor.c_str(),
                           args.fOutputColor, kOpColorUni);
     }
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) { }
 
 protected:
     void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
         const PixelXorFP& pixXor = proc.cast<PixelXorFP>();
         pdman.set3f(fOpColorUni,
-                    SkColorGetR(pixXor.opColor())/255.0f,
-                    SkColorGetG(pixXor.opColor())/255.0f,
-                    SkColorGetB(pixXor.opColor())/255.0f);
+                    SkGetPackedR32(pixXor.opColor())/255.0f,
+                    SkGetPackedG32(pixXor.opColor())/255.0f,
+                    SkGetPackedB32(pixXor.opColor())/255.0f);
     }
 
 private:
     GrGLSLProgramDataManager::UniformHandle fOpColorUni;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLSLFragmentProcessor* PixelXorFP::onCreateGLSLInstance() const {
     return new GLPixelXorFP(*this);
 }
 
 void PixelXorFP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLPixelXorFP::GenKey(*this, caps, b);
 }
 
 const GrFragmentProcessor* PixelXorFP::TestCreate(GrProcessorTestData* d) {
     SkColor color = d->fRandom->nextU();
 
     SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChildFP(d));
-    return new PixelXorFP(color, dst);
+    return new PixelXorFP(SkPreMultiplyColor(color), dst);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(PixelXorFP);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Xfer Processor
 ///////////////////////////////////////////////////////////////////////////////
 
 class PixelXorXP : public GrXferProcessor {
 public:
-    PixelXorXP(const DstTexture* dstTexture, bool hasMixedSamples, SkColor opColor)
+    PixelXorXP(const DstTexture* dstTexture, bool hasMixedSamples, SkPMColor opColor)
         : INHERITED(dstTexture, true, hasMixedSamples)
         , fOpColor(opColor) {
         this->initClassID<PixelXorXP>();
     }
 
     const char* name() const override { return "PixelXor"; }
 
     GrGLSLXferProcessor* createGLSLInstance() const override;
 
-    SkColor opColor() const { return fOpColor; }
+    SkPMColor opColor() const { return fOpColor; }
 
 private:
     GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
                                                  const GrCaps& caps) const override {
         return GrXferProcessor::kNone_OptFlags;
     }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
         const PixelXorXP& xp = xpBase.cast<PixelXorXP>();
 
         return fOpColor == xp.fOpColor;
     }
 
-    SkColor fOpColor;
+    SkPMColor fOpColor;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLPixelXorXP : public GrGLSLXferProcessor {
 public:
     GLPixelXorXP(const PixelXorXP& pixelXorXP) { }
 
@@ skipping 18 matching lines @@
         add_pixelxor_code(fragBuilder, srcColor, dstColor, outColor, kOpColorUni);
 
         // Apply coverage.
         INHERITED::DefaultCoverageModulation(fragBuilder, srcCoverage, dstColor, outColor,
                                              outColorSecondary, proc);
     }
 
     void onSetData(const GrGLSLProgramDataManager& pdman,
                    const GrXferProcessor& processor) override {
         const PixelXorXP& pixelXor = processor.cast<PixelXorXP>();
-        pdman.set3f(fOpColorUni,
-                    SkColorGetR(pixelXor.opColor())/255.0f,
-                    SkColorGetG(pixelXor.opColor())/255.0f,
-                    SkColorGetB(pixelXor.opColor())/255.0f);
+        pdman.set3f(fOpColorUni, 
+                    SkGetPackedR32(pixelXor.opColor())/255.0f,
+                    SkGetPackedG32(pixelXor.opColor())/255.0f,
+                    SkGetPackedB32(pixelXor.opColor())/255.0f);
     };
 
     GrGLSLProgramDataManager::UniformHandle fOpColorUni;
 
     typedef GrGLSLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void PixelXorXP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLPixelXorXP::GenKey(*this, caps, b);
 }
 
 GrGLSLXferProcessor* PixelXorXP::createGLSLInstance() const { return new GLPixelXorXP(*this); }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrPixelXorXPFactory : public GrXPFactory {
 public:
-    static GrXPFactory* Create(SkColor opColor) {
+    static GrXPFactory* Create(SkPMColor opColor) {
         return new GrPixelXorXPFactory(opColor);
     }
 
     void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                   GrXPFactory::InvariantBlendedColor* blendedColor) const override {
         blendedColor->fWillBlendWithDst = true;
         blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
     }
 
 private:
-    GrPixelXorXPFactory(SkColor opColor)
+    GrPixelXorXPFactory(SkPMColor opColor)
         : fOpColor(opColor) {
         this->initClassID<GrPixelXorXPFactory>();
     }
 
     GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
                                            const GrPipelineOptimizations& optimizations,
                                            bool hasMixedSamples,
                                            const DstTexture* dstTexture) const override {
         return new PixelXorXP(dstTexture, hasMixedSamples, fOpColor);
     }
 
     bool willReadDstColor(const GrCaps& caps,
                           const GrPipelineOptimizations& optimizations,
                           bool hasMixedSamples) const override {
         return true;
     }
 
     bool onIsEqual(const GrXPFactory& xpfBase) const override {
         const GrPixelXorXPFactory& xpf = xpfBase.cast<GrPixelXorXPFactory>();
         return fOpColor == xpf.fOpColor;
     }
 
     GR_DECLARE_XP_FACTORY_TEST;
 
-    SkColor fOpColor;
+    SkPMColor fOpColor;
 
     typedef GrXPFactory INHERITED;
 };
 
 GR_DEFINE_XP_FACTORY_TEST(GrPixelXorXPFactory);
 
 const GrXPFactory* GrPixelXorXPFactory::TestCreate(GrProcessorTestData* d) {
     SkColor color = d->fRandom->nextU();
 
-    return GrPixelXorXPFactory::Create(color);
+    return GrPixelXorXPFactory::Create(SkPreMultiplyColor(color));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkPixelXorXfermode::asFragmentProcessor(const GrFragmentProcessor** output,
-    const GrFragmentProcessor* dst) const {
+                                             const GrFragmentProcessor* dst) const {
     if (output) {
         *output = PixelXorFP::Create(fOpColor, dst);
     }
     return true;
 }
 
 bool SkPixelXorXfermode::asXPFactory(GrXPFactory** xpf) const {
     if (xpf) {
         *xpf = GrPixelXorXPFactory::Create(fOpColor);
     }
     return true;
 }
 
 #endif