Convert unit tests, GMs from SkBitmapSource to SkImagesource

gm/imagefiltersgraph.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 "gm.h"
 
 #include "SkArithmeticMode.h"
 #include "SkDevice.h"
-#include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkColorFilter.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkColorMatrixFilter.h"
+#include "SkImage.h"
+#include "SkImageSource.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMergeImageFilter.h"
 #include "SkMorphologyImageFilter.h"
 #include "SkTestImageFilters.h"
 #include "SkXfermodeImageFilter.h"
 
 // More closely models how Blink's OffsetFilter works as of 10/23/13. SkOffsetImageFilter doesn't
 // perform a draw and this one does.
 class SimpleOffsetFilter : public SkImageFilter {
@@ skipping 73 matching lines @@
 class ImageFiltersGraphGM : public skiagm::GM {
 public:
     ImageFiltersGraphGM() {}
 
 protected:
 
     SkString onShortName() override {
         return SkString("imagefiltersgraph");
     }
 
-    void drawClippedBitmap(SkCanvas* canvas, const SkBitmap& bitmap, const SkPaint& paint) {
-        canvas->save();
-        canvas->clipRect(SkRect::MakeXYWH(0, 0,
-            SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height())));
-        canvas->drawBitmap(bitmap, 0, 0, &paint);
-        canvas->restore();
-    }
-
     SkISize onISize() override { return SkISize::Make(500, 150); }
 
     void onOnceBeforeDraw() override {
-        fBitmap = sk_tool_utils::create_string_bitmap(100, 100, SK_ColorWHITE, 20, 70, 96, "e");
+        fImage.reset(SkImage::NewFromBitmap(
+            sk_tool_utils::create_string_bitmap(100, 100, SK_ColorWHITE, 20, 70, 96, "e")));
     }
 
     void onDraw(SkCanvas* canvas) override {
         canvas->clear(SK_ColorBLACK);
         {
-            SkAutoTUnref<SkImageFilter> bitmapSource(SkBitmapSource::Create(fBitmap));
+            SkAutoTUnref<SkImageFilter> bitmapSource(SkImageSource::Create(fImage));
             SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
                                                          SkXfermode::kSrcIn_Mode));
             SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource));
             SkAutoTUnref<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur));
             SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf, erode));
             SkAutoTUnref<SkImageFilter> merge(SkMergeImageFilter::Create(blur, color));
 
             SkPaint paint;
             paint.setImageFilter(merge);
             canvas->drawPaint(paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
             SkAutoTUnref<SkImageFilter> morph(SkDilateImageFilter::Create(5, 5));
 
             SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
                                     0, SK_Scalar1, 0, 0, 0,
                                     0, 0, SK_Scalar1, 0, 0,
                                     0, 0, 0, 0.5f, 0 };
 
             SkAutoTUnref<SkColorFilter> matrixFilter(SkColorMatrixFilter::Create(matrix));
             SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter, morph));
             SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
             SkAutoTUnref<SkImageFilter> blendColor(SkXfermodeImageFilter::Create(mode, colorMorph));
 
             SkPaint paint;
             paint.setImageFilter(blendColor);
-            drawClippedBitmap(canvas, fBitmap, paint);
+            DrawClippedImage(canvas, fImage, paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
             SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
                                     0, SK_Scalar1, 0, 0, 0,
                                     0, 0, SK_Scalar1, 0, 0,
                                     0, 0, 0, 0.5f, 0 };
             SkAutoTUnref<SkColorMatrixFilter> matrixCF(SkColorMatrixFilter::Create(matrix));
             SkAutoTUnref<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Create(matrixCF));
             SkAutoTUnref<SkImageFilter> offsetFilter(
                 SimpleOffsetFilter::Create(10.0f, 10.f, matrixFilter));
 
             SkAutoTUnref<SkXfermode> arith(SkArithmeticMode::Create(0, SK_Scalar1, SK_Scalar1, 0));
             SkAutoTUnref<SkXfermodeImageFilter> arithFilter(
                 SkXfermodeImageFilter::Create(arith, matrixFilter, offsetFilter));
 
             SkPaint paint;
             paint.setImageFilter(arithFilter);
-            drawClippedBitmap(canvas, fBitmap, paint);
+            DrawClippedImage(canvas, fImage, paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
             SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(
               SkIntToScalar(10), SkIntToScalar(10)));
 
             SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcIn_Mode));
             SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
             SkAutoTUnref<SkImageFilter> blend(
                 SkXfermodeImageFilter::Create(mode, blur, nullptr, &cropRect));
 
             SkPaint paint;
             paint.setImageFilter(blend);
-            drawClippedBitmap(canvas, fBitmap, paint);
+            DrawClippedImage(canvas, fImage, paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
             // Test that crop offsets are absolute, not relative to the parent's crop rect.
             SkAutoTUnref<SkColorFilter> cf1(SkColorFilter::CreateModeFilter(SK_ColorBLUE,
                                                                             SkXfermode::kSrcIn_Mode));
             SkAutoTUnref<SkColorFilter> cf2(SkColorFilter::CreateModeFilter(SK_ColorGREEN,
                                                                             SkXfermode::kSrcIn_Mode));
             SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
                                                                SkIntToScalar(80), SkIntToScalar(80)));
             SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
                                                                SkIntToScalar(60), SkIntToScalar(60)));
             SkAutoTUnref<SkImageFilter> color1(SkColorFilterImageFilter::Create(cf1, nullptr, &outerRect));
             SkAutoTUnref<SkImageFilter> color2(SkColorFilterImageFilter::Create(cf2, color1, &innerRect));
 
             SkPaint paint;
             paint.setImageFilter(color2);
             paint.setColor(SK_ColorRED);
             canvas->drawRect(SkRect::MakeXYWH(0, 0, 100, 100), paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
     }
 
 private:
+    static void DrawClippedImage(SkCanvas* canvas, const SkImage* image, const SkPaint& paint) {
+        canvas->save();
+        canvas->clipRect(SkRect::MakeIWH(image->width(), image->height()));
+        canvas->drawImage(image, 0, 0, &paint);
+        canvas->restore();
+    }
+
+    SkAutoTUnref<SkImage> fImage;
+
     typedef GM INHERITED;
-    SkBitmap fBitmap;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new ImageFiltersGraphGM;)