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

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 1575 matching lines @@
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
   child->SetDrawsContent(true);
-  render_surface1->SetForceRenderSurface(true);
+  render_surface1->test_properties()->force_render_surface = true;
 
   {
     ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
 
     // The root layer always creates a render surface
     EXPECT_TRUE(parent->has_render_surface());
     EXPECT_TRUE(render_surface1->has_render_surface());
   }
 
   {
-    render_surface1->SetForceRenderSurface(false);
+    render_surface1->test_properties()->force_render_surface = false;
     render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;
     ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
     EXPECT_TRUE(parent->has_render_surface());
     EXPECT_FALSE(render_surface1->has_render_surface());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
@@ skipping 687 matching lines @@
   SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
                                true, false);
   SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(9.f, 9.f), gfx::Size(2000, 2000),
                                true, false);
 
   // Case 1: Nothing is clipped. In this case, each layer's clip rect is its
   // bounds in target space. The only thing that changes when surfaces are
   // disabled is that target space is always screen space.
-  root->SetForceRenderSurface(true);
-  child1->SetForceRenderSurface(true);
-  grand_child->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
+  child1->test_properties()->force_render_surface = true;
+  grand_child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(parent->has_render_surface());
   EXPECT_TRUE(child1->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
   EXPECT_TRUE(grand_child->has_render_surface());
   EXPECT_FALSE(leaf_node1->has_render_surface());
   EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
@@ skipping 15 matching lines @@
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
   EXPECT_TRUE(root->render_surface()->is_clipped());
   EXPECT_EQ(gfx::Rect(100, 100), root->render_surface()->clip_rect());
 
   // Case 2: The root is clipped. In this case, layers that draw into the root
   // render surface are clipped by the root's bounds.
   root->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetForceRenderSurface(true);
-  child1->SetForceRenderSurface(true);
-  grand_child->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
+  child1->test_properties()->force_render_surface = true;
+  grand_child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(parent->has_render_surface());
   EXPECT_TRUE(child1->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
   EXPECT_TRUE(grand_child->has_render_surface());
   EXPECT_FALSE(leaf_node1->has_render_surface());
   EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_TRUE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
@@ skipping 30 matching lines @@
 
   // Case 3: The parent and child1 are clipped. When surfaces are enabled, the
   // parent clip rect only contributes to the subtree rooted at child2, since
   // the subtree rooted at child1 renders into a separate surface. Similarly,
   // child1's clip rect doesn't contribute to its descendants, since its only
   // child is a render surface. However, without surfaces, these clip rects
   // contribute to all descendants.
   parent->SetMasksToBounds(true);
   child1->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetForceRenderSurface(true);
-  child1->SetForceRenderSurface(true);
-  grand_child->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
+  child1->test_properties()->force_render_surface = true;
+  grand_child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(parent->has_render_surface());
   EXPECT_TRUE(child1->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
   EXPECT_TRUE(grand_child->has_render_surface());
   EXPECT_FALSE(leaf_node1->has_render_surface());
   EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(root->render_surface()->is_clipped());
@@ skipping 1970 matching lines @@
       AddChild<LayerImpl>(back_facing_surface);
   // Opacity will not force creation of render surfaces in this case because of
   // the preserve-3d transform style. Instead, an example of when a surface
   // would be created with preserve-3d is when there is a replica layer.
   LayerImpl* dummy_replica_layer1 =
       AddReplicaLayer<LayerImpl>(front_facing_surface);
   LayerImpl* dummy_replica_layer2 =
       AddReplicaLayer<LayerImpl>(back_facing_surface);
 
   // Nothing is double-sided
-  front_facing_child->SetDoubleSided(false);
-  back_facing_child->SetDoubleSided(false);
-  front_facing_surface->SetDoubleSided(false);
-  back_facing_surface->SetDoubleSided(false);
-  front_facing_child_of_front_facing_surface->SetDoubleSided(false);
-  back_facing_child_of_front_facing_surface->SetDoubleSided(false);
-  front_facing_child_of_back_facing_surface->SetDoubleSided(false);
-  back_facing_child_of_back_facing_surface->SetDoubleSided(false);
+  front_facing_child->test_properties()->double_sided = false;
+  back_facing_child->test_properties()->double_sided = false;
+  front_facing_surface->test_properties()->double_sided = false;
+  back_facing_surface->test_properties()->double_sided = false;
+  front_facing_child_of_front_facing_surface->test_properties()->double_sided =
+      false;
+  back_facing_child_of_front_facing_surface->test_properties()->double_sided =
+      false;
+  front_facing_child_of_back_facing_surface->test_properties()->double_sided =
+      false;
+  back_facing_child_of_back_facing_surface->test_properties()->double_sided =
+      false;
 
   // Everything draws content.
   front_facing_child->SetDrawsContent(true);
   back_facing_child->SetDrawsContent(true);
   front_facing_surface->SetDrawsContent(true);
   back_facing_surface->SetDrawsContent(true);
   front_facing_child_of_front_facing_surface->SetDrawsContent(true);
   back_facing_child_of_front_facing_surface->SetDrawsContent(true);
   front_facing_child_of_back_facing_surface->SetDrawsContent(true);
   back_facing_child_of_back_facing_surface->SetDrawsContent(true);
@@ skipping 96 matching lines @@
   animating_surface->SetDoubleSided(false);
   child_of_animating_surface->SetDoubleSided(false);
   animating_child->SetDoubleSided(false);
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
   // Make our render surface.
-  animating_surface->SetForceRenderSurface(true);
+  animating_surface->SetForceRenderSurfaceForTesting(true);
 
   // Animate the transform on the render surface.
   AddAnimatedTransformToLayerWithPlayer(animating_surface->id(), timeline(),
                                         10.0, 30, 0);
   // This is just an animating layer, not a surface.
   AddAnimatedTransformToLayerWithPlayer(animating_child->id(), timeline(), 10.0,
                                         30, 0);
 
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
@@ skipping 1921 matching lines @@
                                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->Set3dSortingContextId(1);
   back_facing->Set3dSortingContextId(1);
   back_facing->SetShouldFlattenTransform(false);
-  render_surface1->SetDoubleSided(false);
+  render_surface1->test_properties()->double_sided = false;
   render_surface2->Set3dSortingContextId(2);
-  render_surface2->SetDoubleSided(false);
+  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()
                     ->at(0)
                     ->render_surface()
                     ->layer_list()
@@ skipping 23 matching lines @@
                     ->layer_list()
                     .size());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
-  child->SetDoubleSided(false);
+  child->test_properties()->double_sided = false;
   grand_child->SetUseParentBackfaceVisibility(true);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), false, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), false, false,
                                false);
   SetLayerPropertiesForTesting(grand_child, identity_transform, gfx::Point3F(),
@@ skipping 43 matching lines @@
   EXPECT_TRUE(grand_child->should_check_backface_visibility());
   // child uses its local transform for backface visibility as it is the root of
   // a 3d rendering context. grand_child is in a 3d rendering context and is not
   // the root, but it derives its backface visibility from its parent which uses
   // its local transform.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(grand_child->use_local_transform_for_backface_visibility());
 
   grand_child->SetUseParentBackfaceVisibility(false);
-  grand_child->SetDoubleSided(false);
+  grand_child->test_properties()->double_sided = false;
   grand_child->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(0u, render_surface_layer_list_impl()
                     ->at(0)
                     ->render_surface()
                     ->layer_list()
                     .size());
 
@@ skipping 407 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->SetForceRenderSurface(true);
+  render_surface->test_properties()->force_render_surface = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->SetPositionConstraint(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);
@@ skipping 878 matching lines @@
   LayerImpl* root_layer = root.get();
   std::unique_ptr<LayerImpl> child1 =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->AddChild(std::move(child1));
   root->AddChild(std::move(child2));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   root->SetDrawsContent(true);
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
@@ skipping 300 matching lines @@
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
 
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false);
 
   root->SetMasksToBounds(true);
-  root->SetForceRenderSurface(true);
+  root->SetForceRenderSurfaceForTesting(true);
   animated->SetOpacity(0.f);
 
   AddOpacityTransitionToLayerWithPlayer(animated->id(), timeline(), 10.0, 0.f,
                                         1.f, false);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_FALSE(animated->visible_layer_rect_for_testing().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> clip = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(clip);
   clip->AddChild(animated);
   animated->AddChild(surface);
   surface->AddChild(descendant_of_animation);
 
   clip->SetMasksToBounds(true);
-  surface->SetForceRenderSurface(true);
+  surface->SetForceRenderSurfaceForTesting(true);
 
   host()->SetRootLayer(root);
 
   gfx::Transform uninvertible_matrix;
   uninvertible_matrix.Scale3d(6.f, 6.f, 0.f);
 
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(clip.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
@@ skipping 649 matching lines @@
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
   requests.clear();
   grandchild_ptr->PassCopyRequests(&requests);
   child_ptr->SetOpacity(1.f);
 
   // A double sided render surface with backface visible should not be skipped
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetHasRenderSurface(true);
-  child_ptr->SetDoubleSided(true);
+  child_ptr->test_properties()->double_sided = true;
   child_ptr->SetTransform(rotate_back_and_translate);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
   child_ptr->SetTransform(identity);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
@@ skipping 171 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->SetHideLayerAndSubtree(false);
 
   child->SetBounds(gfx::Size());
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->SetBounds(gfx::Size(10, 10));
 
   gfx::Transform rotate;
-  child->SetDoubleSided(false);
+  child->test_properties()->double_sided = false;
   rotate.RotateAboutXAxis(180.f);
   child->SetTransform(rotate);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
-  child->SetDoubleSided(true);
+  child->test_properties()->double_sided = true;
   child->SetTransform(identity);
 
   child->SetOpacity(0.f);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTreeRebuildTest) {
   // Ensure that the treewalk in LayerTreeHostCommom::
@@ skipping 107 matching lines @@
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false);
   SetLayerPropertiesForTesting(layer_clips_subtree, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false);
   SetLayerPropertiesForTesting(render_surface, transform2, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false);
 
-  root->SetForceRenderSurface(true);
-  significant_transform->SetForceRenderSurface(false);
-  layer_clips_subtree->SetForceRenderSurface(true);
-  render_surface->SetForceRenderSurface(true);
-  test_layer->SetForceRenderSurface(false);
+  root->test_properties()->force_render_surface = true;
+  significant_transform->test_properties()->force_render_surface = false;
+  layer_clips_subtree->test_properties()->force_render_surface = true;
+  render_surface->test_properties()->force_render_surface = true;
+  test_layer->test_properties()->force_render_surface = false;
   ExecuteCalculateDrawProperties(root);
 
   TransformTree transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
   EXPECT_EQ(transform_node->owner_id, significant_transform->id());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(significant_transform->has_render_surface());
@@ skipping 861 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