transform__layer__unittests_8cc_source.html

// Copyright 2013 The Flutter Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.


#include "flutter/flow/layers/transform_layer.h"


#include "flutter/flow/testing/diff_context_test.h"

#include "flutter/flow/testing/layer_test.h"

#include "flutter/flow/testing/mock_layer.h"

#include "flutter/fml/macros.h"


namespace flutter {

namespace testing {


using TransformLayerTest = LayerTest;


#ifndef NDEBUG

TEST_F(TransformLayerTest, PaintingEmptyLayerDies) {

  auto layer = std::make_shared<TransformLayer>(DlMatrix());  // identity


  layer->Preroll(preroll_context());

  EXPECT_EQ(layer->paint_bounds(), DlRect());

  EXPECT_EQ(layer->child_paint_bounds(), DlRect());

  EXPECT_FALSE(layer->needs_painting(paint_context()));


  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),

                            "needs_painting\\(context\\)");

}


TEST_F(TransformLayerTest, PaintBeforePrerollDies) {

  const DlPath child_path = DlPath::MakeRectLTRB(5.0f, 6.0f, 20.5f, 21.5f);

  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());

  auto layer = std::make_shared<TransformLayer>(DlMatrix());  // identity

  layer->Add(mock_layer);


  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),

                            "needs_painting\\(context\\)");

}

#endif


TEST_F(TransformLayerTest, Identity) {

  const DlPath child_path = DlPath::MakeRectLTRB(5.0f, 6.0f, 20.5f, 21.5f);

  DlRect cull_rect = DlRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);

  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());

  auto layer = std::make_shared<TransformLayer>(DlMatrix());  // identity

  layer->Add(mock_layer);


  preroll_context()->state_stack.set_preroll_delegate(cull_rect);

  layer->Preroll(preroll_context());

  EXPECT_EQ(mock_layer->paint_bounds(), child_path.GetBounds());

  EXPECT_EQ(layer->paint_bounds(), mock_layer->paint_bounds());

  EXPECT_EQ(layer->child_paint_bounds(), mock_layer->paint_bounds());

  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));

  EXPECT_TRUE(layer->needs_painting(paint_context()));

  EXPECT_EQ(mock_layer->parent_matrix(), DlMatrix());  // identity

  EXPECT_EQ(mock_layer->parent_cull_rect(), cull_rect);

  EXPECT_EQ(mock_layer->parent_mutators().stack_count(), 0u);

  EXPECT_EQ(mock_layer->parent_mutators(), MutatorsStack());


  layer->Paint(display_list_paint_context());

  DisplayListBuilder expected_builder;

  /* (Transform)layer::Paint */ {

    expected_builder.Save();

    {

      expected_builder.Transform(DlMatrix());

      /* mock_layer::Paint */ {

        expected_builder.DrawPath(child_path, DlPaint());

      }

    }

    expected_builder.Restore();

  }

  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));

}


TEST_F(TransformLayerTest, Simple) {

  const DlPath child_path = DlPath::MakeRectLTRB(5.0f, 6.0f, 20.5f, 21.5f);

  DlMatrix initial_transform = DlMatrix::MakeTranslation({-0.5f, -0.5f});

  DlRect local_cull_rect = DlRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);

  DlRect device_cull_rect =

      local_cull_rect.TransformAndClipBounds(initial_transform);

  DlMatrix layer_transform = DlMatrix::MakeTranslation({2.5f, 2.5f});

  EXPECT_TRUE(layer_transform.IsInvertible());

  DlMatrix inverse_layer_transform = layer_transform.Invert();


  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());

  auto layer = std::make_shared<TransformLayer>(layer_transform);

  layer->Add(mock_layer);


  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,

                                                      initial_transform);

  layer->Preroll(preroll_context());

  EXPECT_EQ(mock_layer->paint_bounds(), child_path.GetBounds());

  EXPECT_EQ(layer->paint_bounds(),

            mock_layer->paint_bounds().TransformAndClipBounds(layer_transform));

  EXPECT_EQ(layer->child_paint_bounds(), mock_layer->paint_bounds());

  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));

  EXPECT_TRUE(layer->needs_painting(paint_context()));

  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform * layer_transform);

  EXPECT_EQ(mock_layer->parent_cull_rect(),

            local_cull_rect.TransformAndClipBounds(inverse_layer_transform));

  EXPECT_EQ(mock_layer->parent_mutators(),

            std::vector({Mutator(layer_transform)}));


  layer->Paint(display_list_paint_context());

  DisplayListBuilder expected_builder;

  /* (Transform)layer::Paint */ {

    expected_builder.Save();

    {

      expected_builder.Transform(layer_transform);

      /* mock_layer::Paint */ {

        expected_builder.DrawPath(child_path, DlPaint());

      }

    }

    expected_builder.Restore();

  }

  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));

}


