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

tests/RecordingXfermodeTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 
 #include "../include/core/SkCanvas.h"
@@ skipping 16 matching lines @@
         fCircleBM.allocPixels(SkImageInfo::MakeN32Premul(100, 100));
         SkCanvas canvas(fCircleBM);
         canvas.clear(0xffffffff);
         SkPaint circlePaint;
         circlePaint.setColor(0xff000000);
         canvas.drawCircle(50, 50, 50, circlePaint);
     }
 
     const SkImageInfo& imageInfo() const { return fImageInfo; }
 
-    void draw(SkCanvas* canvas, const SkRect& clipRect, SkXfermode::Mode mode) const {
+    void draw(SkCanvas* canvas, const SkRect& clipRect, SkBlendMode mode) const {
         SkPaint greenPaint;
         greenPaint.setColor(0xff008000);
         SkPaint blackPaint;
         blackPaint.setColor(0xff000000);
         SkPaint whitePaint;
         whitePaint.setColor(0xffffffff);
         SkPaint layerPaint;
         layerPaint.setColor(0xff000000);
-        layerPaint.setXfermodeMode(mode);
+        layerPaint.setBlendMode(mode);
         SkRect canvasRect(SkRect::MakeWH(SkIntToScalar(fImageInfo.width()),
                                          SkIntToScalar(fImageInfo.height())));
 
         canvas->clipRect(clipRect);
         canvas->clear(0xff000000);
 
         canvas->saveLayer(nullptr, &blackPaint);
             canvas->drawRect(canvasRect, greenPaint);
             canvas->saveLayer(nullptr, &layerPaint);
                 canvas->drawBitmapRect(fCircleBM, SkRect::MakeXYWH(20,20,60,60), &blackPaint);
             canvas->restore();
         canvas->restore();
     }
 
  private:
     const SkImageInfo fImageInfo;
     SkBitmap fCircleBM;
 };
 
 class RecordingStrategy {
  public:
     virtual ~RecordingStrategy() {}
     virtual const SkBitmap& recordAndReplay(const Drawer& drawer,
                                             const SkRect& intoClip,
-                                            SkXfermode::Mode) = 0;
+                                            SkBlendMode) = 0;
 };
 
 class BitmapBackedCanvasStrategy : public RecordingStrategy {
     // This version just draws into a bitmap-backed canvas.
  public:
     BitmapBackedCanvasStrategy(const SkImageInfo& imageInfo) {
         fBitmap.allocPixels(imageInfo);
     }
 
-    virtual const SkBitmap& recordAndReplay(const Drawer& drawer,
-                                            const SkRect& intoClip,
-                                            SkXfermode::Mode mode) {
+    const SkBitmap& recordAndReplay(const Drawer& drawer, const SkRect& intoClip,
+                                    SkBlendMode mode) override {
         SkCanvas canvas(fBitmap);
         canvas.clear(0xffffffff);
         // Note that the scene is drawn just into the clipped region!
         canvas.clipRect(intoClip);
         drawer.draw(&canvas, intoClip, mode); // Shouild be canvas-wide...
         return fBitmap;
     }
 
  private:
     SkBitmap fBitmap;
 };
 
 class PictureStrategy : public RecordingStrategy {
     // This version draws the entire scene into an SkPictureRecorder.
     // Then it then replays the scene through a clip rectangle.
     // This backend proved to be buggy.
  public:
     PictureStrategy(const SkImageInfo& imageInfo) {
         fBitmap.allocPixels(imageInfo);
         fWidth  = imageInfo.width();
         fHeight = imageInfo.height();
     }
 
-    virtual const SkBitmap& recordAndReplay(const Drawer& drawer,
-                                            const SkRect& intoClip,
-                                            SkXfermode::Mode mode) {
+    const SkBitmap& recordAndReplay(const Drawer& drawer, const SkRect& intoClip,
+                                    SkBlendMode mode) override {
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
         SkRect canvasRect(SkRect::MakeWH(SkIntToScalar(fWidth),SkIntToScalar(fHeight)));
         SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(fWidth),
                                                    SkIntToScalar(fHeight),
                                                    &factory);
         drawer.draw(canvas, canvasRect, mode);
         sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
         SkCanvas replayCanvas(fBitmap);
@@ skipping 17 matching lines @@
     const Drawer drawer;
 
     BitmapBackedCanvasStrategy golden(drawer.imageInfo());
     PictureStrategy picture(drawer.imageInfo());
 
 #if !FINEGRAIN
     unsigned numErrors = 0;
     SkString errors;
 #endif
 
-    for (int iMode = 0; iMode < int(SkXfermode::kLastMode); iMode++) {
+    for (int iMode = 0; iMode < int(SkBlendMode::kLastMode); iMode++) {
         const SkRect& clip = SkRect::MakeXYWH(100, 0, 100, 100);
-        SkXfermode::Mode mode = SkXfermode::Mode(iMode);
+        SkBlendMode mode = SkBlendMode(iMode);
 
         const SkBitmap& goldenBM = golden.recordAndReplay(drawer, clip, mode);
         const SkBitmap& pictureBM = picture.recordAndReplay(drawer, clip, mode);
 
         size_t pixelsSize = goldenBM.getSize();
         REPORTER_ASSERT(reporter, pixelsSize == pictureBM.getSize());
 
         // The pixel arrays should match.
 #if FINEGRAIN
         REPORTER_ASSERT(reporter,
                         0 == memcmp(goldenBM.getPixels(), pictureBM.getPixels(), pixelsSize));
 #else
         if (memcmp(goldenBM.getPixels(), pictureBM.getPixels(), pixelsSize)) {
             numErrors++;
             errors.appendf("For SkXfermode %d %s:    SkPictureRecorder bitmap is wrong\n",
                            iMode, SkXfermode::ModeName(mode));
         }
 #endif
     }
 
 #if !FINEGRAIN
     REPORTER_ASSERT_MESSAGE(reporter, 0 == numErrors, errors.c_str());
 #endif
 }