Revert of cc: Move data to LayerTree from LayerTreeHost.

cc/trees/layer_tree_host_unittest.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 249 matching lines @@
 class LayerTreeHostTestReadyToActivateNonEmpty
     : public LayerTreeHostTestReadyToActivateEmpty {
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
     EXPECT_LE(size_t(1), required_for_activation_count_);
   }
 
@@ skipping 50 matching lines @@
 class LayerTreeHostTestReadyToDrawNonEmpty
     : public LayerTreeHostTestReadyToDrawEmpty {
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
     EXPECT_TRUE(all_tiles_required_for_draw_are_ready_to_draw_);
     EXPECT_LE(size_t(1), required_for_draw_count_);
   }
 
@@ skipping 18 matching lines @@
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     client_.set_bounds(root_layer->bounds());
     root_layer->SetIsDrawable(true);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (!toggled_visibility_) {
       {
         DebugScopedSetMainThread main(task_runner_provider());
         layer_tree_host()->SetVisible(false);
       }
       toggled_visibility_ = true;
@@ skipping 244 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
 
 // Verify that we pass property values in PushPropertiesTo.
 class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   enum Properties {
     STARTUP,
     BOUNDS,
     HIDE_LAYER_AND_SUBTREE,
     DRAWS_CONTENT,
     DONE,
   };
 
   void BeginTest() override {
     index_ = STARTUP;
     PostSetNeedsCommitToMainThread();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     VerifyAfterValues(impl->active_tree()->root_layer_for_testing());
   }
 
   void DidCommitAndDrawFrame() override {
-    SetBeforeValues(layer_tree()->root_layer());
-    VerifyBeforeValues(layer_tree()->root_layer());
+    SetBeforeValues(layer_tree_host()->root_layer());
+    VerifyBeforeValues(layer_tree_host()->root_layer());
 
     ++index_;
     if (index_ == DONE) {
       EndTest();
       return;
     }
 
-    SetAfterValues(layer_tree()->root_layer());
+    SetAfterValues(layer_tree_host()->root_layer());
   }
 
   void AfterTest() override {}
 
   void VerifyBeforeValues(Layer* layer) {
     EXPECT_EQ(gfx::Size(10, 10).ToString(), layer->bounds().ToString());
     EXPECT_FALSE(layer->hide_layer_and_subtree());
     EXPECT_FALSE(layer->DrawsContent());
   }
 
@@ skipping 43 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesTo);
 
 class LayerTreeHostTestPushNodeOwnerToNodeIdMap : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     child_ = Layer::Create();
     root_->AddChild(child_);
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // child_ should create transform, effect, clip node.
         child_->SetForceRenderSurfaceForTesting(true);
@@ skipping 99 matching lines @@
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushNodeOwnerToNodeIdMap);
 
 class LayerTreeHostTestDamageWithReplica : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     index_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1:
         scoped_refptr<Layer> replica_layer = Layer::Create();
-        layer_tree()->root_layer()->SetReplicaLayer(replica_layer.get());
+        layer_tree_host()->root_layer()->SetReplicaLayer(replica_layer.get());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     switch (index_) {
       case 0:
         impl->sync_tree()->ResetAllChangeTracking();
         EXPECT_FALSE(impl->sync_tree()
                          ->root_layer_for_testing()
@@ skipping 19 matching lines @@
 
 // Verify damage status of property trees is preserved after commit.
 class LayerTreeHostTestPropertyTreesChangedSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     child_ = Layer::Create();
     // This is to force the child to create a transform and effect node.
     child_->SetForceRenderSurfaceForTesting(true);
     root_->AddChild(child_);
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   enum Animations {
     OPACITY,
     TRANSFORM,
     FILTER,
     END,
   };
 
   void BeginTest() override {
     index_ = OPACITY;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 2:
         // We rebuild property trees for this case to test the code path of
         // damage status synchronization when property trees are different.
-        layer_tree()->property_trees()->needs_rebuild = true;
+        layer_tree_host()->property_trees()->needs_rebuild = true;
         break;
       default:
-        EXPECT_FALSE(layer_tree()->property_trees()->needs_rebuild);
+        EXPECT_FALSE(layer_tree_host()->property_trees()->needs_rebuild);
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     gfx::Transform transform;
     FilterOperations filters;
     switch (static_cast<Animations>(index_)) {
       case OPACITY:
         index_++;
         impl->active_tree()->ResetAllChangeTracking();
@@ skipping 53 matching lines @@
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
 };
 
 SINGLE_THREAD_TEST_F(LayerTreeHostTestPropertyTreesChangedSync);
 
 class LayerTreeHostTestEffectTreeSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     blur_filter_.Append(FilterOperation::CreateBlurFilter(0.5f));
     brightness_filter_.Append(FilterOperation::CreateBrightnessFilter(0.25f));
     sepia_filter_.Append(FilterOperation::CreateSepiaFilter(0.75f));
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    EffectTree& effect_tree = layer_tree()->property_trees()->effect_tree;
+    EffectTree& effect_tree = layer_tree_host()->property_trees()->effect_tree;
     EffectNode* node = effect_tree.Node(root_->effect_tree_index());
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         node->opacity = 0.5f;
         node->is_currently_animating_opacity = true;
         break;
       case 2:
         node->is_currently_animating_opacity = true;
         break;
       case 3:
@@ skipping 77 matching lines @@
   FilterOperations brightness_filter_;
   FilterOperations sepia_filter_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestEffectTreeSync);
 
 class LayerTreeHostTestTransformTreeSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     TransformTree& transform_tree =
-        layer_tree()->property_trees()->transform_tree;
+        layer_tree_host()->property_trees()->transform_tree;
     TransformNode* node = transform_tree.Node(root_->transform_tree_index());
     gfx::Transform rotate10;
     rotate10.Rotate(10.f);
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         node->local = rotate10;
         node->is_currently_animating = true;
         break;
       case 2:
         node->is_currently_animating = true;
@@ skipping 63 matching lines @@
     root_->SetBounds(gfx::Size(50, 50));
 
     // Make sure child and grand_child have transform nodes.
     gfx::Transform rotation;
     rotation.RotateAboutZAxis(45.0);
     child_->SetTransform(rotation);
     grand_child_->SetTransform(rotation);
 
     root_->AddChild(child_);
     child_->AddChild(grand_child_);
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       gfx::Transform scale;
       scale.Scale(2.0, 2.0);
       LayerInternalsForTest(child_.get()).OnTransformAnimated(scale);
@@ skipping 46 matching lines @@
 class LayerTreeHostTestSwitchMaskLayer : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     scoped_refptr<Layer> child = Layer::Create();
     mask_layer = Layer::Create();
     mask_layer->SetBounds(gfx::Size(10, 10));
     child->SetMaskLayer(mask_layer.get());
     root->AddChild(std::move(child));
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     index_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Root and mask layer should have the same source frame number as they
         // will be in the layer update list but the child is not as it has empty
         // bounds.
-        EXPECT_EQ(
-            mask_layer->paint_properties().source_frame_number,
-            layer_tree()->root_layer()->paint_properties().source_frame_number);
+        EXPECT_EQ(mask_layer->paint_properties().source_frame_number,
+                  layer_tree_host()
+                      ->root_layer()
+                      ->paint_properties()
+                      .source_frame_number);
         EXPECT_NE(mask_layer->paint_properties().source_frame_number,
-                  layer_tree()
+                  layer_tree_host()
                       ->root_layer()
                       ->child_at(0)
                       ->paint_properties()
                       .source_frame_number);
-        layer_tree()->root_layer()->RemoveAllChildren();
-        layer_tree()->root_layer()->SetMaskLayer(mask_layer.get());
+        layer_tree_host()->root_layer()->RemoveAllChildren();
+        layer_tree_host()->root_layer()->SetMaskLayer(mask_layer.get());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     switch (index_) {
       case 0:
         index_++;
         EXPECT_FALSE(impl->sync_tree()
                          ->root_layer_for_testing()
@@ skipping 58 matching lines @@
 // must contain invalid_rect.
 class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedrawRect()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
-    layer_tree()->SetRootLayer(root_layer_);
-    layer_tree()->SetViewportSize(bounds_);
+    layer_tree_host()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::Rect root_damage_rect;
@@ skipping 42 matching lines @@
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     gfx::Transform transform;
     // Translate the layer out of the viewport to force it to not update its
     // tile size via PushProperties.
     transform.Translate(10000.0, 10000.0);
     root_layer_->SetTransform(transform);
     root_layer_->SetBounds(bounds_);
-    layer_tree()->SetRootLayer(root_layer_);
-    layer_tree()->SetViewportSize(bounds_);
+    layer_tree_host()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetViewportSize(bounds_);
 
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
@@ skipping 23 matching lines @@
       EXPECT_EQ(
           pending_tiling->TilingDataForTesting().max_texture_size().width(),
           active_tiling->TilingDataForTesting().max_texture_size().width());
       EndTest();
     }
   }
 
   void DidCommitAndDrawFrame() override {
     // On the second commit, resize the viewport.
     if (num_draws_ == 1) {
-      layer_tree()->SetViewportSize(gfx::Size(400, 64));
+      layer_tree_host()->SetViewportSize(gfx::Size(400, 64));
     }
   }
 
   void AfterTest() override {}
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
@@ skipping 12 matching lines @@
   }
 
   void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
     scaled_layer_ = FakePictureLayer::Create(&client_);
     scaled_layer_->SetBounds(gfx::Size(1, 1));
     root_layer_->AddChild(scaled_layer_);
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
@@ skipping 35 matching lines @@
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_ = FakePaintedScrollbarLayer::Create(paint_scrollbar, has_thumb,
                                                    root_layer_->id());
     scrollbar_->SetPosition(gfx::PointF(0.f, 10.f));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     root_layer_->AddChild(scrollbar_);
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Changing the device scale factor causes a commit. It also changes
         // the content bounds of |scrollbar_|, which should not generate
         // a second commit as a result.
-        layer_tree()->SetDeviceScaleFactor(4.f);
+        layer_tree_host()->SetDeviceScaleFactor(4.f);
         break;
       default:
         // No extra commits.
         EXPECT_EQ(2, layer_tree_host()->source_frame_number());
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 13 matching lines @@
   }
 
   void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
     child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(10, 10));
     root_layer_->AddChild(child_layer_);
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1)
-      layer_tree()->SetDeviceScaleFactor(4.f);
+      layer_tree_host()->SetDeviceScaleFactor(4.f);
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 1) {
       EXPECT_EQ(4.f, host_impl->sync_tree()->device_scale_factor());
       if (host_impl->pending_tree()) {
         // The active tree's device scale factor shouldn't change until
         // activation.
         EXPECT_EQ(1.f, host_impl->active_tree()->device_scale_factor());
       }
@@ skipping 31 matching lines @@
 
 class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNextCommitForcesRedraw()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
-    layer_tree()->SetRootLayer(root_layer_);
-    layer_tree()->SetViewportSize(bounds_);
+    layer_tree_host()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 3)
       host_impl->SetNeedsRedrawRect(invalid_rect_);
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
@@ skipping 71 matching lines @@
     // If we don't set the minimum contents scale, it's harder to verify whether
     // the damage we get is correct. For other scale amounts, please see
     // LayerTreeHostTestDamageWithScale.
     settings->minimum_contents_scale = 1.f;
   }
 
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
 
     // The initially transparent layer has a larger child layer, which is
     // not initially drawn because of the this (parent) layer.
     parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
     child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
