cc: Merge LayerTree into the LayerTreeHost.

ui/compositor/compositor.cc

 // Copyright (c) 2012 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 "ui/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 190 matching lines @@
   params.main_task_runner = task_runner_;
   params.mutator_host = animation_host_.get();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
                       base::TimeTicks::Now() - before_create);
 
   animation_timeline_ =
       cc::AnimationTimeline::Create(cc::AnimationIdProvider::NextTimelineId());
   animation_host_->AddAnimationTimeline(animation_timeline_.get());
 
-  host_->GetLayerTree()->SetRootLayer(root_web_layer_);
+  host_->SetRootLayer(root_web_layer_);
   host_->SetFrameSinkId(frame_sink_id_);
   host_->SetVisible(true);
 
   if (command_line->HasSwitch(switches::kUISlowAnimations)) {
     slow_animations_ = base::MakeUnique<ScopedAnimationDurationScaleMode>(
         ScopedAnimationDurationScaleMode::SLOW_DURATION);
   }
 }
 
 Compositor::~Compositor() {
@@ skipping 74 matching lines @@
   if (root_layer_)
     root_layer_->SetCompositor(this, root_web_layer_);
 }
 
 cc::AnimationTimeline* Compositor::GetAnimationTimeline() const {
   return animation_timeline_.get();
 }
 
 void Compositor::SetHostHasTransparentBackground(
     bool host_has_transparent_background) {
-  host_->GetLayerTree()->set_has_transparent_background(
-      host_has_transparent_background);
+  host_->set_has_transparent_background(host_has_transparent_background);
 }
 
 void Compositor::ScheduleFullRedraw() {
   // TODO(enne): Some callers (mac) call this function expecting that it
   // will also commit.  This should probably just redraw the screen
   // from damage and not commit.  ScheduleDraw/ScheduleRedraw need
   // better names.
-  host_->SetNeedsRedrawRect(
-      gfx::Rect(host_->GetLayerTree()->device_viewport_size()));
+  host_->SetNeedsRedrawRect(gfx::Rect(host_->device_viewport_size()));
   host_->SetNeedsCommit();
 }
 
 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
   // TODO(enne): Make this not commit.  See ScheduleFullRedraw.
   host_->SetNeedsRedrawRect(damage_rect);
   host_->SetNeedsCommit();
 }
 
 void Compositor::DisableSwapUntilResize() {
   context_factory_private_->ResizeDisplay(this, gfx::Size());
 }
 
 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
   std::unique_ptr<cc::SwapPromise> swap_promise(
       new cc::LatencyInfoSwapPromise(latency_info));
   host_->QueueSwapPromise(std::move(swap_promise));
 }
 
 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
   DCHECK_GT(scale, 0);
   if (!size_in_pixel.IsEmpty()) {
     size_ = size_in_pixel;
-    host_->GetLayerTree()->SetViewportSize(size_in_pixel);
+    host_->SetViewportSize(size_in_pixel);
     root_web_layer_->SetBounds(size_in_pixel);
     // TODO(fsamuel): Get rid of ContextFactoryPrivate.
     if (context_factory_private_)
       context_factory_private_->ResizeDisplay(this, size_in_pixel);
   }
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
-    host_->GetLayerTree()->SetDeviceScaleFactor(scale);
+    host_->SetDeviceScaleFactor(scale);
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 void Compositor::SetDisplayColorSpace(const gfx::ColorSpace& color_space) {
-  host_->GetLayerTree()->SetDeviceColorSpace(color_space);
+  host_->SetDeviceColorSpace(color_space);
   color_space_ = color_space;
   // Color space is reset when the output surface is lost, so this must also be
   // updated then.
   // TODO(fsamuel): Get rid of this.
   if (context_factory_private_)
     context_factory_private_->SetDisplayColorSpace(this, color_space_);
 }
 
 void Compositor::SetBackgroundColor(SkColor color) {
-  host_->GetLayerTree()->set_background_color(color);
+  host_->set_background_color(color);
   ScheduleDraw();
 }
 
 void Compositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
   // Visibility is reset when the output surface is lost, so this must also be
   // updated then.
   // TODO(fsamuel): Eliminate this call.
   if (context_factory_private_)
     context_factory_private_->SetDisplayVisible(this, visible);
@@ skipping 183 matching lines @@
   for (auto& observer : observer_list_)
     observer.OnCompositingLockStateChanged(this);
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui