cc: Merge LayerTree into the LayerTreeHost.

content/browser/renderer_host/compositor_impl_android.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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 425 matching lines @@
   animation_host_ = cc::AnimationHost::CreateMainInstance();
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
   params.mutator_host = animation_host_.get();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   DCHECK(!host_->IsVisible());
-  host_->GetLayerTree()->SetRootLayer(root_window_->GetLayer());
+  host_->SetRootLayer(root_window_->GetLayer());
   host_->SetFrameSinkId(frame_sink_id_);
-  host_->GetLayerTree()->SetViewportSize(size_);
+  host_->SetViewportSize(size_);
   SetHasTransparentBackground(false);
-  host_->GetLayerTree()->SetDeviceScaleFactor(1);
+  host_->SetDeviceScaleFactor(1);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
   if (!visible) {
     DCHECK(host_->IsVisible());
 
@@ skipping 13 matching lines @@
       HandlePendingCompositorFrameSinkRequest();
   }
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
   if (host_)
-    host_->GetLayerTree()->SetViewportSize(size);
+    host_->SetViewportSize(size);
   if (display_)
     display_->Resize(size);
   root_window_->GetLayer()->SetBounds(size);
 }
 
 void CompositorImpl::SetHasTransparentBackground(bool transparent) {
   has_transparent_background_ = transparent;
   if (host_) {
-    host_->GetLayerTree()->set_has_transparent_background(transparent);
+    host_->set_has_transparent_background(transparent);
 
     // Give a delay in setting the background color to avoid the color for
     // the normal mode (white) affecting the UI transition.
     base::ThreadTaskRunnerHandle::Get().get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CompositorImpl::SetBackgroundColor,
                    weak_factory_.GetWeakPtr(),
                    transparent ? SK_ColorBLACK : SK_ColorWHITE),
         base::TimeDelta::FromMilliseconds(500));
   }
 }
 
 void CompositorImpl::SetBackgroundColor(int color) {
-  host_->GetLayerTree()->set_background_color(color);
+  host_->set_background_color(color);
 }
 
 void CompositorImpl::SetNeedsComposite() {
   if (!host_->IsVisible())
     return;
   TRACE_EVENT0("compositor", "Compositor::SetNeedsComposite");
   host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::UpdateLayerTreeHost() {
@@ skipping 215 matching lines @@
 
 cc::FrameSinkId CompositorImpl::GetFrameSinkId() {
   return frame_sink_id_;
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content