TEST_F(TransformLayerTest, ComplexMatrix) {

  const DlPath child_path = DlPath::MakeRectLTRB(5.0f, 6.0f, 20.5f, 21.5f);

  DlMatrix initial_transform = DlMatrix::MakeTranslation({-2.0f, -2.0f});

  DlRect local_cull_rect = DlRect::MakeXYWH(4.0f, 4.0f, 16.0f, 16.0f);

  DlRect device_cull_rect =

      local_cull_rect.TransformAndClipBounds(initial_transform);

  DlMatrix layer_transform = (DlMatrix::MakeTranslation({1.0f, 1.0f}) *

                              DlMatrix::MakeRotationX(DlDegrees(20.0f))) *

                             DlMatrix::MakeRotationY(DlDegrees(10.0f));


  EXPECT_TRUE(layer_transform.IsInvertible());

  DlMatrix inverse_layer_transform = layer_transform.Invert();


  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());

  auto layer = std::make_shared<TransformLayer>(layer_transform);

  layer->Add(mock_layer);


  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,

                                                      initial_transform);

  layer->Preroll(preroll_context());

  EXPECT_EQ(mock_layer->paint_bounds(), child_path.GetBounds());

  EXPECT_EQ(layer->paint_bounds(),

            mock_layer->paint_bounds().TransformAndClipBounds(layer_transform));

  EXPECT_EQ(layer->child_paint_bounds(), mock_layer->paint_bounds());

  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));

  EXPECT_TRUE(layer->needs_painting(paint_context()));

  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform * layer_transform);


  // Even having switched to binary-ieee friendly numbers for the

  // initial conditions, these numbers which are based on a matrix

  // concatenation and inversion still aren't exact, so we are using

  // fuzzy float comparisons to check them.

  DlRect parent_cull_rect = mock_layer->parent_cull_rect();

  DlRect expect_parent_cull_rect =

      local_cull_rect.TransformAndClipBounds(inverse_layer_transform);

  EXPECT_FLOAT_EQ(parent_cull_rect.GetLeft(),

                  expect_parent_cull_rect.GetLeft());

  EXPECT_FLOAT_EQ(parent_cull_rect.GetTop(),  //

                  expect_parent_cull_rect.GetTop());

  EXPECT_FLOAT_EQ(parent_cull_rect.GetRight(),

                  expect_parent_cull_rect.GetRight());

  EXPECT_FLOAT_EQ(parent_cull_rect.GetBottom(),

                  expect_parent_cull_rect.GetBottom());


  EXPECT_EQ(mock_layer->parent_mutators(),

            std::vector({Mutator(layer_transform)}));


  layer->Paint(display_list_paint_context());

  DisplayListBuilder expected_builder;

  /* (Transform)layer::Paint */ {

    expected_builder.Save();

    {

      expected_builder.Transform(layer_transform);

      /* mock_layer::Paint */ {

        expected_builder.DrawPath(child_path, DlPaint());

      }

    }

    expected_builder.Restore();

  }

  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));

}


