Convert unit tests, GMs from SkBitmapSource to SkImagesource

tests/ImageFilterTest.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 "SkBitmap.h"
 #include "SkBitmapDevice.h"
-#include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkColorMatrixFilter.h"
 #include "SkComposeImageFilter.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkFlattenableSerialization.h"
 #include "SkGradientShader.h"
+#include "SkImage.h"
 #include "SkImageSource.h"
 #include "SkLightingImageFilter.h"
 #include "SkMatrixConvolutionImageFilter.h"
 #include "SkMergeImageFilter.h"
 #include "SkMorphologyImageFilter.h"
 #include "SkOffsetImageFilter.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkPicture.h"
 #include "SkPictureImageFilter.h"
 #include "SkPictureRecorder.h"
@@ skipping 55 matching lines @@
     return new MatrixTestImageFilter(reporter, matrix);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void MatrixTestImageFilter::toString(SkString* str) const {
     str->appendf("MatrixTestImageFilter: (");
     str->append(")");
 }
 #endif
 
-static void make_small_bitmap(SkBitmap& bitmap) {
-    bitmap.allocN32Pixels(kBitmapSize, kBitmapSize);
-    SkCanvas canvas(bitmap);
-    canvas.clear(0x00000000);
+static SkImage* make_small_image() {
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(kBitmapSize, kBitmapSize));
+    SkCanvas* canvas = surface->getCanvas();
+    canvas->clear(0x00000000);
     SkPaint darkPaint;
     darkPaint.setColor(0xFF804020);
     SkPaint lightPaint;
     lightPaint.setColor(0xFF244484);
     const int i = kBitmapSize / 4;
     for (int y = 0; y < kBitmapSize; y += i) {
         for (int x = 0; x < kBitmapSize; x += i) {
-            canvas.save();
-            canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
-            canvas.drawRect(SkRect::MakeXYWH(0, 0,
+            canvas->save();
+            canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
+            canvas->drawRect(SkRect::MakeXYWH(0, 0,
                                              SkIntToScalar(i),
                                              SkIntToScalar(i)), darkPaint);
-            canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
+            canvas->drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
                                              0,
                                              SkIntToScalar(i),
                                              SkIntToScalar(i)), lightPaint);
-            canvas.drawRect(SkRect::MakeXYWH(0,
+            canvas->drawRect(SkRect::MakeXYWH(0,
                                              SkIntToScalar(i),
                                              SkIntToScalar(i),
                                              SkIntToScalar(i)), lightPaint);
-            canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
+            canvas->drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
                                              SkIntToScalar(i),
                                              SkIntToScalar(i),
                                              SkIntToScalar(i)), darkPaint);
-            canvas.restore();
+            canvas->restore();
         }
     }
+
+    return surface->newImageSnapshot();
 }
 
 static SkImageFilter* make_scale(float amount, SkImageFilter* input = nullptr) {
     SkScalar s = amount;
     SkScalar matrix[20] = { s, 0, 0, 0, 0,
                             0, s, 0, 0, 0,
                             0, 0, s, 0, 0,
                             0, 0, 0, s, 0 };
     SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
     return SkColorFilterImageFilter::Create(filter, input);
@@ skipping 98 matching lines @@
         canvas.clear(0x0);
         SkRect rect = SkRect::Make(SkIRect::MakeWH(kBitmapSize, kBitmapSize));
         canvas.drawRect(rect, paint);
         uint32_t pixel = *result.getAddr32(0, 0);
         // The result here should be green, since we have effectively shifted blue to green.
         REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
     }
 
     {
         // Tests pass by not asserting
-        SkBitmap bitmap, result;
-        make_small_bitmap(bitmap);
+        SkAutoTUnref<SkImage> image(make_small_image());
+        SkBitmap result;
         result.allocN32Pixels(kBitmapSize, kBitmapSize);
 
         {
             // This tests for :
             // 1 ) location at (0,0,1)
             SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
             // 2 ) location and target at same value
             SkPoint3 target = SkPoint3::Make(location.fX, location.fY, location.fZ);
             // 3 ) large negative specular exponent value
             SkScalar specularExponent = -1000;
 
-            SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
+            SkAutoTUnref<SkImageFilter> bmSrc(SkImageSource::Create(image));
             SkPaint paint;
             paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
                     location, target, specularExponent, 180,
                     0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
                     bmSrc))->unref();
             SkCanvas canvas(result);
             SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                       SkIntToScalar(kBitmapSize));
             canvas.drawRect(r, paint);
         }
@@ skipping 149 matching lines @@
     SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkScalar kernel[9] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     SkISize kernelSize = SkISize::Make(3, 3);
     SkScalar gain = SK_Scalar1, bias = 0;
     SkScalar five = SkIntToScalar(5);
 
-    SkAutoTUnref<SkImageFilter> gradient_source(SkBitmapSource::Create(make_gradient_circle(64, 64)));
+    SkAutoTUnref<SkImage> gradientImage(SkImage::NewFromBitmap(make_gradient_circle(64, 64)));

[robertphillips, 2015/09/15 17:43:52]

gradientSource ?

[f(malita), 2015/09/15 18:12:54]

Done.

+    SkAutoTUnref<SkImageFilter> gradient_source(SkImageSource::Create(gradientImage));
     SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(five, five));
     SkMatrix matrix;
 
     matrix.setTranslate(SK_Scalar1, SK_Scalar1);
     matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
 
     SkRTreeFactory factory;
     SkPictureRecorder recorder;
     SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
 
@@ skipping 867 matching lines @@
                                                          SkSurface::kNo_Budgeted,
                                                          SkImageInfo::MakeN32Premul(1, 1),
                                                          0,
                                                          &props,
                                                          SkGpuDevice::kUninit_InitContents));
     SkImageFilter::Proxy proxy(device);
 
     test_negative_blur_sigma(&proxy, reporter);
 }
 #endif