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}

14 files changed, 83 insertions, 21 deletions

diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index a3a79b4..526b5dd 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -97,7 +97,8 @@ Layer::Layer(const LayerSettings& settings)
       replica_layer_(nullptr),
       client_(nullptr),
       num_unclipped_descendants_(0),
-      frame_timing_requests_dirty_(false) {
+      frame_timing_requests_dirty_(false),
+      is_hidden_from_property_trees_(false) {
   if (!settings.use_compositor_animation_timelines) {
     layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
     layer_animation_controller_->AddValueObserver(this);
@@ -1249,6 +1250,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
   layer->SetElementId(element_id_);
   layer->SetMutableProperties(mutable_properties_);
+  layer->set_is_hidden_from_property_trees(is_hidden_from_property_trees_);
 
   LayerImpl* scroll_parent = nullptr;
   if (scroll_parent_) {
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 06669d3..c5c031c 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -560,6 +560,12 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   bool layer_or_descendant_is_drawn();
   void set_sorted_for_recursion(bool sorted_for_recursion);
   bool sorted_for_recursion();
+  void set_is_hidden_from_property_trees(bool is_hidden) {
+    if (is_hidden == is_hidden_from_property_trees_)
+      return;
+    is_hidden_from_property_trees_ = is_hidden;
+    SetNeedsPushProperties();
+  }
 
   // LayerAnimationValueProvider implementation.
   gfx::ScrollOffset ScrollOffsetForAnimation() const override;
@@ -789,6 +795,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
 
   std::vector<FrameTimingRequest> frame_timing_requests_;
   bool frame_timing_requests_dirty_;
+  bool is_hidden_from_property_trees_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 432992b..74927e8 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -96,7 +96,8 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
       visited_(false),
       layer_or_descendant_is_drawn_(false),
       layer_or_descendant_has_input_handler_(false),
-      sorted_for_recursion_(false) {
+      sorted_for_recursion_(false),
+      is_hidden_from_property_trees_(false) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
@@ -624,6 +625,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer->SetClipTreeIndex(clip_tree_index_);
   layer->SetEffectTreeIndex(effect_tree_index_);
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
+  layer->set_is_hidden_from_property_trees(is_hidden_from_property_trees_);
 
   LayerImpl* scroll_parent = nullptr;
   if (scroll_parent_) {
@@ -1875,6 +1877,14 @@ gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
                                            gfx::Rect(scaled_bounds));
 }
 
+bool LayerImpl::LayerIsHidden() const {
+  if (layer_tree_impl()->settings().use_property_trees) {
+    return is_hidden_from_property_trees_;
+  } else {
+    return hide_layer_and_subtree_ || (parent() && parent()->LayerIsHidden());
+  }
+}
+
 float LayerImpl::GetIdealContentsScale() const {
   float page_scale = IsAffectedByPageScale()
                          ? layer_tree_impl()->current_page_scale_factor()
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 0a88918..8d83a0e 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -687,6 +687,14 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
 
   void UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
 
+  void set_is_hidden_from_property_trees(bool is_hidden) {
+    if (is_hidden == is_hidden_from_property_trees_)
+      return;
+    is_hidden_from_property_trees_ = is_hidden;
+    SetNeedsPushProperties();
+  }
+  bool LayerIsHidden() const;
+
   float GetIdealContentsScale() const;
 
   bool was_ever_ready_since_last_transform_animation() const {
@@ -891,6 +899,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   // If true, the layer or one of its descendants has a wheel or touch handler.
   bool layer_or_descendant_has_input_handler_;
   bool sorted_for_recursion_;
+  bool is_hidden_from_property_trees_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
diff --git a/cc/layers/scrollbar_layer_impl_base.cc b/cc/layers/scrollbar_layer_impl_base.cc
index 4e18b62..e8e0f80 100644
--- a/cc/layers/scrollbar_layer_impl_base.cc
+++ b/cc/layers/scrollbar_layer_impl_base.cc
@@ -33,10 +33,8 @@ ScrollbarLayerImplBase::~ScrollbarLayerImplBase() {
 
 void ScrollbarLayerImplBase::PushPropertiesTo(LayerImpl* layer) {
   float active_opacity = layer->opacity();
-  bool active_hidden = layer->hide_layer_and_subtree();
   LayerImpl::PushPropertiesTo(layer);
   layer->SetOpacity(active_opacity);
-  layer->SetHideLayerAndSubtree(active_hidden);
   DCHECK(layer->ToScrollbarLayer());
   layer->ToScrollbarLayer()->set_is_overlay_scrollbar(is_overlay_scrollbar_);
   layer->ToScrollbarLayer()->SetScrollLayerId(ScrollLayerId());
diff --git a/cc/proto/property_tree.proto b/cc/proto/property_tree.proto
index 6bf2a7f..972c0c9 100644
--- a/cc/proto/property_tree.proto
+++ b/cc/proto/property_tree.proto
@@ -145,4 +145,4 @@ message PropertyTrees {
   optional bool needs_rebuild = 4;
   optional bool non_root_surfaces_enabled = 5;
   optional int64 sequence_number = 6;
-}
\ No newline at end of file
+}
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);
   }
 };