Fix a problem with hiDPI filters vs tiled SkPicture playback.

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 "SkBicubicImageFilter.h"
 #include "SkBitmap.h"
 #include "SkBitmapDevice.h"
 #include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkColorMatrixFilter.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
+#include "SkFlattenableBuffers.h"
 #include "SkLightingImageFilter.h"
 #include "SkMatrixConvolutionImageFilter.h"
 #include "SkMergeImageFilter.h"
 #include "SkMorphologyImageFilter.h"
 #include "SkOffsetImageFilter.h"
+#include "SkPicture.h"
 #include "SkRect.h"
 #include "SkTileImageFilter.h"
 #include "SkXfermodeImageFilter.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #include "SkGpuDevice.h"
 #endif
 
 static const int kBitmapSize = 4;
 
+namespace {
+
+class MatrixTestImageFilter : public SkImageFilter {
+public:
+    MatrixTestImageFilter(skiatest::Reporter* reporter, const SkMatrix& expectedMatrix)
+      : SkImageFilter(0), fReporter(reporter), fExpectedMatrix(expectedMatrix) {
+    }
+
+    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix& ctm,
+                               SkBitmap* result, SkIPoint* offset) SK_OVERRIDE {
+        REPORTER_ASSERT(fReporter, ctm == fExpectedMatrix);
+        return true;
+    }
+
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
+
+protected:
+    explicit MatrixTestImageFilter(SkReadBuffer& buffer) : SkImageFilter(0) {
+        fReporter = static_cast<skiatest::Reporter*>(buffer.readFunctionPtr());
+        buffer.readMatrix(&fExpectedMatrix);
+    }
+
+    virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+        buffer.writeFunctionPtr(fReporter);
+        buffer.writeMatrix(fExpectedMatrix);
+    }
+
+private:
+    skiatest::Reporter* fReporter;
+    SkMatrix fExpectedMatrix;
+};
+
+}
+
 static void make_small_bitmap(SkBitmap& bitmap) {
     bitmap.setConfig(SkBitmap::kARGB_8888_Config, kBitmapSize, kBitmapSize);
     bitmap.allocPixels();
     SkBitmapDevice device(bitmap);
     SkCanvas canvas(&device);
     canvas.clear(0x00000000);
     SkPaint darkPaint;
     darkPaint.setColor(0xFF804020);
     SkPaint lightPaint;
     lightPaint.setColor(0xFF244484);
@@ skipping 177 matching lines @@
 }
 
 DEF_TEST(ImageFilterCropRect, reporter) {
     SkBitmap temp;
     temp.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
     temp.allocPixels();
     SkBitmapDevice device(temp);
     test_crop_rects(&device, reporter);
 }
 
+DEF_TEST(ImageFilterMatrixTest, reporter) {
+    SkBitmap temp;
+    temp.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
+    temp.allocPixels();
+    SkBitmapDevice device(temp);
+    SkCanvas canvas(&device);
+    canvas.scale(SkIntToScalar(2), SkIntToScalar(2));
+
+    SkMatrix expectedMatrix = canvas.getTotalMatrix();
+
+    SkPicture picture;
+    SkCanvas* recordingCanvas = picture.beginRecording(100, 100,
+        SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
+
+    SkPaint paint;
+    SkAutoTUnref<MatrixTestImageFilter> imageFilter(
+        new MatrixTestImageFilter(reporter, expectedMatrix));
+    paint.setImageFilter(imageFilter.get());
+    SkCanvas::SaveFlags saveFlags = static_cast<SkCanvas::SaveFlags>(
+        SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag);
+    recordingCanvas->saveLayer(NULL, &paint, saveFlags);
+    SkPaint solidPaint;
+    solidPaint.setColor(0xFFFFFFFF);
+    recordingCanvas->save();
+    recordingCanvas->scale(SkIntToScalar(10), SkIntToScalar(10));
+    recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(100, 100)), solidPaint);
+    recordingCanvas->restore(); // scale
+    recordingCanvas->restore(); // saveLayer
+    picture.endRecording();
+
+    canvas.drawPicture(picture);
+}
+
 #if SK_SUPPORT_GPU
 DEF_GPUTEST(ImageFilterCropRectGPU, reporter, factory) {
     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
     SkGpuDevice device(context, SkBitmap::kARGB_8888_Config, 100, 100);
     test_crop_rects(&device, reporter);
 }
 #endif