cc: Reland Move data to LayerTree from LayerTreeHost.

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 50 matching lines @@
 #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,
-                         LayerTree* layer_tree) {
-  if (layer_id == Layer::INVALID_ID) {
-    if (current_layer)
-      current_layer->SetLayerTreeHost(nullptr);
-
-    return nullptr;
-  }
-  Layer* layer = layer_tree->LayerById(layer_id);
-  DCHECK(layer);
-  if (current_layer && current_layer != layer)
-    current_layer->SetLayerTreeHost(nullptr);
-
-  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;
 
   const proto::LayerUpdate& layer_update_proto = proto->layer_updates();
@@ skipping 13 matching lines @@
 
       for (int j = 0; j < display_list_proto.items_size(); ++j) {
         const proto::DisplayItem& display_item = display_list_proto.items(j);
         if (display_item.type() == proto::DisplayItem::Type_Drawing)
           drawing_display_items_size += display_item.ByteSize();
       }
     }
   }
 
   value->SetInteger("TotalLayerTreeHostProtoSize", proto->ByteSize());
-  value->SetInteger("LayerTreeHierarchySize", proto->root_layer().ByteSize());
+  value->SetInteger("LayerTreeHierarchySize",
+                    proto->layer_tree().root_layer().ByteSize());
   value->SetInteger("LayerUpdatesSize", proto->layer_updates().ByteSize());
-  value->SetInteger("PropertyTreesSize", proto->property_trees().ByteSize());
+  value->SetInteger("PropertyTreesSize",
+                    proto->layer_tree().property_trees().ByteSize());
 
   // LayerUpdate size breakdown.
   value->SetInteger("TotalBasePropertiesSize",
                     base_layer_properties_size.ValueOrDefault(-1));
   value->SetInteger("PictureLayerPropertiesSize",
                     picture_layer_properties_size.ValueOrDefault(-1));
   value->SetInteger("DisplayItemListSize",
                     display_item_list_size.ValueOrDefault(-1));
   value->SetInteger("DrawingDisplayItemsSize",
                     drawing_display_items_size.ValueOrDefault(-1));
@@ skipping 71 matching lines @@
   DCHECK(params->image_serialization_processor);
 
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::REMOTE));
   layer_tree_host->InitializeRemoteClient(
       remote_proto_channel, params->main_task_runner, impl_task_runner);
   return layer_tree_host;
 }
 
 LayerTreeHost::LayerTreeHost(InitParams* params, CompositorMode mode)
+    : LayerTreeHost(
+          params,
+          mode,
+          base::MakeUnique<LayerTree>(std::move(params->animation_host),
+                                      this)) {}
+
+LayerTreeHost::LayerTreeHost(InitParams* params,
+                             CompositorMode mode,
+                             std::unique_ptr<LayerTree> layer_tree)
     : micro_benchmark_controller_(this),
+      layer_tree_(std::move(layer_tree)),
       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),
       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),
-      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_(),
       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)) {
+      next_surface_sequence_(1u) {
   DCHECK(task_graph_runner_);
+  DCHECK(layer_tree_);
 
-  layer_tree_.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));
 
-  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);
+  // Clear any references into the LayerTreeHost.
+  layer_tree_.reset();
 
   DCHECK(swap_promise_monitor_.empty());
 
   BreakSwapPromises(SwapPromise::COMMIT_FAILS);
 
   if (proxy_) {
     DCHECK(task_runner_provider_->IsMainThread());
     proxy_->Stop();
 
     // Proxy must be destroyed before the Task Runner Provider.
     proxy_ = nullptr;
   }