TEST_F(TransformLayerTest, Nested) {

  DlPath child_path = DlPath::MakeRectLTRB(5.0f, 6.0f, 20.5f, 21.5f);

  DlMatrix initial_transform = DlMatrix::MakeTranslation({-0.5f, -0.5f});

  DlRect local_cull_rect = DlRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);

  DlRect device_cull_rect =

      local_cull_rect.TransformAndClipBounds(initial_transform);

  DlMatrix layer1_transform = DlMatrix::MakeTranslation({2.5f, 2.5f});

  DlMatrix layer2_transform = DlMatrix::MakeTranslation({3.5f, 3.5f});

  EXPECT_TRUE(layer1_transform.IsInvertible());

  EXPECT_TRUE(layer2_transform.IsInvertible());

  DlMatrix inverse_layer1_transform = layer1_transform.Invert();

  DlMatrix inverse_layer2_transform = layer2_transform.Invert();


  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());

  auto layer1 = std::make_shared<TransformLayer>(layer1_transform);

  auto layer2 = std::make_shared<TransformLayer>(layer2_transform);

  layer1->Add(layer2);

  layer2->Add(mock_layer);


  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,

                                                      initial_transform);

  layer1->Preroll(preroll_context());

  EXPECT_EQ(mock_layer->paint_bounds(), child_path.GetBounds());

  EXPECT_EQ(

      layer2->paint_bounds(),

      mock_layer->paint_bounds().TransformAndClipBounds(layer2_transform));

  EXPECT_EQ(layer2->child_paint_bounds(), mock_layer->paint_bounds());

  EXPECT_EQ(layer1->paint_bounds(),

            layer2->paint_bounds().TransformAndClipBounds(layer1_transform));

  EXPECT_EQ(layer1->child_paint_bounds(), layer2->paint_bounds());

  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));

  EXPECT_TRUE(layer2->needs_painting(paint_context()));

  EXPECT_TRUE(layer1->needs_painting(paint_context()));

  EXPECT_EQ(mock_layer->parent_matrix(),

            (initial_transform * layer1_transform) * layer2_transform);

  EXPECT_EQ(mock_layer->parent_cull_rect(),

            local_cull_rect.TransformAndClipBounds(inverse_layer1_transform)

                .TransformAndClipBounds(inverse_layer2_transform));

  EXPECT_EQ(

      mock_layer->parent_mutators(),

      std::vector({Mutator(layer1_transform), Mutator(layer2_transform)}));


  layer1->Paint(display_list_paint_context());

  DisplayListBuilder expected_builder;

  /* (Transform)layer1::Paint */ {

    expected_builder.Save();

    {

      expected_builder.Transform(layer1_transform);

      /* (Transform)layer1::Paint */ {

        expected_builder.Save();

        {

          expected_builder.Transform(layer2_transform);

          /* mock_layer::Paint */ {

            expected_builder.DrawPath(child_path, DlPaint());

          }

        }

        expected_builder.Restore();

      }

    }

    expected_builder.Restore();

  }

  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));

}


TEST_F(TransformLayerTest, NestedSeparated) {

  DlPath child_path = DlPath::MakeRectLTRB(5.0f, 6.0f, 20.5f, 21.5f);

  DlMatrix initial_transform = DlMatrix::MakeTranslation({-0.5f, -0.5f});

  DlRect local_cull_rect = DlRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);

  DlRect device_cull_rect =

      local_cull_rect.TransformAndClipBounds(initial_transform);

  DlMatrix layer1_transform = DlMatrix::MakeTranslation({2.5f, 2.5f});

  DlMatrix layer2_transform = DlMatrix::MakeTranslation({3.5f, 3.5f});

  EXPECT_TRUE(layer1_transform.IsInvertible());

  EXPECT_TRUE(layer2_transform.IsInvertible());

  DlMatrix inverse_layer1_transform = layer1_transform.Invert();

  DlMatrix inverse_layer2_transform = layer2_transform.Invert();

  DlPaint child_paint1(DlColor::kBlue());

  DlPaint child_paint2(DlColor::kGreen());


  auto mock_layer1 = std::make_shared<MockLayer>(child_path, child_paint1);

  auto mock_layer2 = std::make_shared<MockLayer>(child_path, child_paint2);

  auto layer1 = std::make_shared<TransformLayer>(layer1_transform);

  auto layer2 = std::make_shared<TransformLayer>(layer2_transform);

  layer1->Add(mock_layer1);

  layer1->Add(layer2);

  layer2->Add(mock_layer2);


  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,

                                                      initial_transform);

  layer1->Preroll(preroll_context());

  DlRect layer1_child_bounds =

      layer2->paint_bounds().Union(mock_layer1->paint_bounds());

  DlRect expected_layer1_bounds =

      layer1_child_bounds.TransformAndClipBounds(layer1_transform);


  EXPECT_EQ(mock_layer2->paint_bounds(), child_path.GetBounds());

  EXPECT_EQ(

      layer2->paint_bounds(),

      mock_layer2->paint_bounds().TransformAndClipBounds(layer2_transform));

  EXPECT_EQ(layer2->child_paint_bounds(), mock_layer2->paint_bounds());

  EXPECT_EQ(mock_layer1->paint_bounds(), child_path.GetBounds());

  EXPECT_EQ(layer1->paint_bounds(), expected_layer1_bounds);

  EXPECT_EQ(layer1->child_paint_bounds(), layer1_child_bounds);

  EXPECT_TRUE(mock_layer2->needs_painting(paint_context()));

  EXPECT_TRUE(layer2->needs_painting(paint_context()));

  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));

  EXPECT_TRUE(layer1->needs_painting(paint_context()));

  EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform * layer1_transform);

  EXPECT_EQ(mock_layer2->parent_matrix(),

            (initial_transform * layer1_transform) * layer2_transform);

  EXPECT_EQ(mock_layer1->parent_cull_rect(),

            local_cull_rect.TransformAndClipBounds(inverse_layer1_transform));

  EXPECT_EQ(mock_layer2->parent_cull_rect(),

            local_cull_rect.TransformAndClipBounds(inverse_layer1_transform)

                .TransformAndClipBounds(inverse_layer2_transform));

  EXPECT_EQ(mock_layer1->parent_mutators(),

            std::vector({Mutator(layer1_transform)}));

  EXPECT_EQ(

      mock_layer2->parent_mutators(),

      std::vector({Mutator(layer1_transform), Mutator(layer2_transform)}));


  layer1->Paint(display_list_paint_context());

  DisplayListBuilder expected_builder;

  /* (Transform)layer1::Paint */ {

    expected_builder.Save();

    {

      expected_builder.Transform(layer1_transform);

      /* mock_layer::Paint */ {

        expected_builder.DrawPath(child_path, child_paint1);

      }

      /* (Transform)layer1::Paint */ {

        expected_builder.Save();

        {

          expected_builder.Transform(layer2_transform);

          /* mock_layer::Paint */ {

            expected_builder.DrawPath(child_path, child_paint2);

          }

        }

        expected_builder.Restore();

      }

    }

    expected_builder.Restore();

  }

  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));

}


TEST_F(TransformLayerTest, OpacityInheritance) {

  auto path1 = DlPath::MakeRectLTRB(10, 10, 30, 30);

  auto mock1 = MockLayer::MakeOpacityCompatible(path1);

  auto transform1 =

      std::make_shared<TransformLayer>(DlMatrix::MakeScale({2.0f, 2.0f, 1.0f}));

  transform1->Add(mock1);


  // TransformLayer will pass through compatibility from a compatible child

  PrerollContext* context = preroll_context();

  transform1->Preroll(context);

  EXPECT_EQ(context->renderable_state_flags,

            LayerStateStack::kCallerCanApplyOpacity);


  auto path2 = DlPath::MakeRectLTRB(40, 40, 50, 50);

  auto mock2 = MockLayer::MakeOpacityCompatible(path2);

  transform1->Add(mock2);


  // TransformLayer will pass through compatibility from multiple

  // non-overlapping compatible children

  transform1->Preroll(context);

  EXPECT_EQ(context->renderable_state_flags,

            LayerStateStack::kCallerCanApplyOpacity);


  auto path3 = DlPath::MakeRectLTRB(20, 20, 40, 40);

  auto mock3 = MockLayer::MakeOpacityCompatible(path3);

  transform1->Add(mock3);


  // TransformLayer will not pass through compatibility from multiple

  // overlapping children even if they are individually compatible

  transform1->Preroll(context);

  EXPECT_EQ(context->renderable_state_flags, 0);


  auto transform2 =

      std::make_shared<TransformLayer>(DlMatrix::MakeScale({2.0f, 2.0f, 1.0f}));

  transform2->Add(mock1);

  transform2->Add(mock2);


  // Double check first two children are compatible and non-overlapping

  transform2->Preroll(context);

  EXPECT_EQ(context->renderable_state_flags,

            LayerStateStack::kCallerCanApplyOpacity);


  auto path4 = DlPath::MakeRectLTRB(60, 60, 70, 70);

  auto mock4 = MockLayer::Make(path4);

  transform2->Add(mock4);


  // The third child is non-overlapping, but not compatible so the

  // TransformLayer should end up incompatible

  transform2->Preroll(context);

  EXPECT_EQ(context->renderable_state_flags, 0);

}


