Setup LayerTree class, refactor 2 functions from LayerTreeHost to it.

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 26 matching lines @@
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/layer_proto_converter.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/proto/gfx_conversions.h"
+#include "cc/proto/layer_tree.pb.h"
 #include "cc/proto/layer_tree_host.pb.h"
 #include "cc/resources/ui_resource_request.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree_builder.h"
 #include "cc/trees/proxy_main.h"
 #include "cc/trees/remote_channel_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace {
 static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
 }
 
 namespace cc {
 namespace {
 
 Layer* UpdateAndGetLayer(Layer* current_layer,
                          int layer_id,
-                         const std::unordered_map<int, Layer*>& layer_id_map) {
+                         LayerTree* layer_tree) {
   if (layer_id == Layer::INVALID_ID) {
     if (current_layer)
       current_layer->SetLayerTreeHost(nullptr);
 
     return nullptr;
   }
-
-  auto layer_it = layer_id_map.find(layer_id);
-  DCHECK(layer_it != layer_id_map.end());
-  if (current_layer && current_layer != layer_it->second)
+  Layer* layer = layer_tree->LayerById(layer_id);
+  DCHECK(layer);
+  if (current_layer && current_layer != layer)
     current_layer->SetLayerTreeHost(nullptr);
 
-  return layer_it->second;
+  return layer;
 }
 
 std::unique_ptr<base::trace_event::TracedValue>
 ComputeLayerTreeHostProtoSizeSplitAsValue(proto::LayerTreeHost* proto) {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   base::CheckedNumeric<int> base_layer_properties_size = 0;
   base::CheckedNumeric<int> picture_layer_properties_size = 0;
   base::CheckedNumeric<int> display_item_list_size = 0;
   base::CheckedNumeric<int> drawing_display_items_size = 0;
@@ skipping 138 matching lines @@
       page_scale_factor_(1.f),
       min_page_scale_factor_(1.f),
       max_page_scale_factor_(1.f),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
       have_scroll_event_handlers_(false),
       event_listener_properties_(),
-      animation_host_(std::move(params->animation_host)),
       did_complete_scale_animation_(false),
-      in_paint_layer_contents_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(params->shared_bitmap_manager),
       gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
       task_graph_runner_(params->task_graph_runner),
       image_serialization_processor_(params->image_serialization_processor),
       surface_client_id_(0u),
-      next_surface_sequence_(1u) {
+      next_surface_sequence_(1u),
+      layer_tree_(&(params->animation_host)) {

[Khushal, 2016/07/20 00:46:51]

You don't need to pass a reference to the unique_ptr, you can std::move the ptr
itself.

LayerTree(std::unique_ptr<AnimationHost> animation_host) would be the ctor.

And in the initialization here, layer_tree_(std::move(params->animation_host)).

[xingliu, 2016/07/20 20:33:06]

Done, maybe release() and pass raw pointer to LayerTree is more clear?

[Khushal, 2016/07/20 21:29:48]

Use unique pointers if you're passing ownership, it makes it very clear. If you
get a raw pointer, its unclear whether you're just getting a weak reference or
you're supposed to take ownership.

   DCHECK(task_graph_runner_);
 
-  DCHECK(animation_host_);
-  animation_host_->SetMutatorHostClient(this);
+  layer_tree_.animation_host()->SetMutatorHostClient(this);
 
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
 }
 
 void LayerTreeHost::InitializeThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ =
@@ skipping 90 matching lines @@
 
 void LayerTreeHost::InitializeProxy(
     std::unique_ptr<Proxy> proxy,
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
   DCHECK(task_runner_provider_);
 
   proxy_ = std::move(proxy);
   proxy_->Start(std::move(external_begin_frame_source));
 
-  animation_host_->SetSupportsScrollAnimations(proxy_->SupportsImplScrolling());
+  GetLayerTree()->animation_host()->SetSupportsScrollAnimations(
+      proxy_->SupportsImplScrolling());
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
-  animation_host_->SetMutatorHostClient(nullptr);
+  GetLayerTree()->animation_host()->SetMutatorHostClient(nullptr);
 
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
 
   DCHECK(swap_promise_monitor_.empty());
 
   BreakSwapPromises(SwapPromise::COMMIT_FAILS);
 
   if (proxy_) {
     DCHECK(task_runner_provider_->IsMainThread());
@@ skipping 157 matching lines @@
     ui_resource_request_queue_.clear();
   }
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   sync_tree->set_has_ever_been_drawn(false);
 
   {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
 
-    TreeSynchronizer::PushLayerProperties(this, sync_tree);
+    TreeSynchronizer::PushLayerProperties(GetLayerTree(), sync_tree);
 
     // This must happen after synchronizing property trees and after push
     // properties, which updates property tree indices, but before animation
     // host pushes properties as animation host push properties can change
     // Animation::InEffect and we want the old InEffect value for updating
     // property tree scrolling and animation.
     sync_tree->UpdatePropertyTreeScrollingAndAnimationFromMainThread();
 
     TRACE_EVENT0("cc", "LayerTreeHost::AnimationHost::PushProperties");
     DCHECK(host_impl->animation_host());
-    animation_host_->PushPropertiesTo(host_impl->animation_host());
+    GetLayerTree()->animation_host()->PushPropertiesTo(
+        host_impl->animation_host());
   }
 
   // This must happen after synchronizing property trees and after pushing
   // properties, which updates the clobber_active_value flag.
   sync_tree->UpdatePropertyTreeScrollOffset(&property_trees_);
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
   property_trees_.ResetAllChangeTracking();
 }
 
@@ skipping 66 matching lines @@
   client_->DidFailToInitializeOutputSurface();
 }
 
 std::unique_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
   DCHECK(!IsRemoteServer());
   DCHECK(task_runner_provider_->IsImplThread());
 
   const bool supports_impl_scrolling = task_runner_provider_->HasImplThread();
   std::unique_ptr<AnimationHost> animation_host_impl =
-      animation_host_->CreateImplInstance(supports_impl_scrolling);
+      GetLayerTree()->animation_host()->CreateImplInstance(
+          supports_impl_scrolling);
 
   std::unique_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
       settings_, client, task_runner_provider_.get(),
       rendering_stats_instrumentation_.get(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_, task_graph_runner_,
       std::move(animation_host_impl), id_);
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   shared_bitmap_manager_ = NULL;
@@ skipping 84 matching lines @@
 }
 
 void LayerTreeHost::SetNextCommitForcesRedraw() {
   next_commit_forces_redraw_ = true;
   proxy_->SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetAnimationEvents(
     std::unique_ptr<AnimationEvents> events) {
   DCHECK(task_runner_provider_->IsMainThread());
-  animation_host_->SetAnimationEvents(std::move(events));
+  GetLayerTree()->animation_host()->SetAnimationEvents(std::move(events));
 }
 
 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
   if (root_layer_.get() == root_layer.get())
     return;
 
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
   root_layer_ = root_layer;
   if (root_layer_.get()) {
@@ skipping 273 matching lines @@
     }
     draw_property_utils::UpdatePropertyTrees(&property_trees_,
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(
         this, property_trees_.transform_tree, property_trees_.effect_tree,
         &update_layer_list);
   }
 
   for (const auto& layer : update_layer_list)
     layer->SavePaintProperties();
-
-  base::AutoReset<bool> painting(&in_paint_layer_contents_, true);
+  bool& in_paint_layer_contents = GetLayerTree()->get_in_paint_layer_contents();

[Khushal, 2016/07/20 00:46:51]

I think we can have the iteration through the layers during update happen in the
LayerTree itself, so you can set the flag there.

[xingliu, 2016/07/20 20:33:06]

Done.

+  base::AutoReset<bool> painting(&in_paint_layer_contents, true);
   bool did_paint_content = false;
   bool content_is_suitable_for_gpu = true;
   for (const auto& layer : update_layer_list) {
     did_paint_content |= layer->Update();
     content_is_suitable_for_gpu &= layer->IsSuitableForGpuRasterization();
   }
 
   if (content_is_suitable_for_gpu) {
     ++num_consecutive_frames_suitable_for_gpu_;
     if (num_consecutive_frames_suitable_for_gpu_ >=
@@ skipping 90 matching lines @@
 
 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
                                            TopControlsState current,
                                            bool animate) {
   // Top controls are only used in threaded or remote mode.
   DCHECK(IsThreaded() || IsRemoteServer());
   proxy_->UpdateTopControlsState(constraints, current, animate);
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
-  std::unique_ptr<AnimationEvents> events = animation_host_->CreateEvents();
+  AnimationHost* animation_host = GetLayerTree()->animation_host();
+  std::unique_ptr<AnimationEvents> events = animation_host->CreateEvents();
 
-  if (animation_host_->AnimateLayers(monotonic_time))
-    animation_host_->UpdateAnimationState(true, events.get());
+  if (animation_host->AnimateLayers(monotonic_time))
+    animation_host->UpdateAnimationState(true, events.get());
 
   if (!events->events_.empty())
     property_trees_.needs_rebuild = true;
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
   DCHECK(client);
 
   UIResourceId next_id = next_ui_resource_id_++;
   DCHECK(ui_resource_client_map_.find(next_id) ==
@@ skipping 138 matching lines @@
 SurfaceSequence LayerTreeHost::CreateSurfaceSequence() {
   return SurfaceSequence(surface_client_id_, next_surface_sequence_++);
 }
 
 void LayerTreeHost::SetLayerTreeMutator(
     std::unique_ptr<LayerTreeMutator> mutator) {
   proxy_->SetMutator(std::move(mutator));
 }
 
 Layer* LayerTreeHost::LayerById(int id) const {
-  LayerIdMap::const_iterator iter = layer_id_map_.find(id);
-  return iter != layer_id_map_.end() ? iter->second : nullptr;
+  return GetLayerTree()->LayerById(id);
 }
 
 Layer* LayerTreeHost::LayerByElementId(ElementId element_id) const {
   ElementLayersMap::const_iterator iter = element_layers_map_.find(element_id);
   return iter != element_layers_map_.end() ? iter->second : nullptr;
 }
 
 void LayerTreeHost::AddToElementMap(Layer* layer) {
   if (!layer->element_id())
     return;
 
   element_layers_map_[layer->element_id()] = layer;
 }
 
 void LayerTreeHost::RemoveFromElementMap(Layer* layer) {
   if (!layer->element_id())
     return;
 
   element_layers_map_.erase(layer->element_id());
 }
 
-void LayerTreeHost::AddLayerShouldPushProperties(Layer* layer) {
-  layers_that_should_push_properties_.insert(layer);
-}
-
-void LayerTreeHost::RemoveLayerShouldPushProperties(Layer* layer) {
-  layers_that_should_push_properties_.erase(layer);
-}
-
-std::unordered_set<Layer*>& LayerTreeHost::LayersThatShouldPushProperties() {
-  return layers_that_should_push_properties_;
-}
-
 bool LayerTreeHost::LayerNeedsPushPropertiesForTesting(Layer* layer) {

[Khushal, 2016/07/20 00:46:51]

Since we are moving all tracking for layers that are dirty to the LayerTree, you
can move this method there as well.

[xingliu, 2016/07/20 20:33:06]

Done.

-  return layers_that_should_push_properties_.find(layer) !=
-         layers_that_should_push_properties_.end();
-}
-
-void LayerTreeHost::RegisterLayer(Layer* layer) {
-  DCHECK(!LayerById(layer->id()));
-  DCHECK(!in_paint_layer_contents_);
-  layer_id_map_[layer->id()] = layer;
-  if (layer->element_id()) {
-    animation_host_->RegisterElement(layer->element_id(),
-                                     ElementListType::ACTIVE);
-  }
-}
-
-void LayerTreeHost::UnregisterLayer(Layer* layer) {
-  DCHECK(LayerById(layer->id()));
-  DCHECK(!in_paint_layer_contents_);
-  if (layer->element_id()) {
-    animation_host_->UnregisterElement(layer->element_id(),
-                                       ElementListType::ACTIVE);
-  }
-  RemoveLayerShouldPushProperties(layer);
-  layer_id_map_.erase(layer->id());
+  const LayerSet& layers = GetLayerTree()->LayersThatShouldPushProperties();
+  return layers.find(layer) != layers.end();
 }
 
 bool LayerTreeHost::IsElementInList(ElementId element_id,
                                     ElementListType list_type) const {
   return list_type == ElementListType::ACTIVE && LayerByElementId(element_id);
 }
 
 void LayerTreeHost::SetMutatorsNeedCommit() {
   SetNeedsCommit();
 }
@@ skipping 138 matching lines @@
   swap_promises->swap(swap_promise_list_);
   DCHECK(swap_promise_list_.empty());
 
   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_);
 
   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());
+  // Serialize LayerTree before LayerTree.layers_that_should_push_properties_
+  // is cleared.
+  GetLayerTree()->ToProtobuf(proto->mutable_layer_tree());
 
+  // This will clear LayerTree.layers_that_should_push_properties_.
   LayerProtoConverter::SerializeLayerProperties(this,
                                                 proto->mutable_layer_updates());
 
   std::vector<PictureData> pictures =
       engine_picture_cache_->CalculateCacheUpdateAndFlush();
   proto::PictureDataVectorToSkPicturesProto(pictures,
                                             proto->mutable_pictures());
 
   proto->set_hud_layer_id(hud_layer_ ? hud_layer_->id() : Layer::INVALID_ID);
   debug_state_.ToProtobuf(proto->mutable_debug_state());
@@ skipping 14 matching lines @@
   proto->set_has_transparent_background(has_transparent_background_);
   proto->set_have_scroll_event_handlers(have_scroll_event_handlers_);
   proto->set_wheel_event_listener_properties(static_cast<uint32_t>(
       event_listener_properties(EventListenerClass::kMouseWheel)));
   proto->set_touch_start_or_move_event_listener_properties(
       static_cast<uint32_t>(
           event_listener_properties(EventListenerClass::kTouchStartOrMove)));
   proto->set_touch_end_or_cancel_event_listener_properties(
       static_cast<uint32_t>(
           event_listener_properties(EventListenerClass::kTouchEndOrCancel)));
-  proto->set_in_paint_layer_contents(in_paint_layer_contents_);
   proto->set_id(id_);
   proto->set_next_commit_forces_redraw(next_commit_forces_redraw_);
 
   // Viewport layers.
   proto->set_overscroll_elasticity_layer_id(
       overscroll_elasticity_layer_ ? overscroll_elasticity_layer_->id()
                                    : Layer::INVALID_ID);
   proto->set_page_scale_layer_id(page_scale_layer_ ? page_scale_layer_->id()
                                                    : Layer::INVALID_ID);
   proto->set_inner_viewport_scroll_layer_id(
@@ skipping 10 matching lines @@
   proto->set_surface_client_id(surface_client_id_);
   proto->set_next_surface_sequence(next_surface_sequence_);
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       "cc.remote", "LayerTreeHostProto", source_frame_number_,
       ComputeLayerTreeHostProtoSizeSplitAsValue(proto));
 }
 
 void LayerTreeHost::FromProtobufForCommit(const proto::LayerTreeHost& proto) {
   DCHECK(client_picture_cache_);
-
+  LayerTree* layer_tree = GetLayerTree();
   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();
 
   // 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())
-    layers_that_should_push_properties_.insert(layer_id_map_[layer_id]);
+  layer_tree->FromProtobuf(proto.layer_tree());
 
   // Ensure ClientPictureCache contains all the necessary SkPictures before
   // deserializing the properties.
   proto::SkPictures proto_pictures = proto.pictures();
   std::vector<PictureData> pictures =
       SkPicturesProtoToPictureDataVector(proto_pictures);
   client_picture_cache_->ApplyCacheUpdate(pictures);
 
   LayerProtoConverter::DeserializeLayerProperties(root_layer_.get(),
                                                   proto.layer_updates());
@@ skipping 23 matching lines @@
       static_cast<EventListenerProperties>(
           proto.wheel_event_listener_properties());
   event_listener_properties_[static_cast<size_t>(
       EventListenerClass::kTouchStartOrMove)] =
       static_cast<EventListenerProperties>(
           proto.touch_start_or_move_event_listener_properties());
   event_listener_properties_[static_cast<size_t>(
       EventListenerClass::kTouchEndOrCancel)] =
       static_cast<EventListenerProperties>(
           proto.touch_end_or_cancel_event_listener_properties());
-  in_paint_layer_contents_ = proto.in_paint_layer_contents();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 
   hud_layer_ = static_cast<HeadsUpDisplayLayer*>(
-      UpdateAndGetLayer(hud_layer_.get(), proto.hud_layer_id(), layer_id_map_));
+      UpdateAndGetLayer(hud_layer_.get(), proto.hud_layer_id(), layer_tree));
   overscroll_elasticity_layer_ =
       UpdateAndGetLayer(overscroll_elasticity_layer_.get(),
-                        proto.overscroll_elasticity_layer_id(), layer_id_map_);
+                        proto.overscroll_elasticity_layer_id(), layer_tree);
   page_scale_layer_ = UpdateAndGetLayer(
-      page_scale_layer_.get(), proto.page_scale_layer_id(), layer_id_map_);
+      page_scale_layer_.get(), proto.page_scale_layer_id(), layer_tree);
   inner_viewport_scroll_layer_ =
       UpdateAndGetLayer(inner_viewport_scroll_layer_.get(),
-                        proto.inner_viewport_scroll_layer_id(), layer_id_map_);
+                        proto.inner_viewport_scroll_layer_id(), layer_tree);
   outer_viewport_scroll_layer_ =
       UpdateAndGetLayer(outer_viewport_scroll_layer_.get(),
-                        proto.outer_viewport_scroll_layer_id(), layer_id_map_);
+                        proto.outer_viewport_scroll_layer_id(), layer_tree);
 
   LayerSelectionFromProtobuf(&selection_, proto.selection());
 
   // It is required to create new PropertyTrees before deserializing it.
   property_trees_ = PropertyTrees();
   property_trees_.FromProtobuf(proto.property_trees());
 
   // Forcefully override the sequence number of all layers in the tree to have
   // a valid sequence number. Changing the sequence number for a layer does not
   // need a commit, so the value will become out of date for layers that are not
   // updated for other reasons. All layers that at this point are part of the
   // layer tree are valid, so it is OK that they have a valid sequence number.
   int seq_num = property_trees_.sequence_number;
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, [seq_num](Layer* layer) {
     layer->set_property_tree_sequence_number(seq_num);
   });
 
   surface_client_id_ = proto.surface_client_id();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
+AnimationHost* LayerTreeHost::animation_host() const {
+  return GetLayerTree()->animation_host();
+}
+
 }  // namespace cc