@@ skipping 83 matching lines @@
     root_layer_->SetBounds(gfx::Size(50, 50));
 
     recording.reset(new FakeRecordingSource);
     child_layer_ = FakePictureLayer::CreateWithRecordingSource(
         &client_, std::move(recording));
     child_layer_->SetBounds(gfx::Size(25, 25));
     child_layer_->SetIsDrawable(true);
     child_layer_->SetContentsOpaque(true);
     root_layer_->AddChild(child_layer_);
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     // Force the layer to have a tiling at 1.3f scale. Note that if we simply
     // add tiling, it will be gone by the time we draw because of aggressive
     // cleanup. AddTilingUntilNextDraw ensures that it remains there during
     // damage calculation.
     FakePictureLayerImpl* child_layer_impl = static_cast<FakePictureLayerImpl*>(
@@ skipping 69 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDamageWithScale);
 
 // This test verifies that properties on the layer tree host are commited
 // to the impl side.
 class LayerTreeHostTestCommit : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCommit() {}
 
   void BeginTest() override {
-    layer_tree()->SetViewportSize(gfx::Size(20, 20));
-    layer_tree()->set_background_color(SK_ColorGRAY);
-    layer_tree()->SetEventListenerProperties(EventListenerClass::kMouseWheel,
-                                             EventListenerProperties::kPassive);
-    layer_tree()->SetEventListenerProperties(
+    layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
+    layer_tree_host()->set_background_color(SK_ColorGRAY);
+    layer_tree_host()->SetEventListenerProperties(
+        EventListenerClass::kMouseWheel, EventListenerProperties::kPassive);
+    layer_tree_host()->SetEventListenerProperties(
         EventListenerClass::kTouchStartOrMove,
         EventListenerProperties::kBlocking);
-    layer_tree()->SetEventListenerProperties(
+    layer_tree_host()->SetEventListenerProperties(
         EventListenerClass::kTouchEndOrCancel,
         EventListenerProperties::kBlockingAndPassive);
-    layer_tree()->SetHaveScrollEventHandlers(true);
+    layer_tree_host()->SetHaveScrollEventHandlers(true);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(gfx::Size(20, 20), impl->DrawViewportSize());
     EXPECT_EQ(SK_ColorGRAY, impl->active_tree()->background_color());
     EXPECT_EQ(EventListenerProperties::kPassive,
               impl->active_tree()->event_listener_properties(
                   EventListenerClass::kMouseWheel));
@@ skipping 16 matching lines @@
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it doesn't draw due to tree
 // activation failure.
 class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimeUpdatesAfterActivationFails()
       : frame_count_with_pending_tree_(0) {}
 
   void BeginTest() override {
-    layer_tree()->SetViewportSize(gfx::Size(20, 20));
-    layer_tree()->set_background_color(SK_ColorGRAY);
+    layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
+    layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(frame_count_with_pending_tree_, 0);
     impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
@@ skipping 32 matching lines @@
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(
     LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it draws in each frame.
 class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimeUpdatesAfterDraw() : frame_(0) {}
 
   void BeginTest() override {
-    layer_tree()->SetViewportSize(gfx::Size(20, 20));
-    layer_tree()->set_background_color(SK_ColorGRAY);
+    layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
+    layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     frame_++;
     if (frame_ == 1) {
       first_frame_time_ = impl->CurrentBeginFrameArgs().frame_time;
       impl->SetNeedsRedraw();
 
@@ skipping 29 matching lines @@
 
 // Verifies that StartPageScaleAnimation events propagate correctly
 // from LayerTreeHost to LayerTreeHostImpl in the MT compositor.
 class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
  public:
   LayerTreeHostTestStartPageScaleAnimation() {}
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    Layer* root_layer = layer_tree()->root_layer();
+    Layer* root_layer = layer_tree_host()->root_layer();
 
     scoped_refptr<FakePictureLayer> layer = FakePictureLayer::Create(&client_);
     layer->set_always_update_resources(true);
     scroll_layer_ = layer;
 
     scroll_layer_->SetBounds(gfx::Size(2 * root_layer->bounds().width(),
                                        2 * root_layer->bounds().height()));
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset());
 
     CreateVirtualViewportLayers(root_layer, scroll_layer_, root_layer->bounds(),
                                 root_layer->bounds(), layer_tree_host());
 
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& scroll_delta,
                            const gfx::Vector2dF&,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
                            float) override {
     gfx::ScrollOffset offset = scroll_layer_->scroll_offset();
     scroll_layer_->SetScrollOffset(ScrollOffsetWithDelta(offset, scroll_delta));
-    layer_tree()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
+    layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         // We'll start an animation when we get back to the main thread.
         break;
       case 1:
         EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         break;
       case 2:
         EXPECT_EQ(1.25f, impl->active_tree()->current_page_scale_factor());
         EndTest();
         break;
       case 3:
         break;
       default:
         NOTREACHED();
     }
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
-        layer_tree()->StartPageScaleAnimation(gfx::Vector2d(), false, 1.25f,
-                                              base::TimeDelta());
+        layer_tree_host()->StartPageScaleAnimation(gfx::Vector2d(), false,
+                                                   1.25f, base::TimeDelta());
         break;
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> scroll_layer_;
 };
 
@@ skipping 30 matching lines @@
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers() {}
 
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
     root_layer_ = FakePictureLayer::Create(&client_);
     child_layer_ = FakePictureLayer::Create(&client_);
 
-    layer_tree()->SetViewportSize(gfx::Size(60, 60));
-    layer_tree()->SetDeviceScaleFactor(1.5);
-    EXPECT_EQ(gfx::Size(60, 60), layer_tree()->device_viewport_size());
+    layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
+    layer_tree_host()->SetDeviceScaleFactor(1.5);
+    EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
 
     root_layer_->AddChild(child_layer_);
 
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(30, 30));
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetPosition(gfx::PointF(2.f, 2.f));
     child_layer_->SetBounds(gfx::Size(10, 10));
     client_.set_bounds(gfx::Size(10, 10));
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
 
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // Should only do one commit.
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     // Device scale factor should come over to impl.
     EXPECT_NEAR(impl->active_tree()->device_scale_factor(), 1.5f, 0.00001f);
@@ skipping 63 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);
 
 class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   void BeginTest() override {
-    layer_tree()->SetViewportSize(gfx::Size(10, 10));
-    layer_tree()->root_layer()->SetBounds(gfx::Size(10, 10));
+    layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
+    layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_->SetPosition(gfx::PointF(0.f, 0.f));
     layer_->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(layer_);
+    layer_tree_host()->root_layer()->AddChild(layer_);
 
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(layer_->bounds());
   }
 
   void DidCommitAndDrawFrame() override {
     if (num_draw_layers_ == 2)
       return;
     layer_->SetNeedsDisplay();
   }
@@ skipping 155 matching lines @@
  public:
   void SetupTree() override {
     num_tiles_rastered_ = 0;
 
     scoped_refptr<Layer> root_layer = PictureLayer::Create(&client_);
     client_.set_fill_with_nonsolid_color(true);
     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(10, 10));
     root_layer->SetContentsOpaque(true);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
 
     // The expectations are based on the assumption that the default
     // LCD settings are:
     EXPECT_TRUE(layer_tree_host()->settings().can_use_lcd_text);
 
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         // Change layer opacity that should trigger lcd change.
-        layer_tree()->root_layer()->SetOpacity(.5f);
+        layer_tree_host()->root_layer()->SetOpacity(.5f);
         break;
       case 3:
         // Change layer opacity that should not trigger lcd change.
-        layer_tree()->root_layer()->SetOpacity(1.f);
+        layer_tree_host()->root_layer()->SetOpacity(1.f);
         break;
       case 4:
         EndTest();
         break;
     }
   }
 
   void NotifyTileStateChangedOnThread(LayerTreeHostImpl* host_impl,
                                       const Tile* tile) override {
     ++num_tiles_rastered_;
@@ skipping 204 matching lines @@
 
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
     layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
     layer->SetBounds(gfx::Size(10, 10));
-    layer_tree()->root_layer()->AddChild(layer);
+    layer_tree_host()->root_layer()->AddChild(layer);
     client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
   }
 
   void AfterTest() override {}
