switch from MockCanvas to DisplayListBuilder in layer unit tests (#41889)

Part of an ongoing set of efforts to address flutter/flutter#106448

The layer unittests have been using a MockCanvas class to record the painting of trees of layers and then testing for the expected output.

A while back a similar mechanism was created to compare DisplayList output and to print out a human-friendly version of the differences found, but it was only used in a few tests written at the time it was created and a few since then.

This is the first in a series of PRs that will move all the rest of the unit tests onto the new DL comparison mechanism, starting with the layer types that just do basic drawing. Some of the remaining layers will require creating new hooks in, for instance, the Texture registry, the performance overlay TextBlob generation, etc.

Author: flar

display_list/display_list_unittests.cc

@@ -92,6 +92,22 @@ class DisplayListTestBase : public BaseT {
 };
 using DisplayListTest = DisplayListTestBase<::testing::Test>;
 
+TEST_F(DisplayListTest, EmptyBuild) {
+  DisplayListBuilder builder;
+  auto dl = builder.Build();
+  EXPECT_EQ(dl->op_count(), 0u);
+  EXPECT_EQ(dl->bytes(), sizeof(DisplayList));
+}
+
+TEST_F(DisplayListTest, EmptyRebuild) {
+  DisplayListBuilder builder;
+  auto dl1 = builder.Build();
+  auto dl2 = builder.Build();
+  auto dl3 = builder.Build();
+  ASSERT_TRUE(dl1->Equals(dl2));
+  ASSERT_TRUE(dl2->Equals(dl3));
+}
+
 TEST_F(DisplayListTest, BuilderCanBeReused) {
   DisplayListBuilder builder(kTestBounds);
   builder.DrawRect(kTestBounds, DlPaint());

display_list/dl_builder.cc

@@ -578,15 +578,18 @@ void DisplayListBuilder::Transform2DAffine(
     SkScalar myx, SkScalar myy, SkScalar myt) {
   if (SkScalarsAreFinite(mxx, myx) &&
       SkScalarsAreFinite(mxy, myy) &&
-      SkScalarsAreFinite(mxt, myt) &&
-      !(mxx == 1 && mxy == 0 && mxt == 0 &&
-        myx == 0 && myy == 1 && myt == 0)) {
-    checkForDeferredSave();
-    Push<Transform2DAffineOp>(0, 1,
-                              mxx, mxy, mxt,
-                              myx, myy, myt);
-    tracker_.transform2DAffine(mxx, mxy, mxt,
-                               myx, myy, myt);
+      SkScalarsAreFinite(mxt, myt)) {
+    if (mxx == 1 && mxy == 0 &&
+        myx == 0 && myy == 1) {
+      Translate(mxt, myt);
+    } else {
+      checkForDeferredSave();
+      Push<Transform2DAffineOp>(0, 1,
+                                mxx, mxy, mxt,
+                                myx, myy, myt);
+      tracker_.transform2DAffine(mxx, mxy, mxt,
+                                 myx, myy, myt);
+    }
   }
 }
 // full 4x4 transform in row major order

display_list/dl_builder.h

@@ -113,11 +113,17 @@ class DisplayListBuilder final : public virtual DlCanvas,
   SkMatrix GetTransform() const override { return tracker_.matrix_3x3(); }
 
   // |DlCanvas|
-  void ClipRect(const SkRect& rect, ClipOp clip_op, bool is_aa) override;
+  void ClipRect(const SkRect& rect,
+                ClipOp clip_op = ClipOp::kIntersect,
+                bool is_aa = false) override;
   // |DlCanvas|
-  void ClipRRect(const SkRRect& rrect, ClipOp clip_op, bool is_aa) override;
+  void ClipRRect(const SkRRect& rrect,
+                 ClipOp clip_op = ClipOp::kIntersect,
+                 bool is_aa = false) override;
   // |DlCanvas|
-  void ClipPath(const SkPath& path, ClipOp clip_op, bool is_aa) override;
+  void ClipPath(const SkPath& path,
+                ClipOp clip_op = ClipOp::kIntersect,
+                bool is_aa = false) override;
 
   /// Conservative estimate of the bounds of all outstanding clip operations
   /// measured in the coordinate space within which this DisplayList will

flow/layers/backdrop_filter_layer_unittests.cc

@@ -11,9 +11,6 @@
 #include "flutter/flow/testing/layer_test.h"
 #include "flutter/flow/testing/mock_layer.h"
 #include "flutter/fml/macros.h"
-#include "flutter/testing/mock_canvas.h"
-#include "third_party/skia/include/core/SkImageFilter.h"
-#include "third_party/skia/include/effects/SkImageFilters.h"
 
 namespace flutter {
 namespace testing {
@@ -72,15 +69,30 @@ TEST_F(BackdropFilterLayerTest, EmptyFilter) {
   EXPECT_TRUE(layer->needs_painting(paint_context()));
   EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
 
-  layer->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector({MockCanvas::DrawCall{
-                       0, MockCanvas::SaveLayerData{child_bounds, DlPaint(),
-                                                    nullptr, 1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::DrawPathData{child_path, child_paint}},
-                   MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  parent->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipRect)parent::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipRect(child_bounds, DlCanvas::ClipOp::kIntersect,
+                                false);
+      /* (BackdropFilter)layer::Paint */ {
+        expected_builder.Save();
+        {
+          expected_builder.SaveLayer(&child_bounds, nullptr, nullptr);
+          {
+            /* mock_layer::Paint */ {
+              expected_builder.DrawPath(child_path, child_paint);
+            }
+          }
+          expected_builder.Restore();
+        }
+        expected_builder.Restore();
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 TEST_F(BackdropFilterLayerTest, SimpleFilter) {
@@ -104,15 +116,31 @@ TEST_F(BackdropFilterLayerTest, SimpleFilter) {
   EXPECT_TRUE(layer->needs_painting(paint_context()));
   EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
 
-  layer->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector({MockCanvas::DrawCall{
-                       0, MockCanvas::SaveLayerData{child_bounds, DlPaint(),
-                                                    layer_filter, 1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::DrawPathData{child_path, child_paint}},
-                   MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  parent->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipRect)parent::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipRect(child_bounds, DlCanvas::ClipOp::kIntersect,
+                                false);
+      /* (BackdropFilter)layer::Paint */ {
+        expected_builder.Save();
+        {
+          expected_builder.SaveLayer(&child_bounds, nullptr,
+                                     layer_filter.get());
+          {
+            /* mock_layer::Paint */ {
+              expected_builder.DrawPath(child_path, child_paint);
+            }
+          }
+          expected_builder.Restore();
+        }
+        expected_builder.Restore();
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 TEST_F(BackdropFilterLayerTest, NonSrcOverBlend) {
@@ -139,15 +167,32 @@ TEST_F(BackdropFilterLayerTest, NonSrcOverBlend) {
   DlPaint filter_paint = DlPaint();
   filter_paint.setBlendMode(DlBlendMode::kSrc);
 
-  layer->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector({MockCanvas::DrawCall{
-                       0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
-                                                    layer_filter, 1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::DrawPathData{child_path, child_paint}},
-                   MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  parent->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipRect)parent::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipRect(child_bounds, DlCanvas::ClipOp::kIntersect,
+                                false);
+      /* (BackdropFilter)layer::Paint */ {
+        expected_builder.Save();
+        {
+          DlPaint save_paint = DlPaint().setBlendMode(DlBlendMode::kSrc);
+          expected_builder.SaveLayer(&child_bounds, &save_paint,
+                                     layer_filter.get());
+          {
+            /* mock_layer::Paint */ {
+              expected_builder.DrawPath(child_path, child_paint);
+            }
+          }
+          expected_builder.Restore();
+        }
+        expected_builder.Restore();
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 TEST_F(BackdropFilterLayerTest, MultipleChildren) {
@@ -184,17 +229,34 @@ TEST_F(BackdropFilterLayerTest, MultipleChildren) {
   EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
   EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
 
-  layer->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector({MockCanvas::DrawCall{
-                       0, MockCanvas::SaveLayerData{children_bounds, DlPaint(),
-                                                    layer_filter, 1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::DrawPathData{child_path1, child_paint1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::DrawPathData{child_path2, child_paint2}},
-                   MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  parent->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipRect)parent::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipRect(children_bounds, DlCanvas::ClipOp::kIntersect,
+                                false);
+      /* (BackdropFilter)layer::Paint */ {
+        expected_builder.Save();
+        {
+          expected_builder.SaveLayer(&children_bounds, nullptr,
+                                     layer_filter.get());
+          {
+            /* mock_layer1::Paint */ {
+              expected_builder.DrawPath(child_path1, child_paint1);
+            }
+            /* mock_layer2::Paint */ {
+              expected_builder.DrawPath(child_path2, child_paint2);
+            }
+          }
+          expected_builder.Restore();
+        }
+        expected_builder.Restore();
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 TEST_F(BackdropFilterLayerTest, Nested) {
@@ -238,21 +300,45 @@ TEST_F(BackdropFilterLayerTest, Nested) {
   EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
   EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
 
-  layer1->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector({MockCanvas::DrawCall{
-                       0, MockCanvas::SaveLayerData{children_bounds, DlPaint(),
-                                                    layer_filter1, 1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::DrawPathData{child_path1, child_paint1}},
-                   MockCanvas::DrawCall{
-                       1, MockCanvas::SaveLayerData{children_bounds, DlPaint(),
-                                                    layer_filter2, 2}},
-                   MockCanvas::DrawCall{
-                       2, MockCanvas::DrawPathData{child_path2, child_paint2}},
-                   MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
-                   MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  parent->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipRect)parent::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipRect(children_bounds, DlCanvas::ClipOp::kIntersect,
+                                false);
+      /* (BackdropFilter)layer1::Paint */ {
+        expected_builder.Save();
+        {
+          expected_builder.SaveLayer(&children_bounds, nullptr,
+                                     layer_filter1.get());
+          {
+            /* mock_layer1::Paint */ {
+              expected_builder.DrawPath(child_path1, child_paint1);
+            }
+            /* (BackdropFilter)layer2::Paint */ {
+              expected_builder.Save();
+              {
+                expected_builder.SaveLayer(&children_bounds, nullptr,
+                                           layer_filter2.get());
+                {
+                  /* mock_layer2::Paint */ {
+                    expected_builder.DrawPath(child_path2, child_paint2);
+                  }
+                }
+                expected_builder.Restore();
+              }
+              expected_builder.Restore();
+            }
+          }
+          expected_builder.Restore();
+        }
+        expected_builder.Restore();
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 TEST_F(BackdropFilterLayerTest, Readback) {

flow/layers/clip_path_layer_unittests.cc

@@ -12,7 +12,6 @@
 #include "flutter/flow/testing/mock_embedder.h"
 #include "flutter/flow/testing/mock_layer.h"
 #include "flutter/fml/macros.h"
-#include "flutter/testing/mock_canvas.h"
 #include "gtest/gtest.h"
 
 namespace flutter {
@@ -170,17 +169,19 @@ TEST_F(ClipPathLayerTest, FullyContainedChild) {
   EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
   EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(layer_path)}));
 
-  layer->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector(
-          {MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
-           MockCanvas::DrawCall{
-               1, MockCanvas::ClipPathData{layer_path, ClipOp::kIntersect,
-                                           MockCanvas::kHard_ClipEdgeStyle}},
-           MockCanvas::DrawCall{
-               1, MockCanvas::DrawPathData{child_path, child_paint}},
-           MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  layer->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipPath)layer::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipPath(layer_path);
+      /* mock_layer::Paint */ {
+        expected_builder.DrawPath(child_path, child_paint);
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 TEST_F(ClipPathLayerTest, PartiallyContainedChild) {
@@ -224,17 +225,19 @@ TEST_F(ClipPathLayerTest, PartiallyContainedChild) {
   EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
   EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(clip_path)}));
 
-  layer->Paint(paint_context());
-  EXPECT_EQ(
-      mock_canvas().draw_calls(),
-      std::vector(
-          {MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
-           MockCanvas::DrawCall{
-               1, MockCanvas::ClipPathData{clip_path, ClipOp::kIntersect,
-                                           MockCanvas::kHard_ClipEdgeStyle}},
-           MockCanvas::DrawCall{
-               1, MockCanvas::DrawPathData{child_path, child_paint}},
-           MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+  layer->Paint(display_list_paint_context());
+  DisplayListBuilder expected_builder;
+  /* (ClipPath)layer::Paint */ {
+    expected_builder.Save();
+    {
+      expected_builder.ClipPath(clip_path);
+      /* mock_layer::Paint */ {
+        expected_builder.DrawPath(child_path, child_paint);
+      }
+    }
+    expected_builder.Restore();
+  }
+  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
 }
 
 static bool ReadbackResult(PrerollContext* context,