Remove SK_SUPPORT_LEGACY_DEEPFLATTENING.

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 40 matching lines @@
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context& ctx,
                                SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
         REPORTER_ASSERT(fReporter, ctx.ctm() == fExpectedMatrix);
         return true;
     }
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
 
 protected:
-#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
-    explicit MatrixTestImageFilter(SkReadBuffer& buffer) : SkImageFilter(0, NULL) {
-        fReporter = static_cast<skiatest::Reporter*>(buffer.readFunctionPtr());
-        buffer.readMatrix(&fExpectedMatrix);
-    }
-#endif
-
     virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
         this->INHERITED::flatten(buffer);
         buffer.writeFunctionPtr(fReporter);
         buffer.writeMatrix(fExpectedMatrix);
     }
 
 private:
     skiatest::Reporter* fReporter;
     SkMatrix fExpectedMatrix;
-    
+
     typedef SkImageFilter INHERITED;
 };
 
 }
 
 SkFlattenable* MatrixTestImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     skiatest::Reporter* reporter = (skiatest::Reporter*)buffer.readFunctionPtr();
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
@@ skipping 392 matching lines @@
                 }
             }
         }
     }
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
         SkSafeUnref(filters[i].fFilter);
     }
 }
 
-static void draw_saveLayer_picture(int width, int height, int tileSize, 
+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(SkIntToScalar(width), 
-                                                        SkIntToScalar(height), 
+    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)));
@@ skipping 102 matching lines @@
     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(SkIntToScalar(width), 
-                                                          SkIntToScalar(height), 
+    SkCanvas* recordingCanvas1 = recorder1.beginRecording(SkIntToScalar(width),
+                                                          SkIntToScalar(height),
                                                           NULL, 0);
-    SkCanvas* recordingCanvas2 = recorder2.beginRecording(SkIntToScalar(width), 
-                                                          SkIntToScalar(height), 
+    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));
             draw_picture_clipped(&canvas1, tileRect, picture1);
             draw_picture_clipped(&canvas2, tileRect, picture2);
@@ skipping 452 matching lines @@
 
 DEF_GPUTEST(TestNegativeBlurSigmaGPU, reporter, factory) {
     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
                                                          SkImageInfo::MakeN32Premul(1, 1),
                                                          gProps,
                                                          0));
     test_negative_blur_sigma(device, reporter);
 }
 #endif