@@ skipping 66 matching lines @@
     parent_layer_->SetIsDrawable(true);
     parent_layer_->SetBounds(gfx::Size(50, 50));
     parent_layer_->SetForceRenderSurfaceForTesting(true);
 
     child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetIsDrawable(true);
     child_layer_->SetBounds(gfx::Size(50, 50));
 
     root_layer_->AddChild(parent_layer_);
     parent_layer_->AddChild(child_layer_);
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
 
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     auto on_draw_callback =
         base::Bind(&LayerTreeHostTestResourcelessSoftwareDraw::CallOnDraw,
@@ skipping 322 matching lines @@
     }
 
     if (other_root_->layer_tree_host()) {
       EXPECT_FALSE(
           other_root_->GetLayerTree()->LayerNeedsPushPropertiesForTesting(
               other_root_.get()));
     }
 
     switch (num_commits_) {
       case 1:
-        layer_tree()->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         // Layers added to the tree get committed.
         ++expected_push_properties_root_;
         ++expected_push_properties_child_;
         ++expected_push_properties_grandchild_;
         ++expected_push_properties_child2_;
         break;
       case 2:
         layer_tree_host()->SetNeedsCommit();
         // No layers need commit.
         break;
       case 3:
-        layer_tree()->SetRootLayer(other_root_);
+        layer_tree_host()->SetRootLayer(other_root_);
         // Layers added to the tree get committed.
         ++expected_push_properties_other_root_;
         break;
       case 4:
-        layer_tree()->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         // Layers added to the tree get committed.
         ++expected_push_properties_root_;
         ++expected_push_properties_child_;
         ++expected_push_properties_grandchild_;
         ++expected_push_properties_child2_;
         break;
       case 5:
         layer_tree_host()->SetNeedsCommit();
         // No layers need commit.
         break;
@@ skipping 10 matching lines @@
       case 8:
         grandchild_->RemoveFromParent();
         // No layers need commit.
         break;
       case 9:
         child_->AddChild(grandchild_);
         // Layers added to the tree get committed.
         ++expected_push_properties_grandchild_;
         break;
       case 10:
-        layer_tree()->SetViewportSize(gfx::Size(20, 20));
+        layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
         // No layers need commit.
         break;
       case 11:
-        layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.8f, 1.1f);
+        layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.8f, 1.1f);
         // No layers need commit.
         break;
       case 12:
         child_->MakePushProperties();
         // The modified layer needs commit
         ++expected_push_properties_child_;
         ++expected_push_properties_grandchild_;
         break;
       case 13:
         child2_->MakePushProperties();
