kill SkValue

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"
 #include "SkWriteBuffer.h"
 #include "SkString.h"
-#include "SkValue.h"
-#include "SkValueKeys.h"
 
 // we always return an opaque color, 'cause I don't know what to do with
 // the alpha-component and still return a valid premultiplied color.
 SkPMColor SkPixelXorXfermode::xferColor(SkPMColor src, SkPMColor dst) const {
     SkPMColor res = src ^ dst ^ fOpColor;
 
     res |= (SK_A32_MASK << SK_A32_SHIFT);   // force it to be opaque
     return res;
 }
 
@@ skipping 34 matching lines @@
                               const char* opColor) {
     static const GrGLSLShaderVar gXorArgs[] = {
         GrGLSLShaderVar("f1", kFloat_GrSLType),
         GrGLSLShaderVar("f2", kFloat_GrSLType),
         GrGLSLShaderVar("f3", kFloat_GrSLType),
         GrGLSLShaderVar("fPowerOf2Divisor", kFloat_GrSLType),
     };
     SkString xorFuncName;
 
     // The xor function checks if the three passed in floats (f1, f2, f3) would
-    // have a bit in the log2(fPowerOf2Divisor)-th position if they were 
-    // represented by an int. It then performs an xor of the 3 bits (using 
+    // have a bit in the log2(fPowerOf2Divisor)-th position if they were
+    // represented by an int. It then performs an xor of the 3 bits (using
     // the property that serial xors can be treated as a sum of 0s & 1s mod 2).
     fragBuilder->emitFunction(kFloat_GrSLType,
                               "xor",
                               SK_ARRAY_COUNT(gXorArgs),
                               gXorArgs,
                               "float bit1 = floor(f1 / fPowerOf2Divisor);"
                               "float bit2 = floor(f2 / fPowerOf2Divisor);"
                               "float bit3 = floor(f3 / fPowerOf2Divisor);"
                               "return mod(bit1 + bit2 + bit3, 2.0);",
                               &xorFuncName);
@@ skipping 210 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, 
+        pdman.set3f(fOpColorUni,
                     SkColorGetR(pixelXor.opColor())/255.0f,
                     SkColorGetG(pixelXor.opColor())/255.0f,
                     SkColorGetB(pixelXor.opColor())/255.0f);
     };
 
     GrGLSLProgramDataManager::UniformHandle fOpColorUni;
 
     typedef GrGLSLXferProcessor INHERITED;
 };
 
@@ skipping 69 matching lines @@
 }
 
 bool SkPixelXorXfermode::asXPFactory(GrXPFactory** xpf) const {
     if (xpf) {
         *xpf = GrPixelXorXPFactory::Create(fOpColor);
     }
     return true;
 }
 
 #endif
-
-SkValue SkPixelXorXfermode::asValue() const {
-    auto value = SkValue::Object(SkValue::PixelXorXfermode);
-    value.set(SkValueKeys::PixelXorXfermode::kOpColor,
-              SkValue::FromU32(SkToU32(fOpColor)));
-    return value;
-}