Revert[2] of "add backdrop option to SaveLayerRec"

tests/RecordOptsTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #include "RecordTestUtils.h"
 
@@ skipping 89 matching lines @@
     }
 }
 
 static void assert_savelayer_restore(skiatest::Reporter* r,
                                      SkRecord* record,
                                      int i,
                                      bool shouldBeNoOped) {
     SkRecordNoopSaveLayerDrawRestores(record);
     if (shouldBeNoOped) {
         assert_type<SkRecords::NoOp>(r, *record, i);
+        assert_type<SkRecords::NoOp>(r, *record, i+1);
+    } else {
+        assert_type<SkRecords::SaveLayer>(r, *record, i);
+        assert_type<SkRecords::Restore>(r, *record, i+1);
+    }
+}
+
+static void assert_savelayer_draw_restore(skiatest::Reporter* r,
+                                          SkRecord* record,
+                                          int i,
+                                          bool shouldBeNoOped) {
+    SkRecordNoopSaveLayerDrawRestores(record);
+    if (shouldBeNoOped) {
+        assert_type<SkRecords::NoOp>(r, *record, i);
         assert_type<SkRecords::NoOp>(r, *record, i+2);
     } else {
         assert_type<SkRecords::SaveLayer>(r, *record, i);
         assert_type<SkRecords::Restore>(r, *record, i+2);
     }
 }
 
+#include "SkBlurImageFilter.h"
 DEF_TEST(RecordOpts_NoopSaveLayerDrawRestore, r) {
     SkRecord record;
     SkRecorder recorder(&record, W, H);
 
     SkRect bounds = SkRect::MakeWH(100, 200);
     SkRect   draw = SkRect::MakeWH(50, 60);
 
     SkPaint alphaOnlyLayerPaint, translucentLayerPaint, xfermodeLayerPaint;
     alphaOnlyLayerPaint.setColor(0x03000000);  // Only alpha.
     translucentLayerPaint.setColor(0x03040506);  // Not only alpha.
     xfermodeLayerPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);  // Any effect will do.
 
     SkPaint opaqueDrawPaint, translucentDrawPaint;
     opaqueDrawPaint.setColor(0xFF020202);  // Opaque.
     translucentDrawPaint.setColor(0x0F020202);  // Not opaque.
 
     // SaveLayer/Restore removed: No paint = no point.
     recorder.saveLayer(nullptr, nullptr);
         recorder.drawRect(draw, opaqueDrawPaint);
     recorder.restore();
-    assert_savelayer_restore(r, &record, 0, true);
+    assert_savelayer_draw_restore(r, &record, 0, true);
 
     // Bounds don't matter.
     recorder.saveLayer(&bounds, nullptr);
         recorder.drawRect(draw, opaqueDrawPaint);
     recorder.restore();
-    assert_savelayer_restore(r, &record, 3, true);
+    assert_savelayer_draw_restore(r, &record, 3, true);
 
     // TODO(mtklein): test case with null draw paint
 
     // No change: layer paint isn't alpha-only.
     recorder.saveLayer(nullptr, &translucentLayerPaint);
         recorder.drawRect(draw, opaqueDrawPaint);
     recorder.restore();
-    assert_savelayer_restore(r, &record, 6, false);
+    assert_savelayer_draw_restore(r, &record, 6, false);
 
     // No change: layer paint has an effect.
     recorder.saveLayer(nullptr, &xfermodeLayerPaint);
         recorder.drawRect(draw, opaqueDrawPaint);
     recorder.restore();
-    assert_savelayer_restore(r, &record, 9, false);
+    assert_savelayer_draw_restore(r, &record, 9, false);
 
     // SaveLayer/Restore removed: we can fold in the alpha!
     recorder.saveLayer(nullptr, &alphaOnlyLayerPaint);
         recorder.drawRect(draw, translucentDrawPaint);
     recorder.restore();
-    assert_savelayer_restore(r, &record, 12, true);
+    assert_savelayer_draw_restore(r, &record, 12, true);
 
     // SaveLayer/Restore removed: we can fold in the alpha!
     recorder.saveLayer(nullptr, &alphaOnlyLayerPaint);
         recorder.drawRect(draw, opaqueDrawPaint);
     recorder.restore();
-    assert_savelayer_restore(r, &record, 15, true);
+    assert_savelayer_draw_restore(r, &record, 15, true);
 
     const SkRecords::DrawRect* drawRect = assert_type<SkRecords::DrawRect>(r, record, 16);
     REPORTER_ASSERT(r, drawRect != nullptr);
     REPORTER_ASSERT(r, drawRect->paint.getColor() == 0x03020202);