@@ skipping 255 matching lines @@
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(1, 1));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_layer_ = FakePaintedScrollbarLayer::Create(
         paint_scrollbar, has_thumb, root_->id());
 
     root_->AddChild(scrollbar_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
         // During update, the ignore_set_needs_commit_ bit is set to true to
         // avoid causing a second commit to be scheduled. If a property change
         // is made during this, however, it needs to be pushed in the upcoming
         // commit.
         std::unique_ptr<base::AutoReset<bool>> ignore =
             scrollbar_layer_->IgnoreSetNeedsCommit();
 
         scrollbar_layer_->SetBounds(gfx::Size(30, 30));
 
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            scrollbar_layer_.get()));
+        EXPECT_TRUE(
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(scrollbar_layer_.get()));
         layer_tree_host()->SetNeedsCommit();
 
         scrollbar_layer_->reset_push_properties_count();
         EXPECT_EQ(0u, scrollbar_layer_->push_properties_count());
         break;
       }
       case 2:
         EXPECT_EQ(1u, scrollbar_layer_->push_properties_count());
         EndTest();
         break;
@@ skipping 10 matching lines @@
 
 class LayerTreeHostTestSetDrawableCausesCommit : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     root_ = PushPropertiesCountingLayer::Create();
     child_ = PushPropertiesCountingLayer::Create();
     root_->AddChild(child_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
+    LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
         // During update, the ignore_set_needs_commit_ bit is set to true to
         // avoid causing a second commit to be scheduled. If a property change
         // is made during this, however, it needs to be pushed in the upcoming
         // commit.
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
+            layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_EQ(0, root_->NumDescendantsThatDrawContent());
         root_->reset_push_properties_count();
         child_->reset_push_properties_count();
         child_->SetDrawsContent(true);
         EXPECT_EQ(1, root_->NumDescendantsThatDrawContent());
         EXPECT_EQ(0u, root_->push_properties_count());
         EXPECT_EQ(0u, child_->push_properties_count());
         EXPECT_TRUE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_TRUE(
 
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
+            layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         break;
       }
       case 2:
         EXPECT_EQ(1u, root_->push_properties_count());
         EXPECT_EQ(1u, child_->push_properties_count());
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
+            layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<PushPropertiesCountingLayer> root_;
   scoped_refptr<PushPropertiesCountingLayer> child_;
 };
@@ skipping 45 matching lines @@
 };
 
 class LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         // All layers will need push properties as we set their layer tree host
-        layer_tree()->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
+        EXPECT_TRUE(layer_tree_host()
+                        ->GetLayerTree()
+                        ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_TRUE(layer_tree_host()
+                        ->GetLayerTree()
+                        ->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_TRUE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
         EXPECT_TRUE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild1_.get()));
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild2_.get()));
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild3_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
+        EXPECT_TRUE(
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild3_.get()));
         break;
       case 1:
         EndTest();
         break;
     }
   }
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
-        layer_tree()->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild1_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild2_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild3_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
+        EXPECT_FALSE(
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild3_.get()));
 
         grandchild1_->RemoveFromParent();
         grandchild1_->SetPosition(gfx::PointF(1.f, 1.f));
 
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild2_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild3_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild3_.get()));
 
         child_->AddChild(grandchild1_);
 
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(child_.get()));
+        EXPECT_TRUE(
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild1_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild2_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild3_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild3_.get()));
 
         grandchild2_->SetPosition(gfx::PointF(1.f, 1.f));
 
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(child_.get()));
+        EXPECT_TRUE(
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
+        EXPECT_TRUE(
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
         EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
-        EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild1_.get()));
-        EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild2_.get()));
-        EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
-            grandchild3_.get()));
+            layer_tree_host()
+                ->GetLayerTree()
+                ->LayerNeedsPushPropertiesForTesting(grandchild3_.get()));
 
         // grandchild2_ will still need a push properties.
         grandchild1_->RemoveFromParent();
 
-        EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
-        EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(child_.get()));
 
         // grandchild3_ does not need a push properties, so recursing should
         // no longer be needed.
         grandchild2_->RemoveFromParent();
 
-        EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
-        EXPECT_FALSE(
-            layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(root_.get()));
+        EXPECT_FALSE(layer_tree_host()
+                         ->GetLayerTree()
+                         ->LayerNeedsPushPropertiesForTesting(child_.get()));
         EndTest();
         break;
     }
   }
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
-        layer_tree->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         grandchild1_->set_persist_needs_push_properties(true);
         grandchild2_->set_persist_needs_push_properties(true);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_TRUE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
@@ skipping 28 matching lines @@
     LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence);
 
 class LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
-        layer_tree->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
@@ skipping 48 matching lines @@
     LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
-        layer_tree->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
@@ skipping 44 matching lines @@
     LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
