cc: Merge LayerTree into the LayerTreeHost.

cc/trees/layer_tree_host_unittest_scroll.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 54 matching lines @@
 }
 
 static ScrollTree* ScrollTreeForLayer(LayerImpl* layer_impl) {
   return &layer_impl->layer_tree_impl()->property_trees()->scroll_tree;
 }
 
 class LayerTreeHostScrollTest : public LayerTreeTest {
  protected:
   void SetupTree() override {
     LayerTreeTest::SetupTree();
-    Layer* root_layer = layer_tree()->root_layer();
+    Layer* root_layer = layer_tree_host()->root_layer();
 
     // Create an effective max_scroll_offset of (100, 100).
     gfx::Size scroll_layer_bounds(root_layer->bounds().width() + 100,
                                   root_layer->bounds().height() + 100);
 
     CreateVirtualViewportLayers(root_layer, root_layer->bounds(),
                                 root_layer->bounds(), scroll_layer_bounds,
                                 layer_tree_host());
   }
 };
 
 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollSimple()
       : initial_scroll_(10, 20),
         second_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   void BeginTest() override {
-    outer_viewport_container_layer_id_ =
-        layer_tree()->outer_viewport_scroll_layer()->scroll_clip_layer()->id();
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    outer_viewport_container_layer_id_ = layer_tree_host()
+                                             ->outer_viewport_scroll_layer()
+                                             ->scroll_clip_layer()
+                                             ->id();
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
-    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
         base::Bind(&LayerTreeHostScrollTestScrollSimple::DidScrollOuterViewport,
                    base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
-    Layer* scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     if (!layer_tree_host()->SourceFrameNumber()) {
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_,
                                                   scroll_amount_),
                        scroll_layer->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
       scroll_layer->SetScrollOffset(second_scroll_);
     }
@@ skipping 41 matching lines @@
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollSimple);
 
 class LayerTreeHostScrollTestScrollMultipleRedraw
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollMultipleRedraw()
       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 
   void BeginTest() override {
-    scroll_layer_ = layer_tree()->outer_viewport_scroll_layer();
+    scroll_layer_ = layer_tree_host()->outer_viewport_scroll_layer();
     scroll_layer_->SetScrollOffset(initial_scroll_);
     scroll_layer_->set_did_scroll_callback(base::Bind(
         &LayerTreeHostScrollTestScrollMultipleRedraw::DidScrollOuterViewport,
         base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
@@ skipping 70 matching lines @@
         second_main_scroll_(14, -3),
         impl_scale_(2.f),
         num_will_begin_main_frames_(0),
         num_did_begin_main_frames_(0),
         num_will_commits_(0),
         num_did_commits_(0),
         num_impl_commits_(0),
         num_impl_scrolls_(0) {}
 
   void BeginTest() override {
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
-    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
         base::Bind(
             &LayerTreeHostScrollTestScrollAbortedCommit::DidScrollOuterViewport,
             base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
 
     gfx::Size scroll_layer_bounds(200, 200);
-    layer_tree()->outer_viewport_scroll_layer()->SetBounds(scroll_layer_bounds);
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+    layer_tree_host()->outer_viewport_scroll_layer()->SetBounds(
+        scroll_layer_bounds);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   void WillBeginMainFrame() override {
     num_will_begin_main_frames_++;
-    Layer* root_scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* root_scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     switch (num_will_begin_main_frames_) {
       case 1:
         // This will not be aborted because of the initial prop changes.
         EXPECT_EQ(0, num_impl_scrolls_);
         EXPECT_EQ(0, layer_tree_host()->SourceFrameNumber());
         EXPECT_VECTOR_EQ(initial_scroll_, root_scroll_layer->scroll_offset());
-        EXPECT_EQ(1.f, layer_tree()->page_scale_factor());
+        EXPECT_EQ(1.f, layer_tree_host()->page_scale_factor());
         break;
       case 2:
         // This commit will be aborted, and another commit will be
         // initiated from the redraw.
         EXPECT_EQ(1, num_impl_scrolls_);
         EXPECT_EQ(1, layer_tree_host()->SourceFrameNumber());
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(initial_scroll_, impl_scroll_),
             root_scroll_layer->scroll_offset());
-        EXPECT_EQ(impl_scale_, layer_tree()->page_scale_factor());
+        EXPECT_EQ(impl_scale_, layer_tree_host()->page_scale_factor());
         PostSetNeedsRedrawToMainThread();
         break;
       case 3:
         // This commit will not be aborted because of the scroll change.
         EXPECT_EQ(2, num_impl_scrolls_);
         // The source frame number still increases even with the abort.
         EXPECT_EQ(2, layer_tree_host()->SourceFrameNumber());
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(initial_scroll_,
                                        impl_scroll_ + impl_scroll_),
             root_scroll_layer->scroll_offset());
-        EXPECT_EQ(impl_scale_ * impl_scale_, layer_tree()->page_scale_factor());
+        EXPECT_EQ(impl_scale_ * impl_scale_,
+                  layer_tree_host()->page_scale_factor());
         root_scroll_layer->SetScrollOffset(gfx::ScrollOffsetWithDelta(
             root_scroll_layer->scroll_offset(), second_main_scroll_));
         break;
       case 4:
         // This commit will also be aborted.
         EXPECT_EQ(3, num_impl_scrolls_);
         EXPECT_EQ(3, layer_tree_host()->SourceFrameNumber());
         gfx::Vector2dF delta =
             impl_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_;
         EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
@@ skipping 116 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollAbortedCommit);
 
 class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestFractionalScroll() : scroll_amount_(1.75, 0) {}
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
     switch (impl->active_tree()->source_frame_number()) {
@@ skipping 35 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestFractionalScroll);
 
 class LayerTreeHostScrollTestScrollSnapping : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollSnapping() : scroll_amount_(1.75, 0) {}
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
-    layer_tree()
+    layer_tree_host()
         ->outer_viewport_scroll_layer()
         ->scroll_clip_layer()
         ->SetForceRenderSurfaceForTesting(true);
     gfx::Transform translate;
     translate.Translate(0.25f, 0.f);
-    layer_tree()
+    layer_tree_host()
         ->outer_viewport_scroll_layer()
         ->scroll_clip_layer()
         ->SetTransform(translate);
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.1f, 100.f);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.1f, 100.f);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
     gfx::Transform translate;
 
     // Check that screen space transform of the scrollable layer is correctly
     // snapped to integers.
@@ skipping 29 matching lines @@
 
 class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestCaseWithChild()
       : initial_offset_(10, 20),
         javascript_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   void SetupTree() override {
-    layer_tree()->SetDeviceScaleFactor(device_scale_factor_);
+    layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
 
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(10, 10));
 
     root_scroll_layer_ = FakePictureLayer::Create(&fake_content_layer_client_);
     root_scroll_layer_->SetBounds(gfx::Size(110, 110));
     root_scroll_layer_->SetPosition(gfx::PointF());
     root_scroll_layer_->SetIsDrawable(true);
 
     CreateVirtualViewportLayers(root_layer.get(), root_scroll_layer_,
@@ skipping 10 matching lines @@
       // Scrolls on the child layer will happen at 5, 5. If they are treated
       // like device pixels, and device scale factor is 2, then they will
       // be considered at 2.5, 2.5 in logical pixels, and will miss this layer.
       child_layer_->SetPosition(gfx::PointF(5.f, 5.f));
     } else {
       // Adjust the child layer horizontally so that scrolls will never hit it.
       child_layer_->SetPosition(gfx::PointF(60.f, 5.f));
     }
 
     scoped_refptr<Layer> outer_container_layer =
-        layer_tree()->outer_viewport_scroll_layer()->parent();
+        layer_tree_host()->outer_viewport_scroll_layer()->parent();
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetScrollClipLayerId(outer_container_layer->id());
     child_layer_->SetBounds(root_scroll_layer_->bounds());
     root_scroll_layer_->AddChild(child_layer_);
 
     if (scroll_child_layer_) {
       expected_scroll_layer_ = child_layer_;
       expected_no_scroll_layer_ = root_scroll_layer_;
     } else {
       expected_scroll_layer_ = root_scroll_layer_;
       expected_no_scroll_layer_ = child_layer_;
     }
 
     expected_scroll_layer_->SetScrollOffset(initial_offset_);
 
-    layer_tree()->SetRootLayer(root_layer);
+    layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeTest::SetupTree();
     fake_content_layer_client_.set_bounds(root_layer->bounds());
 
-    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
         base::Bind(
             &LayerTreeHostScrollTestCaseWithChild::DidScrollOuterViewport,
             base::Unretained(this)));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillCommit() override {
     // Keep the test committing (otherwise the early out for no update
     // will stall the test).
@@ skipping 192 matching lines @@
  public:
   LayerTreeHostScrollTestSimple()
       : initial_scroll_(10, 20),
         main_thread_scroll_(40, 5),
         impl_thread_scroll1_(2, -1),
         impl_thread_scroll2_(-3, 10),
         num_scrolls_(0) {}
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   void BeginTest() override {
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
-    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
         base::Bind(&LayerTreeHostScrollTestSimple::DidScrollOuterViewport,
                    base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
-    Layer* scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     if (!layer_tree_host()->SourceFrameNumber()) {
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(
           scroll_layer->scroll_offset(),
           gfx::ScrollOffsetWithDelta(initial_scroll_, impl_thread_scroll1_));
 
       // Pretend like Javascript updated the scroll position itself with a
       // change of main_thread_scroll.
       scroll_layer->SetScrollOffset(
@@ skipping 88 matching lines @@
 // beginning a commit and finishing a commit (aka scroll deltas not
 // included in sent scroll delta) still apply to layers that don't
 // push properties.
 class LayerTreeHostScrollTestImplOnlyScroll : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestImplOnlyScroll()
       : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3), impl_scale_(2.f) {}
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   void BeginTest() override {
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   void WillCommit() override {
-    Layer* scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         EXPECT_TRUE(
-            scroll_layer->GetLayerTree()->LayerNeedsPushPropertiesForTesting(
+            scroll_layer->layer_tree_host()->LayerNeedsPushPropertiesForTesting(
                 scroll_layer));
         break;
       case 1:
         // Even if this layer doesn't need push properties, it should
         // still pick up scrolls that happen on the active layer during
         // commit.
         EXPECT_FALSE(
-            scroll_layer->GetLayerTree()->LayerNeedsPushPropertiesForTesting(
+            scroll_layer->layer_tree_host()->LayerNeedsPushPropertiesForTesting(
                 scroll_layer));
         break;
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     // Scroll after the 2nd commit has started.
     if (impl->active_tree()->source_frame_number() == 0) {
       LayerImpl* active_root = impl->active_tree()->root_layer_for_testing();
       LayerImpl* active_scroll_layer = impl->OuterViewportScrollLayer();
@@ skipping 97 matching lines @@
 
 // This tests scrolling on the impl side which is only possible with a thread.
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestImplOnlyScroll);
 
 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
   void BeginTest() override {
-    outer_viewport_container_layer_id_ =
-        layer_tree()->outer_viewport_scroll_layer()->scroll_clip_layer()->id();
+    outer_viewport_container_layer_id_ = layer_tree_host()
+                                             ->outer_viewport_scroll_layer()
+                                             ->scroll_clip_layer()
+                                             ->id();
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
-    Layer* root = layer_tree()->root_layer();
-    Layer* scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* root = layer_tree_host()->root_layer();
+    Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         scroll_layer->SetScrollClipLayerId(outer_viewport_container_layer_id_);
         // Set max_scroll_offset = (100, 100).
         scroll_layer->SetBounds(gfx::Size(root->bounds().width() + 100,
                                           root->bounds().height() + 100));
         break;
       case 1:
         // Set max_scroll_offset = (0, 0).
         scroll_layer->SetBounds(root->bounds());
@@ skipping 48 matching lines @@
 
 class LayerTreeHostScrollTestScrollNonDrawnLayer
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollNonDrawnLayer() {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
-    layer_tree()->outer_viewport_scroll_layer()->SetIsDrawable(false);
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    layer_tree_host()->outer_viewport_scroll_layer()->SetIsDrawable(false);
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         gfx::ScrollOffset(20.f, 20.f));
-    layer_tree()->outer_viewport_scroll_layer()->SetNonFastScrollableRegion(
-        gfx::Rect(20, 20, 20, 20));
+    layer_tree_host()
+        ->outer_viewport_scroll_layer()
+        ->SetNonFastScrollableRegion(gfx::Rect(20, 20, 20, 20));
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
 
     ScrollTree& scroll_tree =
         impl->active_tree()->property_trees()->scroll_tree;
     ScrollNode* scroll_node =
         scroll_tree.Node(scroll_layer->scroll_tree_index());
 
@@ skipping 24 matching lines @@
 
 class LayerTreeHostScrollTestImplScrollUnderMainThreadScrollingParent
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestImplScrollUnderMainThreadScrollingParent() {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
-    layer_tree()->inner_viewport_scroll_layer()->AddMainThreadScrollingReasons(
-        MainThreadScrollingReason::kNonFastScrollableRegion);
+    layer_tree_host()
+        ->inner_viewport_scroll_layer()
+        ->AddMainThreadScrollingReasons(
+            MainThreadScrollingReason::kNonFastScrollableRegion);
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* inner_scroll_layer = impl->InnerViewportScrollLayer();
     LayerImpl* outer_scroll_layer = impl->OuterViewportScrollLayer();
 
     ScrollTree& scroll_tree =
         impl->active_tree()->property_trees()->scroll_tree;
     ScrollNode* inner_scroll_node =
         scroll_tree.Node(inner_scroll_layer->scroll_tree_index());
@@ skipping 120 matching lines @@
 }
 
 class LayerTreeHostScrollTestLayerStructureChange
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestLayerStructureChange()
       : scroll_destroy_whole_tree_(false) {}
 
   void SetupTree() override {
     LayerTreeTest::SetupTree();
-    Layer* root_layer = layer_tree()->root_layer();
+    Layer* root_layer = layer_tree_host()->root_layer();
     root_layer->SetBounds(gfx::Size(10, 10));
 
     CreateVirtualViewportLayers(root_layer, root_layer->bounds(),
                                 root_layer->bounds(), root_layer->bounds(),
                                 layer_tree_host());
 
-    Layer* outer_scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* outer_scroll_layer =
+        layer_tree_host()->outer_viewport_scroll_layer();
 
     Layer* root_scroll_layer =
         CreateScrollLayer(outer_scroll_layer, &root_scroll_layer_client_);
     Layer* sibling_scroll_layer =
         CreateScrollLayer(outer_scroll_layer, &sibling_scroll_layer_client_);
     Layer* child_scroll_layer =
         CreateScrollLayer(root_scroll_layer, &child_scroll_layer_client_);
     root_scroll_layer_id_ = root_scroll_layer->id();
     sibling_scroll_layer_id_ = sibling_scroll_layer->id();
     child_scroll_layer_id_ = child_scroll_layer->id();
@@ skipping 19 matching lines @@
       case 1:
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
   virtual void DidScroll(Layer* layer) {
     if (scroll_destroy_whole_tree_) {
-      layer_tree()->RegisterViewportLayers(NULL, NULL, NULL, NULL);
-      layer_tree()->SetRootLayer(NULL);
+      layer_tree_host()->RegisterViewportLayers(NULL, NULL, NULL, NULL);
+      layer_tree_host()->SetRootLayer(NULL);
       EndTest();
       return;
     }
     layer->RemoveFromParent();
   }
 
  protected:
   class FakeLayerScrollClient {
    public:
     void DidScroll() {
@@ skipping 58 matching lines @@
         third_scroll_(20, 10),
         scroll_amount_(2, -1),
         num_commits_(0),
         num_scrolls_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->main_frame_before_activation_enabled = true;
   }
 
   void BeginTest() override {
-    outer_viewport_container_layer_id_ =
-        layer_tree()->outer_viewport_scroll_layer()->scroll_clip_layer()->id();
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    outer_viewport_container_layer_id_ = layer_tree_host()
+                                             ->outer_viewport_scroll_layer()
+                                             ->scroll_clip_layer()
+                                             ->id();
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
-    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
         base::Bind(&LayerTreeHostScrollTestScrollMFBA::DidScrollOuterViewport,
                    base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void ReadyToCommitOnThread(LayerTreeHostImpl* impl) override {
     switch (num_commits_) {
       case 1:
         // Ask for commit here because activation (and draw) will be blocked.
         impl->SetNeedsCommit();
         // Block activation after second commit until third commit is ready.
         impl->BlockNotifyReadyToActivateForTesting(true);
         break;
       case 2:
         // Unblock activation after third commit is ready.
         impl->BlockNotifyReadyToActivateForTesting(false);
         break;
     }
     num_commits_++;
   }
 
   void UpdateLayerTreeHost() override {
-    Layer* scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
         break;
       case 1:
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(initial_scroll_, scroll_amount_),
             scroll_layer->scroll_offset());
         // Pretend like Javascript updated the scroll position itself.
         scroll_layer->SetScrollOffset(second_scroll_);
@@ skipping 83 matching lines @@
         num_impl_commits_(0),
         num_aborted_commits_(0),
         num_impl_scrolls_(0),
         num_draws_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->main_frame_before_activation_enabled = true;
   }
 
   void BeginTest() override {
-    layer_tree()->outer_viewport_scroll_layer()->SetScrollOffset(
+    layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
-    layer_tree()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
         base::Bind(&LayerTreeHostScrollTestScrollAbortedCommitMFBA::
                        DidScrollOuterViewport,
                    base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
 
     gfx::Size scroll_layer_bounds(200, 200);
-    layer_tree()->outer_viewport_scroll_layer()->SetBounds(scroll_layer_bounds);
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+    layer_tree_host()->outer_viewport_scroll_layer()->SetBounds(
+        scroll_layer_bounds);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   void WillBeginMainFrame() override {
     num_will_begin_main_frames_++;
-    Layer* root_scroll_layer = layer_tree()->outer_viewport_scroll_layer();
+    Layer* root_scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     switch (num_will_begin_main_frames_) {
       case 1:
         // This will not be aborted because of the initial prop changes.
         EXPECT_EQ(0, num_impl_scrolls_);
         EXPECT_EQ(0, layer_tree_host()->SourceFrameNumber());
         EXPECT_VECTOR_EQ(initial_scroll_, root_scroll_layer->scroll_offset());
         break;
       case 2:
         // This commit will not be aborted because of the scroll change.
         EXPECT_EQ(1, num_impl_scrolls_);
@@ skipping 223 matching lines @@
                            float scale,
                            float top_controls_delta) override {
     DCHECK_NE(0, num_begin_main_frames_main_thread_)
         << "The first BeginMainFrame has no deltas to report";
     DCHECK_LT(num_begin_main_frames_main_thread_, 5);
 
     gfx::Vector2dF expected_elastic_overscroll =
         elastic_overscroll_test_cases_[num_begin_main_frames_main_thread_];
     current_elastic_overscroll_ += elastic_overscroll_delta;
     EXPECT_EQ(expected_elastic_overscroll, current_elastic_overscroll_);
-    EXPECT_EQ(expected_elastic_overscroll, layer_tree()->elastic_overscroll());
+    EXPECT_EQ(expected_elastic_overscroll,
+              layer_tree_host()->elastic_overscroll());
   }
 
   void WillBeginMainFrame() override { num_begin_main_frames_main_thread_++; }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     VerifyBeginMainFrameResultOnImplThread(host_impl, true);
   }
 
   void WillCommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 102 matching lines @@
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestElasticOverscroll);
 
 class LayerTreeHostScrollTestPropertyTreeUpdate
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestPropertyTreeUpdate()
       : initial_scroll_(10, 20), second_scroll_(0, 0) {}
 
   void BeginTest() override {
-    layer_tree()->inner_viewport_scroll_layer()->SetScrollOffset(
+    layer_tree_host()->inner_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
-    layer_tree()->inner_viewport_scroll_layer()->SetBounds(gfx::Size(100, 100));
+    layer_tree_host()->inner_viewport_scroll_layer()->SetBounds(
+        gfx::Size(100, 100));
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
-    Layer* scroll_layer = layer_tree()->inner_viewport_scroll_layer();
+    Layer* scroll_layer = layer_tree_host()->inner_viewport_scroll_layer();
     if (layer_tree_host()->SourceFrameNumber() == 0) {
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(
           gfx::ScrollOffsetWithDelta(initial_scroll_, scroll_amount_),
           scroll_layer->scroll_offset());
       scroll_layer->SetScrollOffset(second_scroll_);
       scroll_layer->SetOpacity(0.5f);
     }
   }
@@ skipping 34 matching lines @@
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::ScrollOffset second_scroll_;
   gfx::Vector2dF scroll_amount_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostScrollTestPropertyTreeUpdate);
 
 }  // namespace
 }  // namespace cc