cc :: Reland compute if layer is drawn from property trees

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 82 matching lines @@
       num_dependents_need_push_properties_(0),
       sorting_context_id_(0),
       current_draw_mode_(DRAW_MODE_NONE),
       element_id_(0),
       mutable_properties_(MutableProperty::kNone),
       force_render_surface_(false),
       frame_timing_requests_dirty_(false),
       visited_(false),
       layer_or_descendant_is_drawn_(false),
       layer_or_descendant_has_input_handler_(false),
-      sorted_for_recursion_(false),
-      is_hidden_from_property_trees_(false) {
+      sorted_for_recursion_(false) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
 
   if (!layer_tree_impl_->settings().use_compositor_animation_timelines) {
     AnimationRegistrar* registrar = layer_tree_impl_->GetAnimationRegistrar();
     layer_animation_controller_ =
         registrar->GetAnimationControllerForId(layer_id_);
     layer_animation_controller_->AddValueObserver(this);
     if (IsActive()) {
@@ skipping 537 matching lines @@
 
   layer->PushScrollOffset(nullptr);
 
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
   layer->SetTransformTreeIndex(transform_tree_index_);
   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_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
   }
 
   layer->SetScrollParent(scroll_parent);
   if (scroll_children_) {
     std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>;
@@ skipping 282 matching lines @@
     if (effect_tree_index_ >= static_cast<int>(effect_tree.size()))
       return;
     EffectNode* node = effect_tree.Node(effect_tree_index_);
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns an OpacityNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, an
     // opacity animation might have been in progress at the time the last commit
     // started, but might have finished since then on the compositor thread.
     if (node->owner_id != id())
       return;
-    node->data.opacity = opacity_;
+    node->data.opacity = EffectiveOpacity();
     effect_tree.set_needs_update(true);
   }
 }
 
 void LayerImpl::UpdatePropertyTreeForScrollingAndAnimationIfNeeded() {
   if (scrollable())
     UpdatePropertyTreeScrollOffset();
 
   if (HasAnyAnimationTargetingProperty(Animation::OPACITY))
     UpdatePropertyTreeOpacity();
 
   if (HasAnyAnimationTargetingProperty(Animation::TRANSFORM)) {
     UpdatePropertyTreeTransform();
     UpdatePropertyTreeTransformIsAnimated(
         HasPotentiallyRunningTransformAnimation());
   }
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
   SetFilters(filters);
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   SetOpacity(opacity);
-  UpdatePropertyTreeOpacity();
+  // When hide_layer_and_subtree is true, the effective opacity is zero and we
+  // need not update the opacity on property trees.
+  if (!hide_layer_and_subtree_)
+    UpdatePropertyTreeOpacity();
 }
 
 void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
   SetTransform(transform);
   UpdatePropertyTreeTransform();
   was_ever_ready_since_last_transform_animation_ = false;
 }
 
 void LayerImpl::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Only layers in the active tree should need to do anything here, since
@@ skipping 236 matching lines @@
 }
 
 void LayerImpl::SetOpacity(float opacity) {
   if (opacity_ == opacity)
     return;
 
   opacity_ = opacity;
   NoteLayerPropertyChangedForSubtree();
 }
 
+float LayerImpl::EffectiveOpacity() const {
+  return hide_layer_and_subtree_ ? 0.f : opacity_;
+}
+
 bool LayerImpl::OpacityIsAnimating() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
                    Animation::OPACITY, observer_type)
              : layer_tree_impl_->IsAnimatingOpacityProperty(this);
 }
 
@@ skipping 655 matching lines @@
 }
 
 gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
   gfx::Transform scaled_draw_transform = DrawTransform();
   scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
   gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), scale);
   return MathUtil::MapEnclosingClippedRect(scaled_draw_transform,
                                            gfx::Rect(scaled_bounds));
 }
 
-bool LayerImpl::LayerIsHidden() const {
+bool LayerImpl::IsHidden() const {
   if (layer_tree_impl()->settings().use_property_trees) {
-    return is_hidden_from_property_trees_;
+    EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
+    EffectNode* node = effect_tree.Node(effect_tree_index_);
+    return node->data.screen_space_opacity == 0.f;
   } else {
-    return hide_layer_and_subtree_ || (parent() && parent()->LayerIsHidden());
+    return EffectiveOpacity() == 0.f || (parent() && parent()->IsHidden());
   }
 }
 
 float LayerImpl::GetIdealContentsScale() const {
   float page_scale = IsAffectedByPageScale()
                          ? layer_tree_impl()->current_page_scale_factor()
                          : 1.f;
   float device_scale = layer_tree_impl()->device_scale_factor();
 
   float default_scale = page_scale * device_scale;
   if (!layer_tree_impl()
            ->settings()
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc