cc: Move main thread hierarchy dependencies into PropertyTreeBuilder

cc/trees/layer_tree_host.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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 199 matching lines @@
 }
 
 LayerTreeHost::LayerTreeHost(InitParams* params, CompositorMode mode)
     : micro_benchmark_controller_(this),
       next_ui_resource_id_(1),
       compositor_mode_(mode),
       needs_full_tree_sync_(true),
       needs_meta_info_recomputation_(true),
       client_(params->client),
       source_frame_number_(0),
-      meta_information_sequence_number_(1),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       output_surface_lost_(true),
       settings_(*params->settings),
       debug_state_(settings_.initial_debug_state),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0.f),
       top_controls_shown_ratio_(0.f),
       device_scale_factor_(1.f),
       painted_device_scale_factor_(1.f),
       visible_(false),
@@ skipping 418 matching lines @@
 
 void LayerTreeHost::FinishAllRendering() {
   proxy_->FinishAllRendering();
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
-  std::stack<Layer*> layer_stack;
-  layer_stack.push(root_layer());
-  while (!layer_stack.empty()) {
-    Layer* current_layer = layer_stack.top();
-    layer_stack.pop();
-    current_layer->SetNeedsDisplay();
-    for (unsigned int i = 0; i < current_layer->children().size(); i++) {
-      layer_stack.push(current_layer->child_at(i));
-    }
-  }
+  for (auto* layer : *this)
+    layer->SetNeedsDisplay();
 }
 
 void LayerTreeHost::SetOutputIsSecure(bool output_is_secure) {
   proxy_->SetOutputIsSecure(output_is_secure);
 }
 
 const RendererCapabilities& LayerTreeHost::GetRendererCapabilities() const {
   return proxy_->GetRendererCapabilities();
 }
 
@@ skipping 224 matching lines @@
 }
 
 LayerListIterator<Layer> LayerTreeHost::begin() {
   return LayerListIterator<Layer>(root_layer_.get());
 }
 
 LayerListIterator<Layer> LayerTreeHost::end() {
   return LayerListIterator<Layer>(nullptr);
 }
 
+const LayerListIterator<Layer> LayerTreeHost::begin() const {
+  return LayerListIterator<Layer>(root_layer_.get());
+}
+
+const LayerListIterator<Layer> LayerTreeHost::end() const {
+  return LayerListIterator<Layer>(nullptr);
+}
+
 LayerListReverseIterator<Layer> LayerTreeHost::rbegin() {
   return LayerListReverseIterator<Layer>(root_layer_.get());
 }
 
 LayerListReverseIterator<Layer> LayerTreeHost::rend() {
   return LayerListReverseIterator<Layer>(nullptr);
 }
 
 void LayerTreeHost::DidCompletePageScaleAnimation() {
   did_complete_scale_animation_ = true;
 }
 