-        layer_tree->SetRootLayer(root_);
+        layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild1_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(grandchild2_.get()));
@@ skipping 146 matching lines @@
 // to the compositor thread, even though no resources are updated in
 // response to that invalidation.
 class LayerTreeHostTestVideoLayerInvalidate : public LayerInvalidateCausesDraw {
  public:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     scoped_refptr<VideoLayer> video_layer =
         VideoLayer::Create(&provider_, media::VIDEO_ROTATION_0);
     video_layer->SetBounds(gfx::Size(10, 10));
     video_layer->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(video_layer);
+    layer_tree_host()->root_layer()->AddChild(video_layer);
 
     invalidate_layer_ = video_layer;
   }
 
  private:
   FakeVideoFrameProvider provider_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestVideoLayerInvalidate);
 
 class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetPosition(gfx::PointF());
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     parent_layer_ = SolidColorLayer::Create();
     parent_layer_->SetPosition(gfx::PointF());
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root_layer_->AddChild(parent_layer_);
 
     child_layer_ = SolidColorLayer::Create();
     child_layer_->SetPosition(gfx::PointF());
     child_layer_->SetBounds(gfx::Size(10, 10));
     child_layer_->SetIsDrawable(true);
     parent_layer_->AddChild(child_layer_);
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layer type used does not need to push properties every frame.
@@ skipping 33 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
 
-    layer_tree()->SetRootLayer(root_layer_);
+    layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override {
     // The viewport is empty, but we still need to update layers on the main
     // thread.
-    layer_tree()->SetViewportSize(gfx::Size(0, 0));
+    layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     // The layer should be updated even though the viewport is empty, so we
     // are capable of drawing it on the impl tree.
     EXPECT_GT(root_layer_->update_count(), 0);
     EndTest();
   }
 
@@ skipping 30 matching lines @@
     root_layer_->AddChild(inner_viewport_container_layer);
     inner_viewport_container_layer->AddChild(overscroll_elasticity_layer);
     overscroll_elasticity_layer->AddChild(page_scale_layer);
     page_scale_layer->AddChild(inner_viewport_scroll_layer);
 
     scoped_refptr<Layer> content_layer = FakePictureLayer::Create(&client_);
     content_layer_id_ = content_layer->id();
     content_layer->SetBounds(gfx::Size(10, 10));
     inner_viewport_scroll_layer->AddChild(content_layer);
 
-    layer_tree()->SetRootLayer(root_layer_);
-    layer_tree()->RegisterViewportLayers(overscroll_elasticity_layer,
-                                         page_scale_layer,
-                                         inner_viewport_scroll_layer, nullptr);
+    layer_tree_host()->SetRootLayer(root_layer_);
+    layer_tree_host()->RegisterViewportLayers(
+        overscroll_elasticity_layer, page_scale_layer,
+        inner_viewport_scroll_layer, nullptr);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(content_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 0) {
       scroll_elasticity_helper_ = host_impl->CreateScrollElasticityHelper();
     }
@@ skipping 71 matching lines @@
             second_context_provider_.get() ? second_output_surface_memory_limit_
                                            : first_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
     return std::move(output_surface);
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     // Lost context sometimes takes two frames to recreate. The third frame
     // is sometimes aborted, so wait until the fourth frame to verify that
     // the memory has been set, and the fifth frame to end the test.
