Refactor MutatorHostClient from LayerTreeHost to LayerTree.

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 230 matching lines @@
       event_listener_properties_(),
       did_complete_scale_animation_(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),
-      layer_tree_(std::move(params->animation_host)) {
+      layer_tree_(base::WrapUnique(
+          new LayerTree(std::move(params->animation_host), this))) {
   DCHECK(task_graph_runner_);
 
-  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_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
@@ skipping 89 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));
 
-  layer_tree_.animation_host()->SetSupportsScrollAnimations(
+  layer_tree_->animation_host()->SetSupportsScrollAnimations(
       proxy_->SupportsImplScrolling());
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
-  layer_tree_.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());
     proxy_->Stop();
@@ skipping 47 matching lines @@
 void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   DCHECK(!IsRemoteServer());
   DCHECK(task_runner_provider_->IsImplThread());
 
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   if (is_new_trace &&
       frame_viewer_instrumentation::IsTracingLayerTreeSnapshots() &&
       root_layer()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
-        this, [](Layer* layer) { layer->DidBeginTracing(); });
+        layer_tree_.get(), [](Layer* layer) { layer->DidBeginTracing(); });
   }
 
   LayerTreeImpl* sync_tree = host_impl->sync_tree();
 
   if (next_commit_forces_redraw_) {
     sync_tree->ForceRedrawNextActivation();
     next_commit_forces_redraw_ = false;
   }
 
   sync_tree->set_source_frame_number(source_frame_number());
@@ skipping 88 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(&layer_tree_, sync_tree);
+    TreeSynchronizer::PushLayerProperties(layer_tree_.get(), 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());
-    layer_tree_.animation_host()->PushPropertiesTo(host_impl->animation_host());
+    layer_tree_->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 =
-      layer_tree_.animation_host()->CreateImplInstance(supports_impl_scrolling);
+      layer_tree_->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 15 matching lines @@
 }
 
 void LayerTreeHost::FinishAllRendering() {
   proxy_->FinishAllRendering();
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {

[Khushal, 2016/08/15 17:46:39]

This method can move to the LayerTree as well.

[xingliu, 2016/08/15 21:29:13]

Done.

-  for (auto* layer : *this)
+  for (auto* layer : *layer_tree_)
     layer->SetNeedsDisplay();
 }
 
 const RendererCapabilities& LayerTreeHost::GetRendererCapabilities() const {
   return proxy_->GetRendererCapabilities();
 }
 
 void LayerTreeHost::SetNeedsAnimate() {
   proxy_->SetNeedsAnimate();
   NotifySwapPromiseMonitorsOfSetNeedsCommit();
@@ skipping 47 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());
-  layer_tree_.animation_host()->SetAnimationEvents(std::move(events));
+  layer_tree_->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 149 matching lines @@
 bool LayerTreeHost::UpdateLayers() {
   DCHECK(!output_surface_lost_);
   if (!root_layer())
     return false;
   DCHECK(!root_layer()->parent());
   bool result = DoUpdateLayers(root_layer());
   micro_benchmark_controller_.DidUpdateLayers();
   return result || next_commit_forces_redraw_;
 }
 
-LayerListIterator<Layer> LayerTreeHost::begin() const {
-  return LayerListIterator<Layer>(root_layer_.get());
-}
-
-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;
 }
 
 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;
 
@@ skipping 25 matching lines @@
       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_);
 }
 
 static void SetElementIdForTesting(Layer* layer) {
   layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 }
 
 void LayerTreeHost::SetElementIdsForTesting() {

[Khushal, 2016/08/15 17:46:39]

Can move this to the LayerTree.

[xingliu, 2016/08/15 21:29:13]

Done.

-  LayerTreeHostCommon::CallFunctionForEveryLayer(this, SetElementIdForTesting);
+  LayerTreeHostCommon::CallFunctionForEveryLayer(layer_tree_.get(),
+                                                 SetElementIdForTesting);
 }
 
 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());
 
@@ skipping 43 matching lines @@
                                              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();
 
   bool content_is_suitable_for_gpu = true;