TEST_F(TransformLayerTest, OpacityInheritancePainting) {

  auto path1 = DlPath::MakeRectLTRB(10, 10, 30, 30);

  auto mock1 = MockLayer::MakeOpacityCompatible(path1);

  auto path2 = DlPath::MakeRectLTRB(40, 40, 50, 50);

  auto mock2 = MockLayer::MakeOpacityCompatible(path2);

  auto transform = DlMatrix::MakeScale({2.0f, 2.0f, 1.0f});

  auto transform_layer = std::make_shared<TransformLayer>(transform);

  transform_layer->Add(mock1);

  transform_layer->Add(mock2);


  // TransformLayer will pass through compatibility from multiple

  // non-overlapping compatible children

  PrerollContext* context = preroll_context();

  transform_layer->Preroll(context);

  EXPECT_EQ(context->renderable_state_flags,

            LayerStateStack::kCallerCanApplyOpacity);


  uint8_t opacity_alpha = 0x7F;

  DlPoint offset = DlPoint(10, 10);

  auto opacity_layer = std::make_shared<OpacityLayer>(opacity_alpha, offset);

  opacity_layer->Add(transform_layer);

  opacity_layer->Preroll(context);

  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());


  DisplayListBuilder expected_builder;

  /* opacity_layer paint */ {

    expected_builder.Save();

    {

      expected_builder.Translate(offset.x, offset.y);

      /* transform_layer paint */ {

        expected_builder.Save();

        expected_builder.Transform(transform);

        /* child layer1 paint */ {

          expected_builder.DrawPath(path1, DlPaint().setAlpha(opacity_alpha));

        }

        /* child layer2 paint */ {

          expected_builder.DrawPath(path2, DlPaint().setAlpha(opacity_alpha));

        }

        expected_builder.Restore();

      }

    }

    expected_builder.Restore();

  }


  opacity_layer->Paint(display_list_paint_context());

  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));

}


using TransformLayerLayerDiffTest = DiffContextTest;


TEST_F(TransformLayerLayerDiffTest, Transform) {

  auto path1 = DlPath::MakeRectLTRB(0, 0, 50, 50);

  auto m1 = std::make_shared<MockLayer>(path1);


  auto transform1 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({10, 10}));

  transform1->Add(m1);


  MockLayerTree t1;

  t1.root()->Add(transform1);


  auto damage = DiffLayerTree(t1, MockLayerTree());

  EXPECT_EQ(damage.frame_damage, DlIRect::MakeLTRB(10, 10, 60, 60));


  auto transform2 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({20, 20}));

  transform2->Add(m1);

  transform2->AssignOldLayer(transform1.get());


  MockLayerTree t2;

  t2.root()->Add(transform2);


  damage = DiffLayerTree(t2, t1);

  EXPECT_EQ(damage.frame_damage, DlIRect::MakeLTRB(10, 10, 70, 70));


  auto transform3 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({20, 20}));

  transform3->Add(m1);

  transform3->AssignOldLayer(transform2.get());


  MockLayerTree t3;

  t3.root()->Add(transform3);


  damage = DiffLayerTree(t3, t2);

  EXPECT_EQ(damage.frame_damage, DlIRect());

}