-
-  // We must clear any pointers into the layer tree prior to destroying it.
-  RegisterViewportLayers(NULL, NULL, NULL, NULL);
-
-  if (root_layer_.get()) {
-    // The layer tree must be destroyed before the layer tree host. We've
-    // made a contract with our animation controllers that the animation_host
-    // will outlive them, and we must make good.
-    root_layer_ = NULL;
-  }
 }
 
 void LayerTreeHost::WillBeginMainFrame() {
   devtools_instrumentation::WillBeginMainThreadFrame(id(),
                                                      source_frame_number());
   client_->WillBeginMainFrame();
 }
 
 void LayerTreeHost::DidBeginMainFrame() {
   client_->DidBeginMainFrame();
@@ skipping 21 matching lines @@
 // should be delayed until the LayerTreeHost::CommitComplete, which will run
 // after the commit, but on the main thread.
 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()) {
+      layer_tree_->root_layer()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         this, [](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());
 
-  if (needs_full_tree_sync_)
-    TreeSynchronizer::SynchronizeTrees(root_layer(), sync_tree);
+  if (layer_tree_->needs_full_tree_sync())
+    TreeSynchronizer::SynchronizeTrees(layer_tree_->root_layer(), sync_tree);
 
-  sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
-  needs_full_tree_sync_ = false;
-
-  if (hud_layer_.get()) {
-    LayerImpl* hud_impl = sync_tree->LayerById(hud_layer_->id());
-    sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
-  } else {
-    sync_tree->set_hud_layer(NULL);
-  }
-
-  sync_tree->set_background_color(background_color_);
-  sync_tree->set_has_transparent_background(has_transparent_background_);
-  sync_tree->set_have_scroll_event_handlers(have_scroll_event_handlers_);
-  sync_tree->set_event_listener_properties(
-      EventListenerClass::kTouchStartOrMove,
-      event_listener_properties(EventListenerClass::kTouchStartOrMove));
-  sync_tree->set_event_listener_properties(
-      EventListenerClass::kMouseWheel,
-      event_listener_properties(EventListenerClass::kMouseWheel));
-  sync_tree->set_event_listener_properties(
-      EventListenerClass::kTouchEndOrCancel,
-      event_listener_properties(EventListenerClass::kTouchEndOrCancel));
-
-  if (page_scale_layer_.get() && inner_viewport_scroll_layer_.get()) {
-    sync_tree->SetViewportLayersFromIds(
-        overscroll_elasticity_layer_.get() ? overscroll_elasticity_layer_->id()
-                                           : Layer::INVALID_ID,
-        page_scale_layer_->id(), inner_viewport_scroll_layer_->id(),
-        outer_viewport_scroll_layer_.get() ? outer_viewport_scroll_layer_->id()
-                                           : Layer::INVALID_ID);
-    DCHECK(inner_viewport_scroll_layer_->IsContainerForFixedPositionLayers());
-  } else {
-    sync_tree->ClearViewportLayers();
-  }
-
-  sync_tree->RegisterSelection(selection_);
-
-  bool property_trees_changed_on_active_tree =
-      sync_tree->IsActiveTree() && sync_tree->property_trees()->changed;
-  // Property trees may store damage status. We preserve the sync tree damage
-  // status by pushing the damage status from sync tree property trees to main
-  // thread property trees or by moving it onto the layers.
-  if (root_layer_ && property_trees_changed_on_active_tree) {
-    if (property_trees_.sequence_number ==
-        sync_tree->property_trees()->sequence_number)
-      sync_tree->property_trees()->PushChangeTrackingTo(&property_trees_);
-    else
-      sync_tree->MoveChangeTrackingToLayers();
-  }
-  // Setting property trees must happen before pushing the page scale.
-  sync_tree->SetPropertyTrees(&property_trees_);
-
-  sync_tree->PushPageScaleFromMainThread(
-      page_scale_factor_, min_page_scale_factor_, max_page_scale_factor_);
-  sync_tree->elastic_overscroll()->PushFromMainThread(elastic_overscroll_);
-  if (sync_tree->IsActiveTree())
-    sync_tree->elastic_overscroll()->PushPendingToActive();
+  layer_tree_->PushPropertiesTo(sync_tree);
 
   sync_tree->PassSwapPromises(std::move(swap_promise_list_));
   swap_promise_list_.clear();
 
-  sync_tree->set_top_controls_shrink_blink_size(
-      top_controls_shrink_blink_size_);
-  sync_tree->set_top_controls_height(top_controls_height_);
-  sync_tree->PushTopControlsFromMainThread(top_controls_shown_ratio_);
-
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   RecordGpuRasterizationHistogram();
 
-  host_impl->SetViewportSize(device_viewport_size_);
-  // TODO(senorblanco): Move this up so that it happens before GPU rasterization
-  // properties are set, since those trigger an update of GPU rasterization
-  // status, which depends on the device scale factor. (crbug.com/535700)
-  sync_tree->SetDeviceScaleFactor(device_scale_factor_);
-  sync_tree->set_painted_device_scale_factor(painted_device_scale_factor_);
+  host_impl->SetViewportSize(layer_tree_->device_viewport_size());
+  // TODO(senorblanco): Move this to LayerTree::PushPropertiesTo so that it
+  // happens before GPU rasterization properties are set, since those trigger an
+  // update of GPU rasterization status, which depends on the device scale
+  // factor. (crbug.com/535700)
+  sync_tree->SetDeviceScaleFactor(layer_tree_->device_scale_factor());
   host_impl->SetDebugState(debug_state_);
-  if (pending_page_scale_animation_) {
-    sync_tree->SetPendingPageScaleAnimation(
-        std::move(pending_page_scale_animation_));
-  }
 
   if (!ui_resource_request_queue_.empty()) {
     sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
     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_);
+  sync_tree->UpdatePropertyTreeScrollOffset(layer_tree_->property_trees());
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
-  property_trees_.ResetAllChangeTracking();
+  layer_tree_->property_trees()->ResetAllChangeTracking();
 }
 
 void LayerTreeHost::WillCommit() {
   OnCommitForSwapPromises();
   client_->WillCommit();
 }
 
 void LayerTreeHost::UpdateHudLayer() {
-  if (debug_state_.ShowHudInfo()) {
-    if (!hud_layer_.get()) {
-      hud_layer_ = HeadsUpDisplayLayer::Create();
-    }
-
-    if (root_layer_.get() && !hud_layer_->parent())
-      root_layer_->AddChild(hud_layer_);
-  } else if (hud_layer_.get()) {
-    hud_layer_->RemoveFromParent();
-    hud_layer_ = NULL;
-  }
 }
 
 void LayerTreeHost::CommitComplete() {
   source_frame_number_++;
   client_->DidCommit();
   if (did_complete_scale_animation_) {
     client_->DidCompletePageScaleAnimation();
     did_complete_scale_animation_ = false;
   }
 }
