Revert[8] "replace SkXfermode obj with SkBlendMode enum in paints"

src/effects/SkXfermodeImageFilter.cpp

 /*
  * Copyright 2013 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 "SkXfermodeImageFilter.h"
+#include "SkArithmeticModePriv.h"
 
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
 #include "SkXfermode.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "SkArithmeticMode_gpu.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #endif
 
 class SkXfermodeImageFilter_Base : public SkImageFilter {
 public:
-    SkXfermodeImageFilter_Base(sk_sp<SkXfermode> mode, sk_sp<SkImageFilter> inputs[2],
+    SkXfermodeImageFilter_Base(SkBlendMode mode, sk_sp<SkImageFilter> inputs[2],
                                const CropRect* cropRect);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkXfermodeImageFilter_Base)
 
 protected:
     sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
                                         SkIPoint* offset) const override;
 
 #if SK_SUPPORT_GPU
     sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source,
                                          sk_sp<SkSpecialImage> background,
                                          const SkIPoint& backgroundOffset,
                                          sk_sp<SkSpecialImage> foreground,
                                          const SkIPoint& foregroundOffset,
                                          const SkIRect& bounds,
                                          const OutputProperties& outputProperties) const;
 #endif
 
     void flatten(SkWriteBuffer&) const override;
 
     virtual void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
 #if SK_SUPPORT_GPU
     virtual sk_sp<GrFragmentProcessor> makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const;
 #endif
 
 private:
-    sk_sp<SkXfermode> fMode;
+    SkBlendMode fMode;
 
     friend class SkXfermodeImageFilter;
 
     typedef SkImageFilter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-sk_sp<SkImageFilter> SkXfermodeImageFilter::Make(sk_sp<SkXfermode> mode,
+sk_sp<SkImageFilter> SkXfermodeImageFilter::Make(SkBlendMode mode,
                                                  sk_sp<SkImageFilter> background,
                                                  sk_sp<SkImageFilter> foreground,
                                                  const SkImageFilter::CropRect* cropRect) {
     sk_sp<SkImageFilter> inputs[2] = { std::move(background), std::move(foreground) };
     return sk_sp<SkImageFilter>(new SkXfermodeImageFilter_Base(mode, inputs, cropRect));
 }
 
-SkXfermodeImageFilter_Base::SkXfermodeImageFilter_Base(sk_sp<SkXfermode> mode,
-                                             sk_sp<SkImageFilter> inputs[2],
-                                             const CropRect* cropRect)
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_OBJECT
+sk_sp<SkImageFilter> SkXfermodeImageFilter::Make(sk_sp<SkXfermode> mode,
+                                                 sk_sp<SkImageFilter> background,
+                                                 sk_sp<SkImageFilter> foreground,
+                                                 const SkImageFilter::CropRect* cropRect) {
+    return Make(mode ? mode->blend() : SkBlendMode::kSrcOver,
+                std::move(background), std::move(foreground), cropRect);
+}
+#endif
+
+SkXfermodeImageFilter_Base::SkXfermodeImageFilter_Base(SkBlendMode mode,
+                                                       sk_sp<SkImageFilter> inputs[2],
+                                                       const CropRect* cropRect)
     : INHERITED(inputs, 2, cropRect)
-    , fMode(std::move(mode)) {
+    , fMode(mode)
+{}
+
+static int unflatten_blendmode(SkReadBuffer& buffer, SkArithmeticParams* arith) {
+    if (buffer.isVersionLT(SkReadBuffer::kXfermodeToBlendMode_Version)) {
+        sk_sp<SkXfermode> xfer = buffer.readXfermode();
+        if (xfer) {
+            if (xfer->isArithmetic(arith)) {
+                return -1;
+            }
+            return (int)xfer->blend();
+        } else {
+            return (int)SkBlendMode::kSrcOver;
+        }
+    } else {
+        uint32_t mode = buffer.read32();
+        (void)buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode);
+        return mode;
+    }
 }
 
 sk_sp<SkFlattenable> SkXfermodeImageFilter_Base::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
-    sk_sp<SkXfermode> mode(buffer.readXfermode());
-    return SkXfermodeImageFilter::Make(std::move(mode), common.getInput(0), common.getInput(1),
-                                       &common.cropRect());
+    SkArithmeticParams arith;
+    int mode = unflatten_blendmode(buffer, &arith);
+    if (mode >= 0) {
+        return SkXfermodeImageFilter::Make((SkBlendMode)mode, common.getInput(0),
+                                           common.getInput(1), &common.cropRect());
+    } else {
+        return SkXfermodeImageFilter::MakeArithmetic(arith.fK[0], arith.fK[1], arith.fK[2],
+                                                     arith.fK[3], arith.fEnforcePMColor,
+                                                     common.getInput(0),
+                                                     common.getInput(1), &common.cropRect());
+    }
 }
 
 void SkXfermodeImageFilter_Base::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
-    buffer.writeFlattenable(fMode.get());
+    buffer.write32((unsigned)fMode);
 }
 
 sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::onFilterImage(SkSpecialImage* source,
                                                            const Context& ctx,
                                                            SkIPoint* offset) const {
     SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
     sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset));
 
     SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
     sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset));
@@ skipping 38 matching lines @@
     }
 
     SkCanvas* canvas = surf->getCanvas();
     SkASSERT(canvas);
 
     canvas->clear(0x0); // can't count on background to fully clear the background
     canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
 
     if (background) {
         SkPaint paint;
-        paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+        paint.setBlendMode(SkBlendMode::kSrc);
         background->draw(canvas,
                          SkIntToScalar(backgroundOffset.fX), SkIntToScalar(backgroundOffset.fY),
                          &paint);
     }
 
     this->drawForeground(canvas, foreground.get(), foregroundBounds);
 
     return surf->makeImageSnapshot();
 }
 
 void SkXfermodeImageFilter_Base::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
                                                 const SkIRect& fgBounds) const {
     SkPaint paint;
-    paint.setXfermode(fMode);
+    paint.setBlendMode(fMode);
     if (img) {
         img->draw(canvas, SkIntToScalar(fgBounds.fLeft), SkIntToScalar(fgBounds.fTop), &paint);
     }
 
     SkAutoCanvasRestore acr(canvas, true);
     canvas->clipRect(SkRect::Make(fgBounds), SkCanvas::kDifference_Op);
     paint.setColor(0);
     canvas->drawPaint(paint);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkXfermodeImageFilter_Base::toString(SkString* str) const {
     str->appendf("SkXfermodeImageFilter: (");
-    str->appendf("xfermode: (");
-    if (fMode) {
-        fMode->toString(str);
-    }
-    str->append(")");
+    str->appendf("blendmode: (%d)", (int)fMode);
     if (this->getInput(0)) {
         str->appendf("foreground: (");
         this->getInput(0)->toString(str);
         str->appendf(")");
     }
     if (this->getInput(1)) {
         str->appendf("background: (");
         this->getInput(1)->toString(str);
         str->appendf(")");
     }
@@ skipping 66 matching lines @@
         sk_sp<GrFragmentProcessor> xferFP = this->makeFGFrag(bgFP);
 
         // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
         if (xferFP) {
             paint.addColorFragmentProcessor(std::move(xferFP));
         }
     } else {
         paint.addColorFragmentProcessor(std::move(bgFP));
     }
 
-    paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
+    paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
     sk_sp<GrDrawContext> drawContext(
         context->makeDrawContext(SkBackingFit::kApprox, bounds.width(), bounds.height(),
                                  GrRenderableConfigForColorSpace(outputProperties.colorSpace()),
                                  sk_ref_sp(outputProperties.colorSpace())));
     if (!drawContext) {
         return nullptr;
     }
     paint.setGammaCorrect(drawContext->isGammaCorrect());
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
     drawContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(bounds));
 
     return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
                                        kNeedNewImageUniqueID_SpecialImage,
                                        drawContext->asTexture(),
                                        sk_ref_sp(drawContext->getColorSpace()));
 }
 
 sk_sp<GrFragmentProcessor>
 SkXfermodeImageFilter_Base::makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const {
     // A null fMode is interpreted to mean kSrcOver_Mode (to match raster).
-    SkAutoTUnref<SkXfermode> mode(SkSafeRef(fMode.get()));
-    if (!mode) {
+    SkXfermode* xfer = SkXfermode::Peek(fMode);
+    sk_sp<SkXfermode> srcover;
+    if (!xfer) {
         // It would be awesome to use SkXfermode::Create here but it knows better
         // than us and won't return a kSrcOver_Mode SkXfermode. That means we
         // have to get one the hard way.
         struct ProcCoeff rec;
         rec.fProc = SkXfermode::GetProc(SkXfermode::kSrcOver_Mode);
         SkXfermode::ModeAsCoeff(SkXfermode::kSrcOver_Mode, &rec.fSC, &rec.fDC);
 
-        mode.reset(new SkProcCoeffXfermode(rec, SkXfermode::kSrcOver_Mode));
+        srcover.reset(new SkProcCoeffXfermode(rec, SkXfermode::kSrcOver_Mode));
+        xfer = srcover.get();
+
     }
-    return mode->makeFragmentProcessorForImageFilter(std::move(bgFP));
+    return xfer->makeFragmentProcessorForImageFilter(std::move(bgFP));
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class SkArithmeticImageFilter : public SkXfermodeImageFilter_Base {
 public:
     SkArithmeticImageFilter(float k1, float k2, float k3, float k4, bool enforcePMColor,
                             sk_sp<SkImageFilter> inputs[2], const CropRect* cropRect)
-        : SkXfermodeImageFilter_Base(nullptr, inputs, cropRect)
+        // need to pass a blendmode to our inherited constructor, but we ignore it
+        : SkXfermodeImageFilter_Base(SkBlendMode::kSrcOver, inputs, cropRect)
         , fK{ k1, k2, k3, k4 }
         , fEnforcePMColor(enforcePMColor)
     {}
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkArithmeticImageFilter)
 
 protected:
     void flatten(SkWriteBuffer& buffer) const override {
         this->INHERITED::flatten(buffer);
         for (int i = 0; i < 4; ++i) {
@@ skipping 14 matching lines @@
 
     friend class SkXfermodeImageFilter;
 
     typedef SkXfermodeImageFilter_Base INHERITED;
 };
 
 sk_sp<SkFlattenable> SkArithmeticImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
 
     // skip the mode (srcover) our parent-class wrote
-    sk_sp<SkXfermode> mode(buffer.readXfermode());
-    SkASSERT(nullptr == mode);
+    SkDEBUGCODE(int mode =) unflatten_blendmode(buffer, nullptr);
+    if (!buffer.isValid()) {
+        return nullptr;
+    }
+    SkASSERT(SkBlendMode::kSrcOver == (SkBlendMode)mode);
 
     float k[4];
     for (int i = 0; i < 4; ++i) {
         k[i] = buffer.readScalar();
     }
     const bool enforcePMColor = buffer.readBool();
     return SkXfermodeImageFilter::MakeArithmetic(k[0], k[1], k[2], k[3], enforcePMColor,
                                                  common.getInput(0), common.getInput(1),
                                                  &common.cropRect());
 }
@@ skipping 106 matching lines @@
                                                            const SkImageFilter::CropRect* crop) {
     if (!SkScalarIsFinite(k1) || !SkScalarIsFinite(k2) ||
         !SkScalarIsFinite(k3) || !SkScalarIsFinite(k4)) {
         return nullptr;
     }
 
     // are we nearly some other "std" mode?
     int mode = -1;  // illegal mode
     if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) &&
         SkScalarNearlyZero(k3) && SkScalarNearlyZero(k4)) {
-        mode = SkXfermode::kSrc_Mode;
+        mode = (int)SkBlendMode::kSrc;
     } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
                SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
-        mode = SkXfermode::kDst_Mode;
+        mode = (int)SkBlendMode::kDst;
     } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
                SkScalarNearlyZero(k3) && SkScalarNearlyZero(k4)) {
-        mode = SkXfermode::kClear_Mode;
+        mode = (int)SkBlendMode::kClear;
     }
     if (mode >= 0) {
-        return SkXfermodeImageFilter::Make(SkXfermode::Make((SkXfermode::Mode)mode),
+        return SkXfermodeImageFilter::Make((SkBlendMode)mode,
                                            std::move(background), std::move(foreground), crop);
     }
 
     sk_sp<SkImageFilter> inputs[2] = { std::move(background), std::move(foreground) };
     return sk_sp<SkImageFilter>(new SkArithmeticImageFilter(k1, k2, k3, k4, enforcePMColor,
                                                             inputs, crop));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermodeImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkXfermodeImageFilter_Base)
     // manually register the legacy serialized name "SkXfermodeImageFilter"
     SkFlattenable::Register("SkXfermodeImageFilter", SkXfermodeImageFilter_Base::CreateProc,
                             SkFlattenable::kSkImageFilter_Type);
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkArithmeticImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END