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

fuzz/FilterFuzz.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Fuzz.h"
 #include "Sk1DPathEffect.h"
 #include "Sk2DPathEffect.h"
 #include "SkAlphaThresholdFilter.h"
@@ skipping 136 matching lines @@
 }
 
 static SkMatrix make_matrix() {
     SkMatrix m;
     for (int i = 0; i < 9; ++i) {
         m[i] = make_scalar();
     }
     return m;
 }
 
-static SkXfermode::Mode make_xfermode() {
-    return static_cast<SkXfermode::Mode>(R(SkXfermode::kLastMode+1));
+static SkBlendMode make_blendmode() {
+    return static_cast<SkBlendMode>(R((int)SkBlendMode::kLastMode+1));
 }
 
 static SkPaint::Align make_paint_align() {
     return static_cast<SkPaint::Align>(R(SkPaint::kRight_Align+1));
 }
 
 static SkPaint::Hinting make_paint_hinting() {
     return static_cast<SkPaint::Hinting>(R(SkPaint::kFull_Hinting+1));
 }
 
@@ skipping 193 matching lines @@
             uint8_t tableR[256];
             uint8_t tableG[256];
             uint8_t tableB[256];
             rand_color_table(tableA);
             rand_color_table(tableR);
             rand_color_table(tableG);
             rand_color_table(tableB);
             return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB);
         }
         case 3:
-            return SkColorFilter::MakeModeFilter(make_color(), make_xfermode());
+            return SkColorFilter::MakeModeFilter(make_color(), (SkXfermode::Mode)make_blendmode());
         case 4:
             return SkColorMatrixFilter::MakeLightingFilter(make_color(), make_color());
         case 5:
         default:
             break;
     }
     return nullptr;
 }
 
 static SkPath make_path() {
@@ skipping 115 matching lines @@
     paint.setFakeBoldText(make_bool());
     paint.setDevKernText(make_bool());
     paint.setFilterQuality(make_filter_quality());
     paint.setStyle(make_paint_style());
     paint.setColor(make_color());
     paint.setStrokeWidth(make_scalar());
     paint.setStrokeMiter(make_scalar());
     paint.setStrokeCap(make_paint_cap());
     paint.setStrokeJoin(make_paint_join());
     paint.setColorFilter(make_color_filter());
-    paint.setXfermodeMode(make_xfermode());
+    paint.setBlendMode(make_blendmode());
     paint.setPathEffect(make_path_effect());
     paint.setMaskFilter(make_mask_filter());
 
     if (false) {
         // our validating buffer does not support typefaces yet, so skip this for now
         paint.setTypeface(SkTypeface::MakeFromName(make_font_name().c_str(),make_typeface_style()));
     }
 
     SkLayerRasterizer::Builder rasterizerBuilder;
     SkPaint paintForRasterizer;
@@ skipping 14 matching lines @@
 
 static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
     sk_sp<SkImageFilter> filter;
 
     // Add a 1 in 3 chance to get a nullptr input
     if (canBeNull && (R(3) == 1)) {
         return filter;
     }
 
     enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
-           XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
+           BLENDMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
            DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
            MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
 
     switch (R(NUM_FILTERS)) {
     case ALPHA_THRESHOLD:
         filter = SkAlphaThresholdFilter::Make(make_region(),
                                               make_scalar(),
                                               make_scalar(),
                                               make_image_filter());
         break;
     case MERGE:
         filter = SkMergeImageFilter::Make(make_image_filter(),
                                           make_image_filter(),
-                                          make_xfermode());
+                                          (SkXfermode::Mode)make_blendmode());
         break;
     case COLOR: {
         sk_sp<SkColorFilter> cf(make_color_filter());
         filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
                     : nullptr;
         break;
     }
     case LUT3D: {
         int cubeDimension;
         sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
         sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(std::move(lut3D), cubeDimension));
         filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
                     : nullptr;
         break;
     }
     case BLUR:
         filter = SkBlurImageFilter::Make(make_scalar(true),
                                          make_scalar(true),
                                          make_image_filter());
         break;
     case MAGNIFIER:
         filter = SkMagnifierImageFilter::Make(make_rect(),
                                               make_scalar(true),
                                               make_image_filter());
         break;
-    case XFERMODE:
-        filter = SkXfermodeImageFilter::Make(SkXfermode::Make(make_xfermode()),
+    case BLENDMODE:
+        filter = SkXfermodeImageFilter::Make(make_blendmode(),
                                              make_image_filter(),
                                              make_image_filter(),
                                              nullptr);
         break;
     case OFFSET:
         filter = SkOffsetImageFilter::Make(make_scalar(), make_scalar(), make_image_filter());
         break;
     case MATRIX:
         filter = SkImageFilter::MakeMatrixFilter(make_matrix(),
                                                  (SkFilterQuality)R(4),
@@ skipping 180 matching lines @@
 DEF_FUZZ(SerializedImageFilter, f) {
     fuzz = f;
     SkImageFilter* filter = make_serialized_image_filter();
 
     SkPaint paint;
     SkSafeUnref(paint.setImageFilter(filter));
     SkBitmap bitmap;
     SkCanvas canvas(bitmap);
     drawClippedBitmap(&canvas, 0, 0, paint);
 }