Keeping track of descendants that draw content instead of recalcualting

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/debug/trace_event.h"
@@ skipping 29 matching lines @@
     : needs_push_properties_(false),
       num_dependents_need_push_properties_(false),
       stacking_order_changed_(false),
       // Layer IDs start from 1.
       layer_id_(g_next_layer_id.GetNext() + 1),
       ignore_set_needs_commit_(false),
       sorting_context_id_(0),
       parent_(NULL),
       layer_tree_host_(NULL),
       scroll_clip_layer_id_(INVALID_ID),
+      num_descendants_that_draw_content_(0),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       have_scroll_event_handlers_(false),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       is_root_for_isolated_group_(false),
       is_container_for_fixed_position_layers_(false),
       is_drawable_(false),
+      draws_content_(false),
       hide_layer_and_subtree_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       force_render_surface_(false),
       transform_is_invertible_(true),
       background_color_(0),
@@ skipping 175 matching lines @@
 }
 
 void Layer::InsertChild(scoped_refptr<Layer> child, size_t index) {
   DCHECK(IsPropertyChangeAllowed());
   child->RemoveFromParent();
   child->SetParent(this);
   child->stacking_order_changed_ = true;
 
   index = std::min(index, children_.size());
   children_.insert(children_.begin() + index, child);
+  AddDrawableDescendants(child->NumDescendantsThatDrawContent() +
+                         (child->DrawsContent() ? 1 : 0));
   SetNeedsFullTreeSync();
 }
 
 void Layer::RemoveFromParent() {
   DCHECK(IsPropertyChangeAllowed());
   if (parent_)
     parent_->RemoveChildOrDependent(this);
 }
 
 void Layer::RemoveChildOrDependent(Layer* child) {
@@ skipping 10 matching lines @@
     return;
   }
 
   for (LayerList::iterator iter = children_.begin();
        iter != children_.end();
        ++iter) {
     if (iter->get() != child)
       continue;
 
     child->SetParent(NULL);
+    AddDrawableDescendants(-child->NumDescendantsThatDrawContent() -
+                           (child->DrawsContent() ? 1 : 0));
     children_.erase(iter);
     SetNeedsFullTreeSync();
     return;
   }
 }
 
 void Layer::ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer) {
   DCHECK(reference);
   DCHECK_EQ(reference->parent(), this);
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 479 matching lines @@
   should_flatten_transform_ = should_flatten;
   SetNeedsCommit();
 }
 
 void Layer::SetIsDrawable(bool is_drawable) {
   DCHECK(IsPropertyChangeAllowed());
   if (is_drawable_ == is_drawable)
     return;
 
   is_drawable_ = is_drawable;
-  SetNeedsCommit();
+  UpdateDrawsContent(HasDrawableContent());
 }
 
 void Layer::SetHideLayerAndSubtree(bool hide) {
   DCHECK(IsPropertyChangeAllowed());
   if (hide_layer_and_subtree_ == hide)
     return;
 
   hide_layer_and_subtree_ = hide;
   SetNeedsCommit();
 }
@@ skipping 100 matching lines @@
   layer->SetPosition(position_);
   layer->SetIsContainerForFixedPositionLayers(
       IsContainerForFixedPositionLayers());
   layer->SetPositionConstraint(position_constraint_);
   layer->SetShouldFlattenTransform(should_flatten_transform_);
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   if (!layer->TransformIsAnimatingOnImplOnly() && !TransformIsAnimating())
     layer->SetTransformAndInvertibility(transform_, transform_is_invertible_);
   DCHECK(!(TransformIsAnimating() && layer->TransformIsAnimatingOnImplOnly()));
   layer->Set3dSortingContextId(sorting_context_id_);
+  layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
   layer->SetScrollClipLayer(scroll_clip_layer_id_);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
 
   LayerImpl* scroll_parent = NULL;
   if (scroll_parent_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
   }
@@ skipping 86 matching lines @@
 
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 bool Layer::DrawsContent() const {
+  return draws_content_;
+}
+
+bool Layer::HasDrawableContent() const {
   return is_drawable_;
 }
 
+void Layer::UpdateDrawsContent(bool has_drawable_content) {
+  bool draws_content = has_drawable_content;

[danakj, 2014/08/06 14:57:07]

can you DCHECK(is_drawable_ || !has_drawable_content) // Input should true only
if HasDrawableContent() is true.

[awoloszyn, 2014/08/08 15:53:20]

I will DCHECK(HasDrawableContent() || !has_drawable_content). I can't DCHECK
against is_drawable_ because HeadsUpDisplayLayer is always drawable regardless
of layer's HasDrawableContent().

[danakj, 2014/08/08 16:04:04]

Oh I see. Can we just make HUD layer's constructor call SetIsDrawable(true) and
then we can dcheck that? I was trying to ensure layers are && with the base
class with that dcheck.

+  if (draws_content == draws_content_)
+    return;
+
+  if (HasDelegatedContent()) {
+    // As per the comment that was originally in

[danakj, 2014/08/06 14:57:07]

I think you can drop the mention of Precalculate, the comment just belongs here
now.

[awoloszyn, 2014/08/08 15:53:20]

Done.

+    // LayerTreeHost::PrecalculateMetaInformation:
+    // Layers with delegated content need to be treated as if they have as
+    // many children as the number of layers they own delegated quads for.
+    // Since we don't know this number right now, we choose one that acts like
+    // infinity for our purposes.
+    AddDrawableDescendants(draws_content ? 1000 : -1000);
+  }
+
+  if (parent()) {
+    if (draws_content) {
+      parent()->AddDrawableDescendants(1);

[danakj, 2014/08/06 14:57:07]

draws_content ? 1 : -1 like you did above for delegated? then you dont need this
long if/else

[awoloszyn, 2014/08/08 15:53:20]

Done.

+    } else {
+      parent()->AddDrawableDescendants(-1);
+    }
+  }
+  draws_content_ = draws_content;
+  SetNeedsCommit();
+}
+
+int Layer::NumDescendantsThatDrawContent() const {
+  return num_descendants_that_draw_content_;
+}
+
 void Layer::SavePaintProperties() {
   DCHECK(layer_tree_host_);
 
   // TODO(reveman): Save all layer properties that we depend on not
   // changing until PushProperties() has been called. crbug.com/231016
   paint_properties_.bounds = bounds_;
   paint_properties_.source_frame_number =
       layer_tree_host_->source_frame_number();
 }
 
@@ skipping 160 matching lines @@
         it != clip_children_->end(); ++it)
       (*it)->clip_parent_ = NULL;
   }
 
   if (clip_parent_)
     clip_parent_->RemoveClipChild(this);
 
   clip_parent_ = NULL;
 }
 
+void Layer::AddDrawableDescendants(int num) {
+  DCHECK_GE(num_descendants_that_draw_content_, 0);
+  DCHECK_GE(num_descendants_that_draw_content_ + num, 0);
+  if (num == 0)
+    return;
+  num_descendants_that_draw_content_ += num;
+  SetNeedsCommit();
+  if (parent())
+    parent()->AddDrawableDescendants(num);
+}
+
 void Layer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
+
+bool Layer::HasDelegatedContent() const {
+  return false;
+}
+
 }  // namespace cc