TEST_F(TransformLayerLayerDiffTest, TransformNested) {

  auto path1 = DlPath::MakeRectLTRB(0, 0, 50, 50);

  auto m1 = CreateContainerLayer(std::make_shared<MockLayer>(path1));

  auto m2 = CreateContainerLayer(std::make_shared<MockLayer>(path1));

  auto m3 = CreateContainerLayer(std::make_shared<MockLayer>(path1));


  auto transform1 =

      std::make_shared<TransformLayer>(DlMatrix::MakeScale({2.0f, 2.0f, 1.0f}));


  auto transform1_1 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({10, 10}));

  transform1_1->Add(m1);

  transform1->Add(transform1_1);


  auto transform1_2 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({100, 100}));

  transform1_2->Add(m2);

  transform1->Add(transform1_2);


  auto transform1_3 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({200, 200}));

  transform1_3->Add(m3);

  transform1->Add(transform1_3);


  MockLayerTree l1;

  l1.root()->Add(transform1);


  auto damage = DiffLayerTree(l1, MockLayerTree());

  EXPECT_EQ(damage.frame_damage, DlIRect::MakeLTRB(20, 20, 500, 500));


  auto transform2 =

      std::make_shared<TransformLayer>(DlMatrix::MakeScale({2.0f, 2.0f, 1.0f}));


  auto transform2_1 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({10, 10}));

  transform2_1->Add(m1);

  transform2_1->AssignOldLayer(transform1_1.get());

  transform2->Add(transform2_1);


  // Offset 1px from transform1_2 so that they're not the same

  auto transform2_2 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({100, 101}));

  transform2_2->Add(m2);

  transform2_2->AssignOldLayer(transform1_2.get());

  transform2->Add(transform2_2);


  auto transform2_3 =

      std::make_shared<TransformLayer>(DlMatrix::MakeTranslation({200, 200}));

  transform2_3->Add(m3);

  transform2_3->AssignOldLayer(transform1_3.get());

  transform2->Add(transform2_3);


  MockLayerTree l2;

  l2.root()->Add(transform2);


  damage = DiffLayerTree(l2, l1);


  // transform2 has not transform1 assigned as old layer, so it should be

  // invalidated completely

  EXPECT_EQ(damage.frame_damage, DlIRect::MakeLTRB(20, 20, 500, 500));


  // now diff the tree properly, the only difference being transform2_2 and

  // transform_2_1

  transform2->AssignOldLayer(transform1.get());

  damage = DiffLayerTree(l2, l1);


  EXPECT_EQ(damage.frame_damage, DlIRect::MakeLTRB(200, 200, 300, 302));

}


}  // namespace testing

}  // namespace flutter

flutter::ContainerLayer::Add
virtual void Add(std::shared_ptr< Layer > layer)
Definition container_layer.cc:106

flutter::DisplayListBuilder
Definition dl_builder.h:30

flutter::DisplayListBuilder::Save
void Save() override
Definition dl_builder.cc:398

flutter::DisplayListBuilder::Restore
void Restore() override
Definition dl_builder.cc:563

flutter::DisplayListBuilder::Build
sk_sp< DisplayList > Build()
Definition dl_builder.cc:66

flutter::DisplayListBuilder::DrawPath
void DrawPath(const DlPath &path, const DlPaint &paint) override
Definition dl_builder.cc:1299

flutter::DisplayListBuilder::Transform
void Transform(const DlMatrix &matrix) override
Definition dl_builder.cc:926

flutter::DlPaint
Definition dl_paint.h:46

flutter::DlPath
Definition dl_path.h:19

flutter::DlPath::MakeRectLTRB
static DlPath MakeRectLTRB(DlScalar left, DlScalar top, DlScalar right, DlScalar bottom)
Definition dl_path.cc:43

flutter::DlPath::GetBounds
DlRect GetBounds() const override
Definition dl_path.cc:245

flutter::LayerStateStack::kCallerCanApplyOpacity
static constexpr int kCallerCanApplyOpacity
Definition layer_state_stack.h:226

flutter::MutatorsStack
Definition embedded_views.h:140

flutter::testing::DiffContextTest
Definition diff_context_test.h:38

flutter::testing::LayerTestBase
Definition layer_test.h:37

flutter::testing::MockLayer::Make
static std::shared_ptr< MockLayer > Make(const DlPath &path, DlPaint paint=DlPaint())
Definition mock_layer.h:30

flutter::testing::MockLayer::MakeOpacityCompatible
static std::shared_ptr< MockLayer > MakeOpacityCompatible(const DlPath &path)
Definition mock_layer.h:35

flutter::testing::MockLayerTree
Definition diff_context_test.h:19

flutter::testing::MockLayerTree::root
ContainerLayer * root()
Definition diff_context_test.h:24

diff_context_test.h

macros.h

transform
Matrix transform
Definition gaussian_blur_filter_contents.cc:214

layer_test.h

mock_layer.h

flutter::testing::TEST_F
TEST_F(DisplayListTest, Defaults)
Definition display_list_unittests.cc:231

flutter::testing::LayerTest
LayerTestBase<::testing::Test > LayerTest
Definition layer_test.h:177

flutter::testing::TransformLayerTest
LayerTest TransformLayerTest
Definition transform_layer_unittests.cc:15

flutter::testing::DisplayListsEQ_Verbose
bool DisplayListsEQ_Verbose(const DisplayList *a, const DisplayList *b)
Definition display_list_testing.cc:20

flutter
Definition asset_manager.cc:10

flutter::DlMatrix
impeller::Matrix DlMatrix
Definition dl_geometry_types.h:32

flutter::DlRect
impeller::Rect DlRect
Definition dl_geometry_types.h:27

flutter::DlDegrees
impeller::Degrees DlDegrees
Definition dl_geometry_types.h:18

flutter::DlPoint
impeller::Point DlPoint
Definition dl_geometry_types.h:21

std::DlPaint
flutter::DlPaint DlPaint
Definition display_list_testing.cc:49

flutter::DlColor::kBlue
static constexpr DlColor kBlue()
Definition dl_color.h:73

flutter::DlColor::kGreen
static constexpr DlColor kGreen()
Definition dl_color.h:72

impeller::Matrix
A 4x4 matrix using column-major storage.
Definition matrix.h:37

impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition matrix.h:95

impeller::Matrix::IsInvertible
bool IsInvertible() const
Definition matrix.h:321

impeller::Matrix::Invert
Matrix Invert() const
Definition matrix.cc:99

impeller::Matrix::MakeRotationY
static Matrix MakeRotationY(Radians r)
Definition matrix.h:208

impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition matrix.h:104

impeller::Matrix::MakeRotationX
static Matrix MakeRotationX(Radians r)
Definition matrix.h:193

impeller::TRect< Scalar >

impeller::TRect::GetBottom
constexpr auto GetBottom() const
Definition rect.h:357

impeller::TRect::GetTop
constexpr auto GetTop() const
Definition rect.h:353

impeller::TRect::Union
constexpr TRect Union(const TRect &o) const
Definition rect.h:513

impeller::TRect::GetLeft
constexpr auto GetLeft() const
Definition rect.h:351

impeller::TRect::GetRight
constexpr auto GetRight() const
Definition rect.h:355

impeller::TRect< Scalar >::MakeXYWH
static constexpr TRect MakeXYWH(Type x, Type y, Type width, Type height)
Definition rect.h:136

impeller::TRect::TransformAndClipBounds
constexpr TRect TransformAndClipBounds(const Matrix &transform) const
Creates a new bounding box that contains this transformed rectangle, clipped against the near clippin...
Definition rect.h:438

impeller::TRect::MakeLTRB
static constexpr TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
Definition rect.h:129

transform_layer.h