@@ skipping 39 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 30 matching lines @@
 void LayerTreeHost::SetNeedsAnimate() {
   proxy_->SetNeedsAnimate();
   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
 void LayerTreeHost::SetNeedsUpdateLayers() {
   proxy_->SetNeedsUpdateLayers();
   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
-void LayerTreeHost::SetPropertyTreesNeedRebuild() {
-  property_trees_.needs_rebuild = true;
-  SetNeedsUpdateLayers();
-}
-
 void LayerTreeHost::SetNeedsCommit() {
   proxy_->SetNeedsCommit();
   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
-void LayerTreeHost::SetNeedsFullTreeSync() {
-  needs_full_tree_sync_ = true;
-  needs_meta_info_recomputation_ = true;
-
-  property_trees_.needs_rebuild = true;
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetNeedsMetaInfoRecomputation(bool needs_recomputation) {
-  needs_meta_info_recomputation_ = needs_recomputation;
-}
-
 void LayerTreeHost::SetNeedsRedraw() {
-  SetNeedsRedrawRect(gfx::Rect(device_viewport_size_));
+  SetNeedsRedrawRect(gfx::Rect(layer_tree_->device_viewport_size()));
 }
 
 void LayerTreeHost::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   proxy_->SetNeedsRedraw(damage_rect);
 }
 
 bool LayerTreeHost::CommitRequested() const {
   return proxy_->CommitRequested();
 }
 
 bool LayerTreeHost::BeginMainFrameRequested() const {
   return proxy_->BeginMainFrameRequested();
 }
 
 void LayerTreeHost::SetNextCommitWaitsForActivation() {
   proxy_->SetNextCommitWaitsForActivation();
 }
 
 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));
-}
-
-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()) {
-    DCHECK(!root_layer_->parent());
-    root_layer_->SetLayerTreeHost(this);
-  }
-
-  if (hud_layer_.get())
-    hud_layer_->RemoveFromParent();
-
-  // Reset gpu rasterization flag.
-  // This flag is sticky until a new tree comes along.
-  content_is_suitable_for_gpu_rasterization_ = true;
-  gpu_rasterization_histogram_recorded_ = false;
-
-  SetNeedsFullTreeSync();
+  layer_tree_->animation_host()->SetAnimationEvents(std::move(events));
 }
 
 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
   LayerTreeDebugState new_debug_state =
       LayerTreeDebugState::Unite(settings_.initial_debug_state, debug_state);
 
   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
     return;
 
   debug_state_ = new_debug_state;
 
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
 
   SetNeedsCommit();
 }
 
+void LayerTreeHost::ResetGpuRasterizationTracking() {
+  content_is_suitable_for_gpu_rasterization_ = true;
+  gpu_rasterization_histogram_recorded_ = false;
+}
+
 void LayerTreeHost::SetHasGpuRasterizationTrigger(bool has_trigger) {
   if (has_trigger == has_gpu_rasterization_trigger_)
     return;
 
   has_gpu_rasterization_trigger_ = has_trigger;
   TRACE_EVENT_INSTANT1("cc",
                        "LayerTreeHost::SetHasGpuRasterizationTrigger",
                        TRACE_EVENT_SCOPE_THREAD,
                        "has_trigger",
                        has_gpu_rasterization_trigger_);
 }
 
-void LayerTreeHost::SetViewportSize(const gfx::Size& device_viewport_size) {
-  if (device_viewport_size == device_viewport_size_)
-    return;
-
-  device_viewport_size_ = device_viewport_size;
-
-  SetPropertyTreesNeedRebuild();
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetTopControlsHeight(float height, bool shrink) {
-  if (top_controls_height_ == height &&
-      top_controls_shrink_blink_size_ == shrink)
-    return;
-
-  top_controls_height_ = height;
-  top_controls_shrink_blink_size_ = shrink;
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetTopControlsShownRatio(float ratio) {
-  if (top_controls_shown_ratio_ == ratio)
-    return;
-
-  top_controls_shown_ratio_ = ratio;
-  SetNeedsCommit();
-}
-
 void LayerTreeHost::ApplyPageScaleDeltaFromImplSide(float page_scale_delta) {
   DCHECK(CommitRequested());
   if (page_scale_delta == 1.f)
     return;
-  page_scale_factor_ *= page_scale_delta;
-  SetPropertyTreesNeedRebuild();
-}
-
-void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
-                                                float min_page_scale_factor,
-                                                float max_page_scale_factor) {
-  if (page_scale_factor == page_scale_factor_ &&
-      min_page_scale_factor == min_page_scale_factor_ &&
-      max_page_scale_factor == max_page_scale_factor_)
-    return;
-
-  page_scale_factor_ = page_scale_factor;
-  min_page_scale_factor_ = min_page_scale_factor;
-  max_page_scale_factor_ = max_page_scale_factor;
-  SetPropertyTreesNeedRebuild();
-  SetNeedsCommit();
+  float page_scale = layer_tree_->page_scale_factor() * page_scale_delta;
+  layer_tree_->SetPageScaleFromImplSide(page_scale);
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   proxy_->SetVisible(visible);
 }
 
-void LayerTreeHost::StartPageScaleAnimation(const gfx::Vector2d& target_offset,
-                                            bool use_anchor,
-                                            float scale,
-                                            base::TimeDelta duration) {
-  pending_page_scale_animation_.reset(
-      new PendingPageScaleAnimation(
-          target_offset,
-          use_anchor,
-          scale,
-          duration));
-
-  SetNeedsCommit();
-}
-
-bool LayerTreeHost::HasPendingPageScaleAnimation() const {
-  return !!pending_page_scale_animation_.get();
-}
-
 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
   proxy_->NotifyInputThrottledUntilCommit();
 }
 
 void LayerTreeHost::LayoutAndUpdateLayers() {
   DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
@@ skipping 13 matching lines @@
   DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
   proxy->CompositeImmediately(frame_begin_time);
 }
 
 bool LayerTreeHost::UpdateLayers() {
   DCHECK(!output_surface_lost_);
-  if (!root_layer())
+  if (!layer_tree_->root_layer())
     return false;
-  DCHECK(!root_layer()->parent());
-  bool result = DoUpdateLayers(root_layer());
+  DCHECK(!layer_tree_->root_layer()->parent());
+  bool result = DoUpdateLayers(layer_tree_->root_layer());
   micro_benchmark_controller_.DidUpdateLayers();
   return result || next_commit_forces_redraw_;
 }
 
 LayerListIterator<Layer> LayerTreeHost::begin() const {
-  return LayerListIterator<Layer>(root_layer_.get());
+  return LayerListIterator<Layer>(layer_tree_->root_layer());
 }
 
 LayerListIterator<Layer> LayerTreeHost::end() const {
   return LayerListIterator<Layer>(nullptr);
 }
 
 LayerListReverseIterator<Layer> LayerTreeHost::rbegin() {
-  return LayerListReverseIterator<Layer>(root_layer_.get());
+  return LayerListReverseIterator<Layer>(layer_tree_->root_layer());
 }
 
 LayerListReverseIterator<Layer> LayerTreeHost::rend() {
   return LayerListReverseIterator<Layer>(nullptr);
 }
 
 void LayerTreeHost::DidCompletePageScaleAnimation() {
   did_complete_scale_animation_ = true;
 }
 
@@ skipping 17 matching lines @@
     // 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() {
-  PropertyTreeBuilder::PreCalculateMetaInformation(root_layer_.get());
+  PropertyTreeBuilder::PreCalculateMetaInformation(layer_tree_->root_layer());
   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_);
+      layer_tree_->root_layer(), layer_tree_->page_scale_layer(),
+      layer_tree_->inner_viewport_scroll_layer(),
+      layer_tree_->outer_viewport_scroll_layer(),
+      layer_tree_->overscroll_elasticity_layer(), elastic_overscroll_,
+      layer_tree_->page_scale_factor(), layer_tree_->device_scale_factor(),
+      gfx::Rect(layer_tree_->device_viewport_size()), identity_transform,
+      layer_tree_->property_trees());
 }
 
 static void SetElementIdForTesting(Layer* layer) {
   layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 }
 
 void LayerTreeHost::SetElementIdsForTesting() {
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, 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());
 
+  layer_tree_->UpdateHudLayer(debug_state_.ShowHudInfo());
   UpdateHudLayer();
 
   Layer* root_scroll =
       PropertyTreeBuilder::FindFirstScrollableLayer(root_layer);
-  Layer* page_scale_layer = page_scale_layer_.get();
+  Layer* page_scale_layer = layer_tree_->page_scale_layer();
   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_);
+  if (layer_tree_->hud_layer()) {
+    layer_tree_->hud_layer()->PrepareForCalculateDrawProperties(
+        layer_tree_->device_viewport_size(),
+        layer_tree_->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");
     PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
     bool can_render_to_separate_surface = true;
+    PropertyTrees* property_trees = layer_tree_->property_trees();
     if (!settings_.use_layer_lists) {
       // If use_layer_lists is set, then the property trees should have been
       // built by the client already.
       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_);
+          root_layer, page_scale_layer,
+          layer_tree_->inner_viewport_scroll_layer(),
+          layer_tree_->outer_viewport_scroll_layer(),
+          layer_tree_->overscroll_elasticity_layer(), elastic_overscroll_,
+          layer_tree_->page_scale_factor(), layer_tree_->device_scale_factor(),
+          gfx::Rect(layer_tree_->device_viewport_size()), identity_transform,
+          property_trees);
       TRACE_EVENT_INSTANT1("cc",
                            "LayerTreeHost::UpdateLayers_BuiltPropertyTrees",
                            TRACE_EVENT_SCOPE_THREAD, "property_trees",
-                           property_trees_.AsTracedValue());
+                           property_trees->AsTracedValue());
     } else {
       TRACE_EVENT_INSTANT1("cc",
                            "LayerTreeHost::UpdateLayers_ReceivedPropertyTrees",
                            TRACE_EVENT_SCOPE_THREAD, "property_trees",
-                           property_trees_.AsTracedValue());
+                           property_trees->AsTracedValue());
     }
-    draw_property_utils::UpdatePropertyTrees(&property_trees_,
+    draw_property_utils::UpdatePropertyTrees(property_trees,
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(
-        this, property_trees_.transform_tree, property_trees_.effect_tree,
+        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;
   }
   return did_paint_content;
 }
 
 void LayerTreeHost::ApplyViewportDeltas(ScrollAndScaleSet* info) {
   gfx::Vector2dF inner_viewport_scroll_delta;
   if (info->inner_viewport_scroll.layer_id != Layer::INVALID_ID)
     inner_viewport_scroll_delta = info->inner_viewport_scroll.scroll_delta;
 
   if (inner_viewport_scroll_delta.IsZero() && info->page_scale_delta == 1.f &&
       info->elastic_overscroll_delta.IsZero() && !info->top_controls_delta)
     return;
 
   // Preemptively apply the scroll offset and scale delta here before sending
   // it to the client.  If the client comes back and sets it to the same
   // value, then the layer can early out without needing a full commit.
-  if (inner_viewport_scroll_layer_.get()) {
-    inner_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
+  if (layer_tree_->inner_viewport_scroll_layer()) {
+    layer_tree_->inner_viewport_scroll_layer()->SetScrollOffsetFromImplSide(
         gfx::ScrollOffsetWithDelta(
-            inner_viewport_scroll_layer_->scroll_offset(),
+            layer_tree_->inner_viewport_scroll_layer()->scroll_offset(),
             inner_viewport_scroll_delta));
   }
 
   ApplyPageScaleDeltaFromImplSide(info->page_scale_delta);
   elastic_overscroll_ += info->elastic_overscroll_delta;
   // TODO(ccameron): pass the elastic overscroll here so that input events
   // may be translated appropriately.
   client_->ApplyViewportDeltas(inner_viewport_scroll_delta, gfx::Vector2dF(),
                                info->elastic_overscroll_delta,
                                info->page_scale_delta,
                                info->top_controls_delta);
   SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::ApplyScrollAndScale(ScrollAndScaleSet* info) {
   for (auto& swap_promise : info->swap_promises) {
     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()) {
+  if (layer_tree_->root_layer()) {
     for (size_t i = 0; i < info->scrolls.size(); ++i) {
       Layer* layer = 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
   // on the main thread.
   ApplyViewportDeltas(info);
 }
 
-void LayerTreeHost::SetDeviceScaleFactor(float device_scale_factor) {
-  if (device_scale_factor == device_scale_factor_)
-    return;
-  device_scale_factor_ = device_scale_factor;
-
-  property_trees_.needs_rebuild = true;
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetPaintedDeviceScaleFactor(
-    float painted_device_scale_factor) {
-  if (painted_device_scale_factor == painted_device_scale_factor_)
-    return;
-  painted_device_scale_factor_ = painted_device_scale_factor;
-
-  SetNeedsCommit();
-}
-
 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;
+    layer_tree_->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) ==
          ui_resource_client_map_.end());
 
   bool resource_lost = false;
@@ skipping 36 matching lines @@
 // Returns the size of a resource given its id.
 gfx::Size LayerTreeHost::GetUIResourceSize(UIResourceId uid) const {
   UIResourceClientMap::const_iterator iter = ui_resource_client_map_.find(uid);
   if (iter == ui_resource_client_map_.end())
     return gfx::Size();
 
   const UIResourceClientData& data = iter->second;
   return data.size;
 }
 
-void LayerTreeHost::RegisterViewportLayers(
-    scoped_refptr<Layer> overscroll_elasticity_layer,
-    scoped_refptr<Layer> page_scale_layer,
-    scoped_refptr<Layer> inner_viewport_scroll_layer,
-    scoped_refptr<Layer> outer_viewport_scroll_layer) {
-  DCHECK(!inner_viewport_scroll_layer ||
-         inner_viewport_scroll_layer != outer_viewport_scroll_layer);
-  overscroll_elasticity_layer_ = overscroll_elasticity_layer;
-  page_scale_layer_ = page_scale_layer;
-  inner_viewport_scroll_layer_ = inner_viewport_scroll_layer;
-  outer_viewport_scroll_layer_ = outer_viewport_scroll_layer;
-}
-
-void LayerTreeHost::RegisterSelection(const LayerSelection& selection) {
-  if (selection_ == selection)
-    return;
-
-  selection_ = selection;
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetHaveScrollEventHandlers(bool have_event_handlers) {
-  if (have_scroll_event_handlers_ == have_event_handlers)
-    return;
-
-  have_scroll_event_handlers_ = have_event_handlers;
-  SetNeedsCommit();
-}
-
-void LayerTreeHost::SetEventListenerProperties(
-    EventListenerClass event_class,
-    EventListenerProperties properties) {
-  const size_t index = static_cast<size_t>(event_class);
-  if (event_listener_properties_[index] == properties)
-    return;
-
-  event_listener_properties_[index] = properties;
-  SetNeedsCommit();
-}
-
 int LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     std::unique_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(benchmark_name,
                                                  std::move(value), callback);
 }
 
 bool LayerTreeHost::SendMessageToMicroBenchmark(
     int id,
@@ skipping 45 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);
+  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;
@@ skipping 11 matching lines @@
 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;
+  layer_tree_->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);
 }
 
@@ skipping 140 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");
   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());
-
   // 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);
   debug_state_.ToProtobuf(proto->mutable_debug_state());
-  SizeToProto(device_viewport_size_, proto->mutable_device_viewport_size());
-  proto->set_top_controls_shrink_blink_size(top_controls_shrink_blink_size_);
-  proto->set_top_controls_height(top_controls_height_);
-  proto->set_top_controls_shown_ratio(top_controls_shown_ratio_);
-  proto->set_device_scale_factor(device_scale_factor_);
-  proto->set_painted_device_scale_factor(painted_device_scale_factor_);
-  proto->set_page_scale_factor(page_scale_factor_);
-  proto->set_min_page_scale_factor(min_page_scale_factor_);
-  proto->set_max_page_scale_factor(max_page_scale_factor_);
   Vector2dFToProto(elastic_overscroll_, proto->mutable_elastic_overscroll());
   proto->set_has_gpu_rasterization_trigger(has_gpu_rasterization_trigger_);
   proto->set_content_is_suitable_for_gpu_rasterization(
       content_is_suitable_for_gpu_rasterization_);
-  proto->set_background_color(background_color_);
-  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_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(
-      inner_viewport_scroll_layer_ ? inner_viewport_scroll_layer_->id()
-                                   : Layer::INVALID_ID);
-  proto->set_outer_viewport_scroll_layer_id(
-      outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
-                                   : Layer::INVALID_ID);
-
-  LayerSelectionToProtobuf(selection_, proto->mutable_selection());
-
-  property_trees_.ToProtobuf(proto->mutable_property_trees());
-
   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_);
-  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;
-  }
-
-  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(),
+  LayerProtoConverter::DeserializeLayerProperties(layer_tree_->root_layer(),
                                                   proto.layer_updates());
 
   // The deserialization is finished, so now clear the cache.
   client_picture_cache_->Flush();
 
   debug_state_.FromProtobuf(proto.debug_state());
-  device_viewport_size_ = ProtoToSize(proto.device_viewport_size());
-  top_controls_shrink_blink_size_ = proto.top_controls_shrink_blink_size();
-  top_controls_height_ = proto.top_controls_height();
-  top_controls_shown_ratio_ = proto.top_controls_shown_ratio();
-  device_scale_factor_ = proto.device_scale_factor();
-  painted_device_scale_factor_ = proto.painted_device_scale_factor();
-  page_scale_factor_ = proto.page_scale_factor();
-  min_page_scale_factor_ = proto.min_page_scale_factor();
-  max_page_scale_factor_ = proto.max_page_scale_factor();
   elastic_overscroll_ = ProtoToVector2dF(proto.elastic_overscroll());
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
-  background_color_ = proto.background_color();
-  has_transparent_background_ = proto.has_transparent_background();
-  have_scroll_event_handlers_ = proto.have_scroll_event_handlers();
-  event_listener_properties_[static_cast<size_t>(
-      EventListenerClass::kMouseWheel)] =
-      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());
   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_);
-  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_);
-
-  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 layer_tree_.animation_host();
+  return layer_tree_->animation_host();
 }
 
 }  // namespace cc