-  bool did_paint_content =
-      layer_tree_.UpdateLayers(update_layer_list, &content_is_suitable_for_gpu);
+  bool did_paint_content = layer_tree_->UpdateLayers(
+      update_layer_list, &content_is_suitable_for_gpu);
 
   if (content_is_suitable_for_gpu) {
     ++num_consecutive_frames_suitable_for_gpu_;
     if (num_consecutive_frames_suitable_for_gpu_ >=
         kNumFramesToConsiderBeforeGpuRasterization) {
       content_is_suitable_for_gpu_rasterization_ = true;
     }
   } else {
     num_consecutive_frames_suitable_for_gpu_ = 0;
     content_is_suitable_for_gpu_rasterization_ = false;
@@ skipping 36 matching lines @@
     TRACE_EVENT_WITH_FLOW1("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(swap_promise->TraceId()),
                            TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                            "step", "Main thread scroll update");
     QueueSwapPromise(std::move(swap_promise));
   }
 
   if (root_layer_.get()) {
     for (size_t i = 0; i < info->scrolls.size(); ++i) {
-      Layer* layer = LayerById(info->scrolls[i].layer_id);
+      Layer* layer = layer_tree_->LayerById(info->scrolls[i].layer_id);
       if (!layer)
         continue;
       layer->SetScrollOffsetFromImplSide(gfx::ScrollOffsetWithDelta(
           layer->scroll_offset(), info->scrolls[i].scroll_delta));
       SetNeedsUpdateLayers();
     }
   }
 
   // This needs to happen after scroll deltas have been sent to prevent top
   // controls from clamping the layout viewport both on the compositor and
@@ skipping 21 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) {
-  AnimationHost* animation_host = layer_tree_.animation_host();
+  AnimationHost* animation_host = layer_tree_->animation_host();
   std::unique_ptr<AnimationEvents> events = animation_host->CreateEvents();
 
   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) {
@@ skipping 141 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 {
-  return layer_tree_.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());
-}
-
-bool LayerTreeHost::IsElementInList(ElementId element_id,
-                                    ElementListType list_type) const {
-  return list_type == ElementListType::ACTIVE && LayerByElementId(element_id);
-}
-
-void LayerTreeHost::SetMutatorsNeedCommit() {
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetMutatorsNeedRebuildPropertyTrees() {
-  property_trees_.needs_rebuild = true;
-}
-
-void LayerTreeHost::SetElementFilterMutated(ElementId element_id,
-                                            ElementListType list_type,
-                                            const FilterOperations& filters) {
-  Layer* layer = LayerByElementId(element_id);
-  DCHECK(layer);
-  layer->OnFilterAnimated(filters);
-}
-
-void LayerTreeHost::SetElementOpacityMutated(ElementId element_id,
-                                             ElementListType list_type,
-                                             float opacity) {
-  Layer* layer = LayerByElementId(element_id);
-  DCHECK(layer);
-  layer->OnOpacityAnimated(opacity);
-}
-
-void LayerTreeHost::SetElementTransformMutated(
-    ElementId element_id,
-    ElementListType list_type,
-    const gfx::Transform& transform) {
-  Layer* layer = LayerByElementId(element_id);
-  DCHECK(layer);
-  layer->OnTransformAnimated(transform);
-}
-
-void LayerTreeHost::SetElementScrollOffsetMutated(
-    ElementId element_id,
-    ElementListType list_type,
-    const gfx::ScrollOffset& scroll_offset) {
-  Layer* layer = LayerByElementId(element_id);
-  DCHECK(layer);
-  layer->OnScrollOffsetAnimated(scroll_offset);
-}
-
-void LayerTreeHost::ElementTransformIsAnimatingChanged(
-    ElementId element_id,
-    ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
-  Layer* layer = LayerByElementId(element_id);
-  if (layer) {
-    switch (change_type) {
-      case AnimationChangeType::POTENTIAL:
-        layer->OnTransformIsPotentiallyAnimatingChanged(is_animating);
-        break;
-      case AnimationChangeType::RUNNING:
-        layer->OnTransformIsCurrentlyAnimatingChanged(is_animating);
-        break;
-      case AnimationChangeType::BOTH:
-        layer->OnTransformIsPotentiallyAnimatingChanged(is_animating);
-        layer->OnTransformIsCurrentlyAnimatingChanged(is_animating);
-        break;
-    }
-  }
-}
-
-void LayerTreeHost::ElementOpacityIsAnimatingChanged(
-    ElementId element_id,
-    ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
-  Layer* layer = LayerByElementId(element_id);
-  if (layer) {
-    switch (change_type) {
-      case AnimationChangeType::POTENTIAL:
-        layer->OnOpacityIsPotentiallyAnimatingChanged(is_animating);
-        break;
-      case AnimationChangeType::RUNNING:
-        layer->OnOpacityIsCurrentlyAnimatingChanged(is_animating);
-        break;
-      case AnimationChangeType::BOTH:
-        layer->OnOpacityIsPotentiallyAnimatingChanged(is_animating);
-        layer->OnOpacityIsCurrentlyAnimatingChanged(is_animating);
-        break;
-    }
-  }
-}
-
-void LayerTreeHost::ElementFilterIsAnimatingChanged(
-    ElementId element_id,
-    ElementListType list_type,
-    AnimationChangeType change_type,
-    bool is_animating) {
-  Layer* layer = LayerByElementId(element_id);
-  if (layer) {
-    switch (change_type) {
-      case AnimationChangeType::POTENTIAL:
-        layer->OnFilterIsPotentiallyAnimatingChanged(is_animating);
-        break;
-      case AnimationChangeType::RUNNING:
-        layer->OnFilterIsCurrentlyAnimatingChanged(is_animating);
-        break;
-      case AnimationChangeType::BOTH:
-        layer->OnFilterIsPotentiallyAnimatingChanged(is_animating);
-        layer->OnFilterIsCurrentlyAnimatingChanged(is_animating);
-        break;
-    }
-  }
-}
-
-gfx::ScrollOffset LayerTreeHost::GetScrollOffsetForAnimation(
-    ElementId element_id) const {
-  Layer* layer = LayerByElementId(element_id);
-  DCHECK(layer);
-  return layer->ScrollOffsetForAnimation();
-}
-
 bool LayerTreeHost::IsSingleThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::SINGLE_THREADED ||
          !task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::SINGLE_THREADED;
 }
 
 bool LayerTreeHost::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::THREADED ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::THREADED;
