cc : Add subtree is hidden bool to effect tree

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 5502 matching lines @@
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
-  grand_child->SetHideLayerAndSubtree(true);
+  grand_child->test_properties()->hide_layer_and_subtree = true;
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
@@ skipping 23 matching lines @@
                                true);
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
   child->SetDrawsContent(true);
-  child->SetHideLayerAndSubtree(true);
+  child->test_properties()->hide_layer_and_subtree = true;
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
@@ skipping 94 matching lines @@
   copy_parent->AddChild(std::move(copy_request));
   copy_grand_parent->AddChild(std::move(copy_parent));
   root->AddChild(std::move(copy_grand_parent_sibling_before));
   root->AddChild(std::move(copy_grand_parent));
   root->AddChild(std::move(copy_grand_parent_sibling_after));
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   // Hide the copy_grand_parent and its subtree. But make a copy request in that
   // hidden subtree on copy_layer. Also hide the copy grand child and its
   // subtree.
-  copy_grand_parent_layer->SetHideLayerAndSubtree(true);
-  copy_grand_parent_sibling_before_layer->SetHideLayerAndSubtree(true);
-  copy_grand_parent_sibling_after_layer->SetHideLayerAndSubtree(true);
-  copy_grand_child_layer->SetHideLayerAndSubtree(true);
+  copy_grand_parent_layer->test_properties()->hide_layer_and_subtree = true;
+  copy_grand_parent_sibling_before_layer->test_properties()
+      ->hide_layer_and_subtree = true;
+  copy_grand_parent_sibling_after_layer->test_properties()
+      ->hide_layer_and_subtree = true;
+  copy_grand_child_layer->test_properties()->hide_layer_and_subtree = true;
 
   std::vector<std::unique_ptr<CopyOutputRequest>> copy_requests;
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
   copy_layer->PassCopyRequests(&copy_requests);
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
@@ skipping 3117 matching lines @@
   gfx::Transform rotate_back_and_translate;
   rotate_back_and_translate.RotateAboutYAxis(180);
   rotate_back_and_translate.Translate(-10, 0);
 
   child_ptr->SetTransform(singular);
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->SetTransform(identity);
 
-  child_ptr->SetHideLayerAndSubtree(true);
+  child_ptr->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  child_ptr->SetHideLayerAndSubtree(false);
+  child_ptr->test_properties()->hide_layer_and_subtree = false;
 
   child_ptr->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->SetOpacity(1.f);
 
   root_ptr->SetTransform(singular);
   // Force transform tree to have a node for child, so that ancestor's
   // invertible transform can be tested.
   child_ptr->SetTransform(rotate);
@@ skipping 200 matching lines @@
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   child->set_visible_layer_rect(gfx::Rect());
 
-  child->SetHideLayerAndSubtree(true);
+  child->test_properties()->hide_layer_and_subtree = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
-  child->SetHideLayerAndSubtree(false);
+  child->test_properties()->hide_layer_and_subtree = 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->test_properties()->double_sided = false;
   rotate.RotateAboutXAxis(180.f);
@@ skipping 604 matching lines @@
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(hidden, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(30, 30), true,
                                false, true);
   SetLayerPropertiesForTesting(test, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
 
-  hidden->SetHideLayerAndSubtree(true);
+  hidden->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(test->IsHidden());
 
-  hidden->SetHideLayerAndSubtree(false);
+  hidden->test_properties()->hide_layer_and_subtree = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(test->IsHidden());
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
@@ skipping 379 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