cc:: Do LayerIsHidden computation while building property trees

Instead of walking up the layer tree to see if any ancestor has
hide_layer_and_subtree as true.

BUG=568837
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1531473003

Cr-Commit-Position: refs/heads/master@{#366213}

8 files changed, 52 insertions, 16 deletions

diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc
index a5243e8..7a086a7 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -650,11 +650,11 @@ void ComputeTransforms(TransformTree* transform_tree) {
   transform_tree->set_needs_update(false);
 }
 
-void ComputeOpacities(EffectTree* effect_tree) {
+void ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
     return;
   for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
-    effect_tree->UpdateOpacities(i);
+    effect_tree->UpdateEffects(i);
   effect_tree->set_needs_update(false);
 }
 
@@ -675,7 +675,7 @@ static void ComputeVisibleRectsUsingPropertyTreesInternal(
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
-  ComputeOpacities(&property_trees->effect_tree);
+  ComputeEffects(&property_trees->effect_tree);
 
   const bool subtree_is_visible_from_ancestor = true;
   FindLayersThatNeedUpdates(root_layer, property_trees->transform_tree,
diff --git a/cc/trees/draw_property_utils.h b/cc/trees/draw_property_utils.h
index 72d9337..eda2e14 100644
--- a/cc/trees/draw_property_utils.h
+++ b/cc/trees/draw_property_utils.h
@@ -37,7 +37,7 @@ void CC_EXPORT ComputeClips(ClipTree* clip_tree,
 void CC_EXPORT ComputeTransforms(TransformTree* transform_tree);
 
 // Computes screen space opacity for every node in the opacity tree.
-void CC_EXPORT ComputeOpacities(EffectTree* effect_tree);
+void CC_EXPORT ComputeEffects(EffectTree* effect_tree);
 
 // Computes the visible content rect for every layer under |root_layer|. The
 // visible content rect is the clipped content space rect that will be used for
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index feffcf3..c4e46ed8 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -9244,6 +9244,33 @@ TEST_F(LayerTreeHostCommonTest,
   EXPECT_EQ(gfx::Rect(50, 50), test_layer->clip_rect());
 }
 
+TEST_F(LayerTreeHostCommonTest, SubtreeIsHiddenTest) {
+  // Tests that subtree is hidden is updated.
+  LayerImpl* root = root_layer();
+  LayerImpl* hidden = AddChild<LayerImpl>(root);
+  LayerImpl* test = AddChild<LayerImpl>(hidden);
+
+  const gfx::Transform identity_matrix;
+  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);
+  ExecuteCalculateDrawProperties(root);
+  EXPECT_TRUE(test->LayerIsHidden());
+
+  hidden->SetHideLayerAndSubtree(false);
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawProperties(root);
+  EXPECT_FALSE(test->LayerIsHidden());
+}
+
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc
index 43ab6c4..38015a4 100644
--- a/cc/trees/occlusion_tracker.cc
+++ b/cc/trees/occlusion_tracker.cc
@@ -163,11 +163,6 @@ void OcclusionTracker::EnterRenderTarget(const LayerImpl* new_target) {
           gfx::Rect(), old_target_to_new_target_transform));
 }
 
-static bool LayerIsHidden(const LayerImpl* layer) {
-  return layer->hide_layer_and_subtree() ||
-         (layer->parent() && LayerIsHidden(layer->parent()));
-}
-
 void OcclusionTracker::FinishedRenderTarget(const LayerImpl* finished_target) {
   // Make sure we know about the target surface.
   EnterRenderTarget(finished_target);
@@ -177,7 +172,7 @@ void OcclusionTracker::FinishedRenderTarget(const LayerImpl* finished_target) {
   // Readbacks always happen on render targets so we only need to check
   // for readbacks here.
   bool target_is_only_for_copy_request =
-      finished_target->HasCopyRequest() && LayerIsHidden(finished_target);
+      finished_target->HasCopyRequest() && finished_target->LayerIsHidden();
 
   // If the occlusion within the surface can not be applied to things outside of
   // the surface's subtree, then clear the occlusion here so it won't be used.
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index e66ff55..9c0e616 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -1020,15 +1020,20 @@ void TransformTree::FromProtobuf(const proto::PropertyTree& proto) {
   }
 }
 
-void EffectTree::UpdateOpacities(int id) {
-  EffectNode* node = Node(id);
+void EffectTree::UpdateOpacities(EffectNode* node, EffectNode* parent_node) {
   node->data.screen_space_opacity = node->data.opacity;
 
-  EffectNode* parent_node = parent(node);
   if (parent_node)
     node->data.screen_space_opacity *= parent_node->data.screen_space_opacity;
 }
 
+void EffectTree::UpdateEffects(int id) {
+  EffectNode* node = Node(id);
+  EffectNode* parent_node = parent(node);
+
+  UpdateOpacities(node, parent_node);
+}
+
 void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
     TransformNode* node,
     TransformNode* parent_node) {
diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h
index 4fbcc43..5afbcac 100644
--- a/cc/trees/property_tree.h
+++ b/cc/trees/property_tree.h
@@ -472,10 +472,13 @@ class CC_EXPORT EffectTree final : public PropertyTree<EffectNode> {
  public:
   bool operator==(const EffectTree& other) const;
 
-  void UpdateOpacities(int id);
+  void UpdateEffects(int id);
 
   void ToProtobuf(proto::PropertyTree* proto) const;
   void FromProtobuf(const proto::PropertyTree& proto);
+
+ private:
+  void UpdateOpacities(EffectNode* node, EffectNode* parent_node);
 };
 
 class CC_EXPORT PropertyTrees final {
diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index 2978af6..7c59807 100644
--- a/cc/trees/property_tree_builder.cc
+++ b/cc/trees/property_tree_builder.cc
@@ -45,6 +45,7 @@ struct DataForRecursion {
   bool affected_by_outer_viewport_bounds_delta;
   bool should_flatten;
   bool target_is_clipped;
+  bool is_hidden;
   const gfx::Transform* device_transform;
   gfx::Vector2dF scroll_compensation_adjustment;
   gfx::Transform compound_transform_since_render_target;
@@ -645,6 +646,10 @@ void BuildPropertyTreesInternal(
   if (layer == data_from_parent.page_scale_layer)
     data_for_children.in_subtree_of_page_scale_layer = true;
 
+  data_for_children.is_hidden =
+      layer->hide_layer_and_subtree() || data_from_parent.is_hidden;
+  layer->set_is_hidden_from_property_trees(data_for_children.is_hidden);
+
   for (size_t i = 0; i < layer->children().size(); ++i) {
     if (!layer->child_at(i)->scroll_parent()) {
       BuildPropertyTreesInternal(layer->child_at(i), data_for_children);
@@ -716,6 +721,7 @@ void BuildPropertyTreesTopLevelInternal(
   data_for_recursion.affected_by_outer_viewport_bounds_delta = false;
   data_for_recursion.should_flatten = false;
   data_for_recursion.target_is_clipped = false;
+  data_for_recursion.is_hidden = false;
   data_for_recursion.device_transform = &device_transform;
 
   data_for_recursion.transform_tree->clear();
diff --git a/cc/trees/property_tree_unittest.cc b/cc/trees/property_tree_unittest.cc
index 65cb414..2d6df1a 100644
--- a/cc/trees/property_tree_unittest.cc
+++ b/cc/trees/property_tree_unittest.cc
@@ -911,13 +911,13 @@ class PropertyTreeTestScreenSpaceOpacityUpdateTest : public PropertyTreeTest {
     tree.Node(parent)->data.opacity = 0.5f;
     tree.set_needs_update(true);
     tree = EffectTreeForTest(tree);
-    ComputeOpacities(&tree);
+    ComputeEffects(&tree);
     EXPECT_EQ(tree.Node(child)->data.screen_space_opacity, 0.5f);
 
     tree.Node(child)->data.opacity = 0.5f;
     tree.set_needs_update(true);
     tree = EffectTreeForTest(tree);
-    ComputeOpacities(&tree);
+    ComputeEffects(&tree);
     EXPECT_EQ(tree.Node(child)->data.screen_space_opacity, 0.25f);
   }
 };