-static Layer* FindFirstScrollableLayer(Layer* layer) {
-  if (!layer)
-    return NULL;
-
-  if (layer->scrollable())
-    return layer;
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
-    if (found)
-      return found;
-  }
-
-  return NULL;
-}
-
 void LayerTreeHost::RecordGpuRasterizationHistogram() {
   // Gpu rasterization is only supported for Renderer compositors.
   // Checking for IsSingleThreaded() to exclude Browser compositors.
   if (gpu_rasterization_histogram_recorded_ || IsSingleThreaded())
     return;
 
   // Record how widely gpu rasterization is enabled.
   // This number takes device/gpu whitelisting/backlisting into account.
   // Note that we do not consider the forced gpu rasterization mode, which is
   // mostly used for debugging purposes.
   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationEnabled",
                         settings_.gpu_rasterization_enabled);
   if (settings_.gpu_rasterization_enabled) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationTriggered",
                           has_gpu_rasterization_trigger_);
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationSuitableContent",
                           content_is_suitable_for_gpu_rasterization_);
     // Record how many pages actually get gpu rasterization when enabled.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationUsed",
                           (has_gpu_rasterization_trigger_ &&
                            content_is_suitable_for_gpu_rasterization_));
   }
 
   gpu_rasterization_histogram_recorded_ = true;
 }
 
 void LayerTreeHost::BuildPropertyTreesForTesting() {
-  LayerTreeHostCommon::PreCalculateMetaInformationForTesting(root_layer_.get());
+  PropertyTreeBuilder::PreCalculateMetaInformation(root_layer_.get());
   gfx::Transform identity_transform;
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer_.get(), page_scale_layer_.get(),
       inner_viewport_scroll_layer_.get(), outer_viewport_scroll_layer_.get(),
       overscroll_elasticity_layer_.get(), elastic_overscroll_,
       page_scale_factor_, device_scale_factor_,
       gfx::Rect(device_viewport_size_), identity_transform, &property_trees_);
 }
 
 bool LayerTreeHost::UsingSharedMemoryResources() {
   return GetRendererCapabilities().using_shared_memory_resources;
 }
 
 bool LayerTreeHost::DoUpdateLayers(Layer* root_layer) {
   TRACE_EVENT1("cc", "LayerTreeHost::DoUpdateLayers", "source_frame_number",
                source_frame_number());
 
   UpdateHudLayer();
 
-  Layer* root_scroll = FindFirstScrollableLayer(root_layer);
+  Layer* root_scroll =
+      PropertyTreeBuilder::FindFirstScrollableLayer(root_layer);
   Layer* page_scale_layer = page_scale_layer_.get();
   if (!page_scale_layer && root_scroll)
     page_scale_layer = root_scroll->parent();
 
   if (hud_layer_.get()) {
     hud_layer_->PrepareForCalculateDrawProperties(device_viewport_size(),
                                                   device_scale_factor_);
   }
 
   gfx::Transform identity_transform;
   LayerList update_layer_list;
 
   {
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::BuildPropertyTrees");
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                  "LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees");
-    LayerTreeHostCommon::PreCalculateMetaInformation(root_layer);
+    PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
     bool can_render_to_separate_surface = true;
     PropertyTreeBuilder::BuildPropertyTrees(
         root_layer, page_scale_layer, inner_viewport_scroll_layer_.get(),
         outer_viewport_scroll_layer_.get(), overscroll_elasticity_layer_.get(),
         elastic_overscroll_, page_scale_factor_, device_scale_factor_,
         gfx::Rect(device_viewport_size_), identity_transform, &property_trees_);
     draw_property_utils::UpdateRenderSurfaces(root_layer, &property_trees_);
     draw_property_utils::UpdatePropertyTrees(&property_trees_,
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(
@@ skipping 480 matching lines @@
   //   LayerTreeHost, so they are serialized outside of the LayerTreeHost
   //   serialization.
   // - The |visible_| flag will be controlled from the client separately and
   //   will need special handling outside of the serialization of the
   //   LayerTreeHost.
   // TODO(nyquist): Figure out how to support animations. See crbug.com/570376.
   TRACE_EVENT0("cc.remote", "LayerTreeHost::ToProtobufForCommit");
   proto->set_needs_full_tree_sync(needs_full_tree_sync_);
   proto->set_needs_meta_info_recomputation(needs_meta_info_recomputation_);
   proto->set_source_frame_number(source_frame_number_);
-  proto->set_meta_information_sequence_number(
-      meta_information_sequence_number_);
 
   LayerProtoConverter::SerializeLayerHierarchy(root_layer_,
                                                proto->mutable_root_layer());
 
   // layers_that_should_push_properties_ should be serialized before layer
   // properties because it is cleared during the properties serialization.
   for (auto layer : layers_that_should_push_properties_)
     proto->add_layers_that_should_push_properties(layer->id());
 
   LayerProtoConverter::SerializeLayerProperties(this,
@@ skipping 51 matching lines @@
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       "cc.remote", "LayerTreeHostProto", source_frame_number_,
       ComputeLayerTreeHostProtoSizeSplitAsValue(proto));
 }
 
 void LayerTreeHost::FromProtobufForCommit(const proto::LayerTreeHost& proto) {
   needs_full_tree_sync_ = proto.needs_full_tree_sync();
   needs_meta_info_recomputation_ = proto.needs_meta_info_recomputation();
   source_frame_number_ = proto.source_frame_number();
-  meta_information_sequence_number_ = proto.meta_information_sequence_number();
 
   // Layer hierarchy.
   scoped_refptr<Layer> new_root_layer =
       LayerProtoConverter::DeserializeLayerHierarchy(root_layer_,
                                                      proto.root_layer(), this);
   if (root_layer_ != new_root_layer) {
     root_layer_ = new_root_layer;
   }
 
   for (auto layer_id : proto.layers_that_should_push_properties())
@@ skipping 63 matching lines @@
   int seq_num = property_trees_.sequence_number;
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, [seq_num](Layer* layer) {
     layer->set_property_tree_sequence_number(seq_num);
   });
 
   surface_id_namespace_ = proto.surface_id_namespace();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc