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

src/gpu/GrSWMaskHelper.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrSWMaskHelper.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "batches/GrDrawBatch.h"
 #include "GrDrawContext.h"
 #include "GrPipelineBuilder.h"
 #include "GrShape.h"
 
 #include "SkDistanceFieldGen.h"
 
 #include "batches/GrRectBatchFactory.h"
 
 /*
  * Convert a boolean operation into a transfer mode code
  */
-static SkXfermode::Mode op_to_mode(SkRegion::Op op) {
+static SkBlendMode op_to_mode(SkRegion::Op op) {
 
-    static const SkXfermode::Mode modeMap[] = {
-        SkXfermode::kDstOut_Mode,   // kDifference_Op
-        SkXfermode::kModulate_Mode, // kIntersect_Op
-        SkXfermode::kSrcOver_Mode,  // kUnion_Op
-        SkXfermode::kXor_Mode,      // kXOR_Op
-        SkXfermode::kClear_Mode,    // kReverseDifference_Op
-        SkXfermode::kSrc_Mode,      // kReplace_Op
+    static const SkBlendMode modeMap[] = {
+        SkBlendMode::kDstOut,   // kDifference_Op
+        SkBlendMode::kModulate, // kIntersect_Op
+        SkBlendMode::kSrcOver,  // kUnion_Op
+        SkBlendMode::kXor,      // kXOR_Op
+        SkBlendMode::kClear,    // kReverseDifference_Op
+        SkBlendMode::kSrc,      // kReplace_Op
     };
 
     return modeMap[op];
 }
 
 /**
  * Draw a single rect element of the clip stack into the accumulation bitmap
  */
 void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op,
                               bool antiAlias, uint8_t alpha) {
     SkPaint paint;
 
-    paint.setXfermode(SkXfermode::Make(op_to_mode(op)));
+    paint.setBlendMode(op_to_mode(op));
     paint.setAntiAlias(antiAlias);
     paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
 
     fDraw.drawRect(rect, paint);
 }
 
 /**
  * Draw a single path element of the clip stack into the accumulation bitmap
  */
 void GrSWMaskHelper::drawShape(const GrShape& shape, SkRegion::Op op, bool antiAlias,
                                uint8_t alpha) {
     SkPaint paint;
     paint.setPathEffect(sk_ref_sp(shape.style().pathEffect()));
     shape.style().strokeRec().applyToPaint(&paint);
     paint.setAntiAlias(antiAlias);
 
     SkPath path;
     shape.asPath(&path);
     if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
         SkASSERT(0xFF == paint.getAlpha());
         fDraw.drawPathCoverage(path, paint);
     } else {
-        paint.setXfermodeMode(op_to_mode(op));
+        paint.setBlendMode(op_to_mode(op));
         paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
         fDraw.drawPath(path, paint);
     }
 }
 
 bool GrSWMaskHelper::init(const SkIRect& resultBounds, const SkMatrix* matrix) {
     if (matrix) {
         fMatrix = *matrix;
     } else {
         fMatrix.setIdentity();
@@ skipping 113 matching lines @@
                          GrSimpleTextureEffect::Make(texture,
                                                      nullptr,
                                                      maskMatrix,
                                                      GrTextureParams::kNone_FilterMode));
 
     SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(paint.getColor(),
                                                                         SkMatrix::I(),
                                                                         dstRect, nullptr, &invert));
     drawContext->drawBatch(pipelineBuilder, clip, batch);
 }