cc : Stop pushing properties not used by LayerImpl to LayerImpl (3)

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium 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 "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 950 matching lines @@
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(grand_child, rotation_about_y_axis,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
                                true, false, false);
   SetLayerPropertiesForTesting(great_grand_child, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
                                true, false, false);
 
   // No layers in this test should preserve 3d.
-  ASSERT_TRUE(root->should_flatten_transform());
-  ASSERT_TRUE(child->should_flatten_transform());
-  ASSERT_TRUE(grand_child->should_flatten_transform());
-  ASSERT_TRUE(great_grand_child->should_flatten_transform());
+  ASSERT_TRUE(root->test_properties()->should_flatten_transform);
+  ASSERT_TRUE(child->test_properties()->should_flatten_transform);
+  ASSERT_TRUE(grand_child->test_properties()->should_flatten_transform);
+  ASSERT_TRUE(great_grand_child->test_properties()->should_flatten_transform);
 
   gfx::Transform expected_child_draw_transform = rotation_about_y_axis;
   gfx::Transform expected_child_screen_space_transform = rotation_about_y_axis;
   gfx::Transform expected_grand_child_draw_transform =
       rotation_about_y_axis;  // draws onto child's render surface
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
   gfx::Transform expected_grand_child_screen_space_transform =
       flattened_rotation_about_y * rotation_about_y_axis;
   gfx::Transform expected_great_grand_child_draw_transform =
@@ skipping 40 matching lines @@
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(200, 200), true, false,
                                true);
   SetLayerPropertiesForTesting(child, child_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(grand_child, grand_child_transform,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, false);
 
-  grand_child->SetShouldFlattenTransform(false);
+  grand_child->test_properties()->should_flatten_transform = false;
   grand_child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   // Mapping grand_child's bounds to target space produces a non-empty rect
   // that is fully contained within the target's bounds, so grand_child should
   // be considered fully visible.
   EXPECT_EQ(gfx::Rect(grand_child->bounds()),
             grand_child->visible_layer_rect());
 }