@@ skipping 233 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 
 class LayerTreeHostTestKeepSwapPromise : public LayerTreeHostTest {
  public:
   LayerTreeHostTestKeepSwapPromise() {}
 
   void BeginTest() override {
     layer_ = SolidColorLayer::Create();
     layer_->SetIsDrawable(true);
     layer_->SetBounds(gfx::Size(10, 10));
-    layer_tree()->SetRootLayer(layer_);
+    layer_tree_host()->SetRootLayer(layer_);
     gfx::Size bounds(100, 100);
-    layer_tree()->SetViewportSize(bounds);
+    layer_tree_host()->SetViewportSize(bounds);
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&LayerTreeHostTestKeepSwapPromise::ChangeFrame,
                               base::Unretained(this)));
   }
 
   void ChangeFrame() {
@@ skipping 72 matching lines @@
   LayerTreeHostTestKeepSwapPromiseMFBA() {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->main_frame_before_activation_enabled = true;
   }
 
   void BeginTest() override {
     layer_ = SolidColorLayer::Create();
     layer_->SetIsDrawable(true);
     layer_->SetBounds(gfx::Size(10, 10));
-    layer_tree()->SetRootLayer(layer_);
+    layer_tree_host()->SetRootLayer(layer_);
     gfx::Size bounds(100, 100);
-    layer_tree()->SetViewportSize(bounds);
+    layer_tree_host()->SetViewportSize(bounds);
     PostSetNeedsCommitToMainThread();
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     // Safe to check frame number here because main thread is blocked.
     if (layer_tree_host()->source_frame_number() == 0) {
       host_impl->BlockNotifyReadyToActivateForTesting(true);
     } else {
       NOTREACHED();
     }
@@ skipping 256 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
-    client_.set_bounds(layer_tree()->root_layer()->bounds());
+    client_.set_bounds(layer_tree_host()->root_layer()->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->EvictAllUIResources();
     // Existence of evicted UI resources will trigger NEW_CONTENT_TAKES_PRIORITY
     // mode. Active tree should require high-res to draw after entering this
     // mode to ensure that high-res tiles are also required for a pending tree
     // to be activated.
@@ skipping 35 matching lines @@
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(layer);
+    layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Setting gpu rasterization trigger does not enable gpu rasterization.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
@@ skipping 33 matching lines @@
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size());
     layer->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(layer);
+    layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override {
     // Setting gpu rasterization trigger does not enable gpu rasterization.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 35 matching lines @@
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(layer);
+    layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Gpu rasterization trigger is relevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
@@ skipping 49 matching lines @@
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(layer);
+    layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Gpu rasterization trigger is relevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
@@ skipping 62 matching lines @@
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
     layer_ = layer.get();
 
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
-    layer_tree()->root_layer()->AddChild(layer);
+    layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // With gpu rasterization forced, gpu rasterization trigger is irrelevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
@@ skipping 315 matching lines @@
 
 // Make sure page scale and top control deltas are applied to the client even
 // when the LayerTreeHost doesn't have a root layer.
 class LayerTreeHostAcceptsDeltasFromImplWithoutRootLayer
     : public LayerTreeHostTest {
  public:
   LayerTreeHostAcceptsDeltasFromImplWithoutRootLayer()
       : deltas_sent_to_client_(false) {}
 
   void BeginTest() override {
-    layer_tree()->SetRootLayer(nullptr);
+    layer_tree_host()->SetRootLayer(nullptr);
     info_.page_scale_delta = 3.14f;
     info_.top_controls_delta = 2.73f;
 
     PostSetNeedsCommitToMainThread();
   }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
-    EXPECT_EQ(nullptr, layer_tree()->root_layer());
+    EXPECT_EQ(nullptr, layer_tree_host()->root_layer());
 
     layer_tree_host()->ApplyScrollAndScale(&info_);
     EndTest();
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner,
                            const gfx::Vector2dF& outer,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale_delta,
                            float top_controls_delta) override {
@@ skipping 37 matching lines @@
     recording->SetPlaybackAllowedEvent(&playback_allowed_event_);
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     // Avoid LCD text on the layer so we don't cause extra commits when we
     // pinch.
     pinch->AddChild(layer);
 
-    layer_tree()->RegisterViewportLayers(NULL, page_scale_layer, pinch,
-                                         nullptr);
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
-    layer_tree()->SetRootLayer(root_clip);
+    layer_tree_host()->RegisterViewportLayers(NULL, page_scale_layer, pinch,
+                                              nullptr);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
+    layer_tree_host()->SetRootLayer(root_clip);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_clip->bounds());
   }
 
   // Returns the delta scale of all quads in the frame's root pass from their
   // ideal, or 0 if they are not all the same.
   float FrameQuadScaleDeltaFromIdeal(LayerTreeHostImpl::FrameData* frame_data) {
     if (frame_data->has_no_damage)
       return 0.f;
     float frame_scale = 0.f;
@@ skipping 177 matching lines @@
     client_.set_bounds(root->bounds());
 
     std::unique_ptr<FakeRecordingSource> recording(new FakeRecordingSource);
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     root->AddChild(layer);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_NE(0u, host_impl->resource_provider()->num_resources());
@@ skipping 20 matching lines @@
     client_.set_fill_with_nonsolid_color(true);
 
     std::unique_ptr<FakeRecordingSource> recording(new FakeRecordingSource);
     scoped_refptr<FakePictureLayer> root =
         FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     root->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(root->bounds());
     root->SetContentsOpaque(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
-    layer_tree()->SetViewportSize(viewport_size_);
+    layer_tree_host()->SetViewportSize(viewport_size_);
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(10u, host_impl->resource_provider()->num_resources());
     EndTest();
@@ skipping 37 matching lines @@
     recording->SetPlaybackAllowedEvent(&playback_allowed_event_);
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     // Avoid LCD text on the layer so we don't cause extra commits when we
     // pinch.
     pinch->AddChild(layer);
 
-    layer_tree()->RegisterViewportLayers(NULL, page_scale_layer, pinch,
-                                         nullptr);
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
-    layer_tree()->SetRootLayer(root_clip);
+    layer_tree_host()->RegisterViewportLayers(NULL, page_scale_layer, pinch,
+                                              nullptr);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
+    layer_tree_host()->SetRootLayer(root_clip);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_clip->bounds());
   }
 
   // Returns the delta scale of all quads in the frame's root pass from their
   // ideal, or 0 if they are not all the same.
   float FrameQuadScaleDeltaFromIdeal(LayerTreeHostImpl::FrameData* frame_data) {
     if (frame_data->has_no_damage)
       return 0.f;
     float frame_scale = 0.f;
@@ skipping 133 matching lines @@
       : notify_ready_to_activate_count_(0u),
         scheduled_prepare_tiles_count_(0) {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1500, 1500));
     root_layer->SetIsDrawable(true);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override {
-    layer_tree()->SetViewportSize(gfx::Size(16, 16));
+    layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
     PostSetNeedsCommitToMainThread();
   }
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     ASSERT_TRUE(success);
     host_impl->tile_manager()->SetScheduledRasterTaskLimitForTesting(1);
   }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 29 matching lines @@
   LayerTreeHostTestActivationCausesPrepareTiles()
       : scheduled_prepare_tiles_count_(0) {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(150, 150));
     root_layer->SetIsDrawable(true);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
     // Ensure we've already activated.
     EXPECT_FALSE(impl->pending_tree());
 
@@ skipping 57 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoTasksBetweenWillAndDidCommit);
 
 class LayerTreeHostTestUpdateCopyRequests : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root = Layer::Create();
     child = Layer::Create();
     root->AddChild(child);
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   static void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
@@ skipping 74 matching lines @@
                                clipping_origin.OffsetFromOrigin());
 
     gfx::Size child_size(50, 50);
     content_child_layer->SetBounds(child_size);
     content_child_layer->SetPosition(gfx::PointF(20.f, 0.f));
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
@@ skipping 64 matching lines @@
     scaling_layer->SetBounds(scaling_layer_size);
     gfx::Transform scale;
     scale.Scale(2.f, 2.f);
     scaling_layer->SetTransform(scale);
 
     content_layer->SetBounds(scaling_layer_size);
 
     mask_layer->SetBounds(scaling_layer_size);
     mask_layer->SetIsMask(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
@@ skipping 29 matching lines @@
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         gfx::Size double_root_size(200, 200);
-        layer_tree()->SetViewportSize(double_root_size);
-        layer_tree()->SetDeviceScaleFactor(2.f);
+        layer_tree_host()->SetViewportSize(double_root_size);
+        layer_tree_host()->SetDeviceScaleFactor(2.f);
         break;
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestMaskLayerWithScaling);
@@ skipping 17 matching lines @@
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
@@ skipping 28 matching lines @@
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         gfx::Size double_root_size(200, 200);
-        layer_tree()->SetViewportSize(double_root_size);
-        layer_tree()->SetDeviceScaleFactor(2.f);
+        layer_tree_host()->SetViewportSize(double_root_size);
+        layer_tree_host()->SetDeviceScaleFactor(2.f);
         break;
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestMaskLayerWithDifferentBounds);
@@ skipping 21 matching lines @@
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
@@ skipping 29 matching lines @@
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         gfx::Size double_root_size(200, 200);
-        layer_tree()->SetViewportSize(double_root_size);
-        layer_tree()->SetDeviceScaleFactor(2.f);
+        layer_tree_host()->SetViewportSize(double_root_size);
+        layer_tree_host()->SetDeviceScaleFactor(2.f);
         break;
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 27 matching lines @@
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
     content_child_layer_->SetBounds(layer_size);
     content_child_layer_->SetPosition(gfx::PointF(50.f, 0.f));
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
@@ skipping 72 matching lines @@
     scoped_refptr<Layer> post_page_scale = Layer::Create();
 
     root->AddChild(pre_page_scale);
     root->AddChild(page_scale);
     root->AddChild(post_page_scale);
 
     page_scale->AddChild(page_scale_child1);
     page_scale->AddChild(page_scale_child2);
     page_scale_child1->AddChild(page_scale_grandchild);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
 
     scoped_refptr<Layer> overscroll_elasticity_layer = nullptr;
     scoped_refptr<Layer> inner_viewport_scroll_layer = nullptr;
     scoped_refptr<Layer> outer_viewport_scroll_layer = nullptr;
-    layer_tree()->RegisterViewportLayers(
+    layer_tree_host()->RegisterViewportLayers(
         overscroll_elasticity_layer, page_scale, inner_viewport_scroll_layer,
         outer_viewport_scroll_layer);
 
     affected_by_page_scale_.push_back(page_scale->id());
     affected_by_page_scale_.push_back(page_scale_child1->id());
     affected_by_page_scale_.push_back(page_scale_child2->id());
     affected_by_page_scale_.push_back(page_scale_grandchild->id());
 
     not_affected_by_page_scale_.push_back(root->id());
     not_affected_by_page_scale_.push_back(pre_page_scale->id());
@@ skipping 38 matching lines @@
   void AfterTest() override {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDestroyWhileInitializingOutputSurface);
 
 // Makes sure that painted_device_scale_factor is propagated to the
 // frame's metadata.
 class LayerTreeHostTestPaintedDeviceScaleFactor : public LayerTreeHostTest {
  protected:
   void BeginTest() override {
-    layer_tree()->SetPaintedDeviceScaleFactor(2.0f);
-    EXPECT_EQ(1.0f, layer_tree()->device_scale_factor());
+    layer_tree_host()->SetPaintedDeviceScaleFactor(2.0f);
+    EXPECT_EQ(1.0f, layer_tree_host()->device_scale_factor());
     PostSetNeedsCommitToMainThread();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(2.0f, host_impl->active_tree()->painted_device_scale_factor());
     EXPECT_EQ(1.0f, host_impl->active_tree()->device_scale_factor());
   }
 
   void DisplayReceivedCompositorFrameOnThread(
       const CompositorFrame& frame) override {
@@ skipping 39 matching lines @@
     recording->SetGenerateDiscardableImagesMetadata(true);
     recording->Rerecord();
 
     scoped_refptr<FakePictureLayer> root =
         FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     root->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(root->bounds());
     root->SetContentsOpaque(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
-    layer_tree()->SetViewportSize(viewport_size_);
+    layer_tree_host()->SetViewportSize(viewport_size_);
     client_.set_bounds(root->bounds());
   }
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     // Check that our large_image_size_ is greater than max texture size. We do
     // this here to ensure that our otuput surface exists.
 
     // Retrieve max texture size from Skia.
     ContextProvider* context_provider =
@@ skipping 17 matching lines @@
  private:
   FakeContentLayerClient client_;
   const gfx::Size viewport_size_;
   const gfx::Size large_image_size_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(GpuRasterizationSucceedsWithLargeImage);
 
 }  // namespace
 }  // namespace cc