Fix for saveLayer() with filters vs. the BBox Hierarchy.

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 391 matching lines @@
                 }
             }
         }
     }
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
         SkSafeUnref(filters[i].fFilter);
     }
 }
 
+static void drawBlurredRect(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) {
+    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);
+    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);
+        }
+    }
+    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;
+        }
+    }
+}
+
 DEF_TEST(ImageFilterMatrixConvolution, reporter) {
     // Check that a 1x3 filter does not cause a spurious assert.
     SkScalar kernel[3] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     SkISize kernelSize = SkISize::Make(1, 3);
     SkScalar gain = SK_Scalar1, bias = 0;
     SkIPoint kernelOffset = SkIPoint::Make(0, 0);
 
     SkAutoTUnref<SkImageFilter> filter(
@@ skipping 339 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