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

gm/aaxfermodes.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 "gm.h"
 #include "SkArithmeticMode.h"
 #include "SkPath.h"
 #include "SkShader.h"
@@ skipping 103 matching lines @@
                         kPaintSpacing, kSubtitleSpacing / 2 + fLabelPaint.getTextSize() / 3,
                         fLabelPaint);
             }
 
             canvas->translate(0, kSubtitleSpacing + kShapeSpacing/2);
 
             for (size_t m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
                 if (firstMode + m > SkXfermode::kLastMode) {
                     break;
                 }
-                SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(firstMode + m);
+                SkBlendMode mode = static_cast<SkBlendMode>(firstMode + m);
                 canvas->save();
 
                 if (kShape_Pass == drawingPass) {
                     this->drawModeName(canvas, mode);
                 }
                 canvas->translate(kLabelSpacing + kShapeSpacing/2, 0);
 
                 for (size_t colorIdx = 0; colorIdx < SK_ARRAY_COUNT(kShapeColors); colorIdx++) {
                     SkPaint paint;
                     this->setupShapePaint(canvas, kShapeColors[colorIdx], mode, &paint);
                     SkASSERT(colorIdx == 0 || 255 == paint.getAlpha());
                     canvas->save();
 
                     for (size_t shapeIdx = 0; shapeIdx <= kLast_Shape; shapeIdx++) {
                         if (kShape_Pass != drawingPass) {
                             canvas->save();
                             canvas->clipRect(clipRect);
                             if (kCheckerboard_Pass == drawingPass) {
                                 sk_tool_utils::draw_checkerboard(canvas, 0xffffffff, 0xffc6c3c6,
                                         10);
                             } else {
                                 SkASSERT(kBackground_Pass == drawingPass);
-                                canvas->drawColor(kBGColor, SkXfermode::kSrc_Mode);
+                                canvas->drawColor(kBGColor, SkBlendMode::kSrc);
                             }
                             canvas->restore();
                         } else {
                             this->drawShape(canvas, static_cast<Shape>(shapeIdx), paint, mode);
                         }
                         canvas->translate(kShapeTypeSpacing, 0);
                     }
 
                     canvas->restore();
                     canvas->translate(kPaintSpacing, 0);
@@ skipping 25 matching lines @@
                          kLabelSpacing + 4 * kShapeTypeSpacing,
                          kTitleSpacing / 2 + titlePaint.getTextSize() / 3, titlePaint);
         canvas->drawText("Advanced", sizeof("Advanced") - 1,
                          kXfermodeTypeSpacing + kLabelSpacing + 4 * kShapeTypeSpacing,
                          kTitleSpacing / 2 + titlePaint.getTextSize() / 3, titlePaint);
 
         draw_pass(canvas, kShape_Pass);
         canvas->restore();
     }
 
-    void drawModeName(SkCanvas* canvas, SkXfermode::Mode mode) {
-        const char* modeName = mode <= SkXfermode::kLastMode ? SkXfermode::ModeName(mode)
-                                                             : "Arithmetic";
+    void drawModeName(SkCanvas* canvas, SkBlendMode mode) {
+        const char* modeName = SkXfermode::ModeName(mode);
         fLabelPaint.setTextAlign(SkPaint::kRight_Align);
         canvas->drawText(modeName, strlen(modeName), kLabelSpacing - kShapeSize / 4,
                          fLabelPaint.getTextSize() / 4, fLabelPaint);
     }
 
-    void setupShapePaint(SkCanvas* canvas, GrColor color, SkXfermode::Mode mode, SkPaint* paint) {
+    void setupShapePaint(SkCanvas* canvas, GrColor color, SkBlendMode mode, SkPaint* paint) {
         paint->setColor(color);
 
-        if (mode == SkXfermode::kPlus_Mode) {
+        if (mode == SkBlendMode::kPlus) {
             // Check for overflow, otherwise we might get confusing AA artifacts.
             int maxSum = SkTMax(SkTMax(SkColorGetA(kBGColor) + SkColorGetA(color),
                                        SkColorGetR(kBGColor) + SkColorGetR(color)),
                                 SkTMax(SkColorGetG(kBGColor) + SkColorGetG(color),
                                        SkColorGetB(kBGColor) + SkColorGetB(color)));
 
             if (maxSum > 255) {
                 SkPaint dimPaint;
                 dimPaint.setAntiAlias(false);
-                dimPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);
+                dimPaint.setBlendMode(SkBlendMode::kDstIn);
                 if (255 != paint->getAlpha()) {
                     // Dim the src and dst colors.
                     dimPaint.setARGB(255 * 255 / maxSum, 0, 0, 0);
                     paint->setAlpha(255 * paint->getAlpha() / maxSum);
                 } else {
                     // Just clear the dst, we need to preserve the paint's opacity.
                     dimPaint.setARGB(0, 0, 0, 0);
                 }
                 canvas->drawRectCoords(-kShapeSpacing/2, -kShapeSpacing/2,
                                        kShapeSpacing/2 + 3 * kShapeTypeSpacing,
                                        kShapeSpacing/2, dimPaint);
             }
         }
     }
 
-    void drawShape(SkCanvas* canvas, Shape shape, const SkPaint& paint, SkXfermode::Mode mode) {
-        SkASSERT(mode <= SkXfermode::kLastMode);
+    void drawShape(SkCanvas* canvas, Shape shape, const SkPaint& paint, SkBlendMode mode) {
+        SkASSERT(mode <= SkBlendMode::kLastMode);
         SkPaint shapePaint(paint);
         shapePaint.setAntiAlias(kSquare_Shape != shape);
-        shapePaint.setXfermodeMode(mode);
+        shapePaint.setBlendMode(mode);
 
         switch (shape) {
             case kSquare_Shape:
                 canvas->drawRectCoords(-kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2,
                                        shapePaint);
                 break;
 
             case kDiamond_Shape:
                 canvas->save();
                 canvas->rotate(45);
                 canvas->drawRectCoords(-kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2,
                                        shapePaint);
                 canvas->restore();
                 break;
 
             case kOval_Shape:
                 canvas->save();
-                canvas->rotate(static_cast<SkScalar>((511 * mode + 257) % 360));
+                canvas->rotate(static_cast<SkScalar>((511 * (int)mode + 257) % 360));
                 canvas->drawPath(fOval, shapePaint);
                 canvas->restore();
                 break;
 
             case kConcave_Shape:
                 canvas->drawPath(fConcave, shapePaint);
                 break;
 
             default:
                 SkFAIL("Invalid shape.");
         }
     }
 
 private:
     SkPaint   fLabelPaint;
     SkPath    fOval;
     SkPath    fConcave;
 
     typedef skiagm::GM INHERITED;
 };
 DEF_GM( return new AAXfermodesGM; )