@@ skipping 41 matching lines @@
   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());
 
   // Serialize the LayerTree before serializing the properties. During layer
   // property serialization, we clear the list |layer_that_should_properties_|
   // from the LayerTree.
-  layer_tree_.ToProtobuf(proto->mutable_layer_tree());
+  layer_tree_->ToProtobuf(proto->mutable_layer_tree());
 
   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);
@@ skipping 57 matching lines @@
   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;
   }
 
-  layer_tree_.FromProtobuf(proto.layer_tree());
+  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 26 matching lines @@
       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());
   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_tree_));
-  overscroll_elasticity_layer_ =
-      UpdateAndGetLayer(overscroll_elasticity_layer_.get(),
-                        proto.overscroll_elasticity_layer_id(), &layer_tree_);
+  hud_layer_ = static_cast<HeadsUpDisplayLayer*>(UpdateAndGetLayer(
+      hud_layer_.get(), proto.hud_layer_id(), layer_tree_.get()));
+  overscroll_elasticity_layer_ = UpdateAndGetLayer(
+      overscroll_elasticity_layer_.get(),
+      proto.overscroll_elasticity_layer_id(), layer_tree_.get());
   page_scale_layer_ = UpdateAndGetLayer(
-      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_tree_);
-  outer_viewport_scroll_layer_ =
-      UpdateAndGetLayer(outer_viewport_scroll_layer_.get(),
-                        proto.outer_viewport_scroll_layer_id(), &layer_tree_);
+      page_scale_layer_.get(), proto.page_scale_layer_id(), layer_tree_.get());
+  inner_viewport_scroll_layer_ = UpdateAndGetLayer(
+      inner_viewport_scroll_layer_.get(),
+      proto.inner_viewport_scroll_layer_id(), layer_tree_.get());
+  outer_viewport_scroll_layer_ = UpdateAndGetLayer(
+      outer_viewport_scroll_layer_.get(),
+      proto.outer_viewport_scroll_layer_id(), layer_tree_.get());
 
   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);
-  });
+  LayerTreeHostCommon::CallFunctionForEveryLayer(
+      layer_tree_.get(), [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 layer_tree_.animation_host();
-}
-
 }  // namespace cc