@@ skipping 589 matching lines @@
   SetLayerPropertiesForTesting(parent, rotation_about_y_axis, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
-  grand_child->SetShouldFlattenTransform(false);
+  grand_child->test_properties()->should_flatten_transform = false;
 
   // Only grand_child should preserve 3d.
-  EXPECT_TRUE(root->should_flatten_transform());
-  EXPECT_TRUE(parent->should_flatten_transform());
-  EXPECT_TRUE(child->should_flatten_transform());
-  EXPECT_FALSE(grand_child->should_flatten_transform());
+  EXPECT_TRUE(root->test_properties()->should_flatten_transform);
+  EXPECT_TRUE(parent->test_properties()->should_flatten_transform);
+  EXPECT_TRUE(child->test_properties()->should_flatten_transform);
+  EXPECT_FALSE(grand_child->test_properties()->should_flatten_transform);
 
   gfx::Transform expected_child_draw_transform = identity_matrix;
   gfx::Transform expected_grand_child_draw_transform = identity_matrix;
 
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(parent->render_surface());
@@ skipping 4792 matching lines @@
   SetLayerPropertiesForTesting(render_surface2, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                false, true, true);
   SetLayerPropertiesForTesting(child1, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                false);
   SetLayerPropertiesForTesting(child2, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                false);
 
-  root->SetShouldFlattenTransform(false);
+  root->test_properties()->should_flatten_transform = false;
   root->Set3dSortingContextId(1);
   back_facing->Set3dSortingContextId(1);
-  back_facing->SetShouldFlattenTransform(false);
+  back_facing->test_properties()->should_flatten_transform = false;
   render_surface1->test_properties()->double_sided = false;
   render_surface2->Set3dSortingContextId(2);
   render_surface2->test_properties()->double_sided = false;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(render_surface1->sorting_context_id(), root->sorting_context_id());
   EXPECT_NE(render_surface2->sorting_context_id(), root->sorting_context_id());
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(2u, render_surface_layer_list_impl()
@@ skipping 517 matching lines @@
   //
   LayerImpl* root = root_layer();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* fixed = AddChild<LayerImpl>(render_surface);
   LayerImpl* child = AddChild<LayerImpl>(fixed);
 
   render_surface->SetDrawsContent(true);
   fixed->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
-  root->SetIsContainerForFixedPositionLayers(true);
   render_surface->test_properties()->force_render_surface = true;
+  root->test_properties()->is_container_for_fixed_position_layers = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
-  fixed->SetPositionConstraint(constraint);
+  fixed->test_properties()->position_constraint = constraint;
 
   SetLayerPropertiesForTesting(root, gfx::Transform(), gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(render_surface, gfx::Transform(), gfx::Point3F(),
                                gfx::PointF(7.f, 9.f), gfx::Size(50, 50), true,
                                false);
   SetLayerPropertiesForTesting(fixed, gfx::Transform(), gfx::Point3F(),
                                gfx::PointF(10.f, 15.f), gfx::Size(50, 50), true,
                                false);
   SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
@@ skipping 47 matching lines @@
   std::unique_ptr<LayerImpl> container =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* container_layer = container.get();
   std::unique_ptr<LayerImpl> scroller =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* scroll_layer = scroller.get();
   std::unique_ptr<LayerImpl> fixed =
       LayerImpl::Create(host_impl.active_tree(), 4);
   LayerImpl* fixed_layer = fixed.get();
 
-  container->SetIsContainerForFixedPositionLayers(true);
+  container->test_properties()->is_container_for_fixed_position_layers = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
-  fixed->SetPositionConstraint(constraint);
+  fixed->test_properties()->position_constraint = constraint;
 
   scroller->SetScrollClipLayer(container->id());
 
   gfx::Transform identity_transform;
   gfx::Transform container_transform;
   container_transform.Translate3d(10.0, 20.0, 0.0);
   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
 
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 1316 matching lines @@
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
                                gfx::PointF(-1000, -1000), gfx::Size(50, 50),
                                true, false, false);
 
   root->SetMasksToBounds(true);
-  root->SetIsContainerForFixedPositionLayers(true);
+  root->test_properties()->is_container_for_fixed_position_layers = true;
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
-  grandchild->SetPositionConstraint(constraint);
+  grandchild->test_properties()->position_constraint = constraint;
   grandchild->SetDrawsContent(true);
 
-  root->SetIsContainerForFixedPositionLayers(true);
+  root->test_properties()->is_container_for_fixed_position_layers = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grandchild->visible_layer_rect());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position containers and their transform tree parents, when a fixed position
 // layer's container is its layer tree parent, but this parent doesn't have its
 // own transform tree node.
 TEST_F(LayerTreeHostCommonTest,
        PropertyTreesAccountForFixedParentOffsetWhenContainerIsParent) {
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
                                gfx::PointF(-1000, -1000), gfx::Size(50, 50),
                                true, false, false);
 
   root->SetMasksToBounds(true);
-  child->SetIsContainerForFixedPositionLayers(true);
+  child->test_properties()->is_container_for_fixed_position_layers = true;
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
-  grandchild->SetPositionConstraint(constraint);
+  grandchild->test_properties()->position_constraint = constraint;
   grandchild->SetDrawsContent(true);
 
-  root->SetIsContainerForFixedPositionLayers(true);
+  root->test_properties()->is_container_for_fixed_position_layers = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grandchild->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, CombineClipsUsingContentTarget) {
   // In the following layer tree, the layer |box|'s render target is |surface|.
   // |surface| also creates a transform node. We want to combine clips for |box|
   // in the space of its target (i.e., |surface|), not its target's target. This
@@ skipping 49 matching lines @@
 TEST_F(LayerTreeHostCommonTest, OnlyApplyFixedPositioningOnce) {
   LayerImpl* root = root_layer();
   LayerImpl* frame_clip = AddChild<LayerImpl>(root);
   LayerImpl* fixed = AddChild<LayerImpl>(frame_clip);
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(800, 800), true, false, true);
-  root->SetIsContainerForFixedPositionLayers(true);
+  root->test_properties()->is_container_for_fixed_position_layers = true;
 
   SetLayerPropertiesForTesting(frame_clip, translate_z, gfx::Point3F(),
                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
                                false, false);
   frame_clip->SetMasksToBounds(true);
 
   SetLayerPropertiesForTesting(fixed, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(1000, 1000), true, false, false);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
-  fixed->SetPositionConstraint(constraint);
+  fixed->test_properties()->position_constraint = constraint;
   fixed->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Rect expected(0, 0, 100, 100);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, FixedClipsShouldBeAssociatedWithTheRightNode) {
   LayerImpl* root = root_layer();
   LayerImpl* frame_clip = AddChild<LayerImpl>(root);
   LayerImpl* scroller = AddChild<LayerImpl>(frame_clip);
   LayerImpl* fixed = AddChild<LayerImpl>(scroller);
 
   gfx::Transform identity;
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(800, 800), true, false, true);
   SetLayerPropertiesForTesting(frame_clip, identity, gfx::Point3F(),
                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
                                false, false);
   SetLayerPropertiesForTesting(scroller, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1000, 1000), true,
                                false, false);
   SetLayerPropertiesForTesting(fixed, identity, gfx::Point3F(),
                                gfx::PointF(100, 100), gfx::Size(50, 50), true,
                                false, true);
 
-  root->SetIsContainerForFixedPositionLayers(true);
+  root->test_properties()->is_container_for_fixed_position_layers = true;
   root->SetDrawsContent(true);
 
   frame_clip->SetMasksToBounds(true);
   frame_clip->SetDrawsContent(true);
 
   scroller->SetCurrentScrollOffset(gfx::ScrollOffset(100, 100));
   scroller->SetScrollClipLayer(frame_clip->id());
   scroller->SetDrawsContent(true);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
-  fixed->SetPositionConstraint(constraint);
+  fixed->test_properties()->position_constraint = constraint;
   fixed->SetMasksToBounds(true);
   fixed->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Rect expected(0, 0, 50, 50);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangingAxisAlignmentTriggersRebuild) {
@@ skipping 1533 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc