cc: 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_));
 
-  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(

[loyso (OOO), 2016/08/16 02:55:41]

Notice that AnimationHost is owned by LayerTree, but
AnimationHost::PushProperties is not a part of
LayerTree::PushPropertiesTo(LayerTreeImpl*).

[Khushal, 2016/08/16 04:28:53]

It can be done there too, we can just pass the impl AnimationHost. Though there
is already so much we do differently for the commit that doing it here looks
fine too. Or have the animation host owned here but the MutatorHostClient can
still be implemented by the tree. You were planning on having it be a weak
reference and moving the ownership out to the
RenderWidgetCompositor/ui::Compositor anyway right?

[Khushal, 2016/08/16 21:47:36]

I'll land this now because this change is mostly moving a lot of call sites and
I don't want more to creep in. Feel free to comment here, I can take those up in
a subsequent change. Thanks.

+        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 34 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