Try out scalar picture sizes

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"
@@ skipping 403 matching lines @@
                 }
             }
         }
     }
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
         SkSafeUnref(filters[i].fFilter);
     }
 }
 
-static void drawSaveLayerPicture(int width, int height, int tileSize, SkBBHFactory* factory, SkBitmap* result) {
+static void draw_saveLayer_picture(int width, int height, int tileSize, 
+                                   SkBBHFactory* factory, SkBitmap* result) {
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(50), 0);
 
     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode));
     SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get()));
     SkAutoTUnref<SkImageFilter> imageFilter(SkMatrixImageFilter::Create(matrix, SkPaint::kNone_FilterLevel, cfif.get()));
 
     SkPaint paint;
     paint.setImageFilter(imageFilter.get());
     SkPictureRecorder recorder;
     SkRect bounds = SkRect::Make(SkIRect::MakeXYWH(0, 0, 50, 50));
-    SkCanvas* recordingCanvas = recorder.beginRecording(width, height, factory, 0);
+    SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(width), 
+                                                        SkIntToScalar(height), 
+                                                        factory, 0);
     recordingCanvas->translate(-55, 0);
     recordingCanvas->saveLayer(&bounds, &paint);
     recordingCanvas->restore();
     SkAutoTUnref<SkPicture> picture1(recorder.endRecording());
 
     result->allocN32Pixels(width, height);
     SkCanvas canvas(*result);
     canvas.clear(0);
     canvas.clipRect(SkRect::Make(SkIRect::MakeWH(tileSize, tileSize)));
     canvas.drawPicture(picture1.get());
 }
 
 DEF_TEST(ImageFilterDrawMatrixBBH, reporter) {
     // Check that matrix filter when drawn tiled with BBH exactly
     // matches the same thing drawn without BBH.
     // Tests pass by not asserting.
 
     const int width = 200, height = 200;
     const int tileSize = 100;
     SkBitmap result1, result2;
     SkRTreeFactory factory;
 
-    drawSaveLayerPicture(width, height, tileSize, &factory, &result1);
-    drawSaveLayerPicture(width, height, tileSize, NULL, &result2);
+    draw_saveLayer_picture(width, height, tileSize, &factory, &result1);
+    draw_saveLayer_picture(width, height, tileSize, NULL, &result2);
 
     for (int y = 0; y < height; y++) {
         int diffs = memcmp(result1.getAddr32(0, y), result2.getAddr32(0, y), result1.rowBytes());
         REPORTER_ASSERT(reporter, !diffs);
         if (diffs) {
             break;
         }
     }
 }
 
@@ skipping 34 matching lines @@
     SkAutoTUnref<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
     SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-132, -132, 234, 234);
     filter2->filterBounds(bounds, SkMatrix::I(), &bounds);
 
     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 }
 
-static void drawBlurredRect(SkCanvas* canvas) {
+static void draw_blurred_rect(SkCanvas* canvas) {
     SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(SkIntToScalar(8), 0));
     SkPaint filterPaint;
     filterPaint.setColor(SK_ColorWHITE);
     filterPaint.setImageFilter(filter);
     canvas->saveLayer(NULL, &filterPaint);
     SkPaint whitePaint;
     whitePaint.setColor(SK_ColorWHITE);
     canvas->drawRect(SkRect::Make(SkIRect::MakeWH(4, 4)), whitePaint);
     canvas->restore();
 }
 
-static void drawPictureClipped(SkCanvas* canvas, const SkRect& clipRect, const SkPicture* picture) {
+static void draw_picture_clipped(SkCanvas* canvas, const SkRect& clipRect, const SkPicture* picture) {
     canvas->save();
     canvas->clipRect(clipRect);
     canvas->drawPicture(picture);
     canvas->restore();
 }
 
 DEF_TEST(ImageFilterDrawTiledBlurRTree, reporter) {
     // Check that the blur filter when recorded with RTree acceleration,
     // and drawn tiled (with subsequent clip rects) exactly
     // matches the same filter drawn with without RTree acceleration.
     // This tests that the "bleed" from the blur into the otherwise-blank
     // tiles is correctly rendered.
     // Tests pass by not asserting.
 
     int width = 16, height = 8;
     SkBitmap result1, result2;
     result1.allocN32Pixels(width, height);
     result2.allocN32Pixels(width, height);
     SkCanvas canvas1(result1);
     SkCanvas canvas2(result2);
     int tileSize = 8;
 
     canvas1.clear(0);
     canvas2.clear(0);
 
     SkRTreeFactory factory;
 
     SkPictureRecorder recorder1, recorder2;
     // The only difference between these two pictures is that one has RTree aceleration.
-    SkCanvas* recordingCanvas1 = recorder1.beginRecording(width, height, NULL, 0);
-    SkCanvas* recordingCanvas2 = recorder2.beginRecording(width, height, &factory, 0);
-    drawBlurredRect(recordingCanvas1);
-    drawBlurredRect(recordingCanvas2);
+    SkCanvas* recordingCanvas1 = recorder1.beginRecording(SkIntToScalar(width), 
+                                                          SkIntToScalar(height), 
+                                                          NULL, 0);
+    SkCanvas* recordingCanvas2 = recorder2.beginRecording(SkIntToScalar(width), 
+                                                          SkIntToScalar(height), 
+                                                          &factory, 0);
+    draw_blurred_rect(recordingCanvas1);
+    draw_blurred_rect(recordingCanvas2);
     SkAutoTUnref<SkPicture> picture1(recorder1.endRecording());
     SkAutoTUnref<SkPicture> picture2(recorder2.endRecording());
     for (int y = 0; y < height; y += tileSize) {
         for (int x = 0; x < width; x += tileSize) {
             SkRect tileRect = SkRect::Make(SkIRect::MakeXYWH(x, y, tileSize, tileSize));
-            drawPictureClipped(&canvas1, tileRect, picture1);
-            drawPictureClipped(&canvas2, tileRect, picture2);
+            draw_picture_clipped(&canvas1, tileRect, picture1);
+            draw_picture_clipped(&canvas2, tileRect, picture2);
         }
     }
     for (int y = 0; y < height; y++) {
         int diffs = memcmp(result1.getAddr32(0, y), result2.getAddr32(0, y), result1.rowBytes());
         REPORTER_ASSERT(reporter, !diffs);
         if (diffs) {
             break;
         }
     }
 }
@@ skipping 374 matching lines @@
 }
 
 DEF_GPUTEST(XfermodeImageFilterCroppedInputGPU, reporter, factory) {
     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
                                                          SkImageInfo::MakeN32Premul(1, 1),
                                                          0));
     test_xfermode_cropped_input(device, reporter);
 }
 #endif