+
+    // saveLayer w/ backdrop should NOT go away
+    SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(3, 3));
+    recorder.saveLayer({ nullptr, nullptr, filter, 0});
+        recorder.drawRect(draw, opaqueDrawPaint);
+    recorder.restore();
+    assert_savelayer_draw_restore(r, &record, 18, false);
 }
 
 static void assert_merge_svg_opacity_and_filter_layers(skiatest::Reporter* r,
                                                        SkRecord* record,
                                                        int i,
                                                        bool shouldBeNoOped) {
     SkRecordMergeSvgOpacityAndFilterLayers(record);
     if (shouldBeNoOped) {
         assert_type<SkRecords::NoOp>(r, *record, i);
         assert_type<SkRecords::NoOp>(r, *record, i + 6);
@@ skipping 31 matching lines @@
         SkPaint shapePaint;
         shapePaint.setColor(SK_ColorWHITE);
         canvas->drawRect(SkRect::MakeWH(SkIntToScalar(50), SkIntToScalar(50)), shapePaint);
         shape.reset(recorder.endRecordingAsPicture());
     }
     translucentFilterLayerPaint.setImageFilter(SkPictureImageFilter::Create(shape))->unref();
 
     int index = 0;
 
     {
+        SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(3, 3));
+        // first (null) should be optimized, 2nd should not
+        SkImageFilter* filters[] = { nullptr, filter.get() };
+
         // Any combination of these should cause the pattern to be optimized.
         SkRect* firstBounds[] = { nullptr, &bounds };
         SkPaint* firstPaints[] = { nullptr, &alphaOnlyLayerPaint };
         SkRect* secondBounds[] = { nullptr, &bounds };
         SkPaint* secondPaints[] = { &opaqueFilterLayerPaint, &translucentFilterLayerPaint };
 
-        for (size_t i = 0; i < SK_ARRAY_COUNT(firstBounds); ++ i) {
-            for (size_t j = 0; j < SK_ARRAY_COUNT(firstPaints); ++j) {
-                for (size_t k = 0; k < SK_ARRAY_COUNT(secondBounds); ++k) {
-                    for (size_t m = 0; m < SK_ARRAY_COUNT(secondPaints); ++m) {
-                        recorder.saveLayer(firstBounds[i], firstPaints[j]);
-                        recorder.save();
-                        recorder.clipRect(clip);
-                        recorder.saveLayer(secondBounds[k], secondPaints[m]);
-                        recorder.restore();
-                        recorder.restore();
-                        recorder.restore();
-                        assert_merge_svg_opacity_and_filter_layers(r, &record, index, true);
-                        index += 7;
+        for (auto outerF : filters) {
+            bool outerNoOped = !outerF;
+            for (auto innerF : filters) {
+                for (size_t i = 0; i < SK_ARRAY_COUNT(firstBounds); ++ i) {
+                    for (size_t j = 0; j < SK_ARRAY_COUNT(firstPaints); ++j) {
+                        for (size_t k = 0; k < SK_ARRAY_COUNT(secondBounds); ++k) {
+                            for (size_t m = 0; m < SK_ARRAY_COUNT(secondPaints); ++m) {
+                                bool innerNoOped = !secondBounds[k] && !secondPaints[m] && !innerF;
+
+                                recorder.saveLayer({firstBounds[i], firstPaints[j], outerF, 0});
+                                recorder.save();
+                                recorder.clipRect(clip);
+                                recorder.saveLayer({secondBounds[k], secondPaints[m], innerF, 0});
+                                recorder.restore();
+                                recorder.restore();
+                                recorder.restore();
+                                assert_merge_svg_opacity_and_filter_layers(r, &record, index,
+                                                                           outerNoOped);
+                                assert_savelayer_restore(r, &record, index + 3, innerNoOped);
+                                index += 7;
+                            }
+                        }
                     }
                 }
             }
         }
     }
 
     // These should cause the pattern to stay unoptimized:
     struct {
         SkPaint* firstPaint;
         SkPaint* secondPaint;
@@ skipping 47 matching lines @@
     recorder.saveLayer(nullptr, &opaqueFilterLayerPaint);
     recorder.restore();
     recorder.restore();
     SkRecordMergeSvgOpacityAndFilterLayers(&record);
     assert_type<SkRecords::SaveLayer>(r, record, index);
     assert_type<SkRecords::SaveLayer>(r, record, index + 1);
     assert_type<SkRecords::Restore>(r, record, index + 2);
     assert_type<SkRecords::Restore>(r, record, index + 3);
     index += 4;
 }