cc: Abstract the 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 90 matching lines @@
 class LayerTreeHostTestSetNeedsCommitInsideLayout : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void UpdateLayerTreeHost() override {
     // This shouldn't cause a second commit to happen.
     layer_tree_host()->SetNeedsCommit();
   }
 
   void DidCommit() override {
-    EXPECT_EQ(1, layer_tree_host()->source_frame_number());
+    EXPECT_EQ(1, layer_tree_host()->SourceFrameNumber());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommitInsideLayout);
 
 class LayerTreeHostTestFrameOrdering : public LayerTreeHostTest {
  protected:
@@ skipping 73 matching lines @@
 class LayerTreeHostTestSetNeedsUpdateInsideLayout : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void UpdateLayerTreeHost() override {
     // This shouldn't cause a second commit to happen.
     layer_tree_host()->SetNeedsUpdateLayers();
   }
 
   void DidCommit() override {
-    EXPECT_EQ(1, layer_tree_host()->source_frame_number());
+    EXPECT_EQ(1, layer_tree_host()->SourceFrameNumber());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsUpdateInsideLayout);
 
 // Test if the LTHI receives ReadyToActivate notifications from the TileManager
 // when no raster tasks get scheduled.
@@ skipping 571 matching lines @@
     root_ = Layer::Create();
     child_ = Layer::Create();
     root_->AddChild(child_);
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // child_ should create transform, effect, clip node.
         child_->SetForceRenderSurfaceForTesting(true);
         break;
       case 2:
         // child_ should create a scroll node.
         child_->SetScrollClipLayerId(root_->id());
         break;
       case 3:
         // child_ should not create any property tree node.
@@ skipping 102 matching lines @@
     layer_tree()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     index_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         break;
       case 1:
         scoped_refptr<Layer> replica_layer = Layer::Create();
         layer_tree()->root_layer()->SetReplicaLayer(replica_layer.get());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 41 matching lines @@
     FILTER,
     END,
   };
 
   void BeginTest() override {
     index_ = OPACITY;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       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;
         break;
       default:
         EXPECT_FALSE(layer_tree()->property_trees()->needs_rebuild);
     }
   }
 
@@ skipping 70 matching lines @@
     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;
     EffectNode* node = effect_tree.Node(root_->effect_tree_index());
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         node->opacity = 0.5f;
         node->is_currently_animating_opacity = true;
         break;
       case 2:
         node->is_currently_animating_opacity = true;
         break;
       case 3:
         node->is_currently_animating_opacity = false;
         break;
@@ skipping 89 matching lines @@
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     TransformTree& transform_tree =
         layer_tree()->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()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         node->local = rotate10;
         node->is_currently_animating = true;
         break;
       case 2:
         node->is_currently_animating = true;
         break;
       case 3:
         node->is_currently_animating = false;
         break;
@@ skipping 66 matching lines @@
 
     root_->AddChild(child_);
     child_->AddChild(grand_child_);
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       gfx::Transform scale;
       scale.Scale(2.0, 2.0);
       LayerInternalsForTest(child_.get()).OnTransformAnimated(scale);
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     if (impl->sync_tree()->source_frame_number() == 0)
       PostSetNeedsCommitToMainThread();
   }
@@ skipping 50 matching lines @@
     layer_tree()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     index_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       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_NE(mask_layer->paint_properties().source_frame_number,
                   layer_tree()
                       ->root_layer()
@@ skipping 228 matching lines @@
   }
 
   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()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // SetBounds grows the layer and exposes new content.
         scaled_layer_->SetBounds(gfx::Size(4, 4));
         break;
       default:
         // No extra commits.
-        EXPECT_EQ(2, layer_tree_host()->source_frame_number());
+        EXPECT_EQ(2, layer_tree_host()->SourceFrameNumber());
     }
   }
 
   void AfterTest() override {
     EXPECT_EQ(gfx::Size(4, 4).ToString(), scaled_layer_->bounds().ToString());
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
@@ skipping 28 matching lines @@
   }
 
   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()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       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);
         break;
       default:
         // No extra commits.
-        EXPECT_EQ(2, layer_tree_host()->source_frame_number());
+        EXPECT_EQ(2, layer_tree_host()->SourceFrameNumber());
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_;
@@ skipping 17 matching lines @@
     root_layer_->AddChild(child_layer_);
 
     layer_tree()->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)
+    if (layer_tree_host()->SourceFrameNumber() == 1)
       layer_tree()->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 175 matching lines @@
         EXPECT_EQ(gfx::Rect(child_layer_->bounds()), root_damage_rect);
         break;
       default:
         NOTREACHED();
     }
 
     return draw_result;
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // Test not owning the surface.
         parent_layer_->SetOpacity(1.0f);
         break;
       case 2:
         parent_layer_->SetOpacity(0.0f);
         break;
       case 3:
         // Test owning the surface.
         parent_layer_->SetOpacity(0.5f);
@@ skipping 92 matching lines @@
         break;
       }
       default:
         NOTREACHED();
     }
 
     return draw_result;
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1: {
         // Test not owning the surface.
         child_layer_->SetOpacity(0.5f);
         break;
       }
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
@@ skipping 214 matching lines @@
         EndTest();
         break;
       case 3:
         break;
       default:
         NOTREACHED();
     }
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         layer_tree()->StartPageScaleAnimation(gfx::Vector2d(), false, 1.25f,
                                               base::TimeDelta());
         break;
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
@@ skipping 321 matching lines @@
     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);
 
     // The expectations are based on the assumption that the default
     // LCD settings are:
-    EXPECT_TRUE(layer_tree_host()->settings().can_use_lcd_text);
+    EXPECT_TRUE(layer_tree_host()->GetSettings().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()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         // Change layer opacity that should trigger lcd change.
         layer_tree()->root_layer()->SetOpacity(.5f);
         break;
       case 3:
         // Change layer opacity that should not trigger lcd change.
         layer_tree()->root_layer()->SetOpacity(1.f);
@@ skipping 168 matching lines @@
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     auto on_draw_callback = base::Bind(
         &LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
             CallOnDraw,
         base::Unretained(this));
     auto output_surface = base::MakeUnique<OnDrawOutputSurface>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
-        layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
-        false /* synchronous_composite */,
+        layer_tree_host()->GetSettings().renderer_settings,
+        ImplThreadTaskRunner(), false /* synchronous_composite */,
         false /* force_disable_reclaim_resources */,
         std::move(on_draw_callback));
     output_surface_ = output_surface.get();
     return std::move(output_surface);
   }
 
   void CallOnDraw() {
     if (!TestEnded()) {
       // Synchronous compositor does not draw unless told to do so by the output
       // surface. But it needs to be done on a new stack frame.
@@ skipping 54 matching lines @@
   void BeginTest() override {
     frame_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   // Round 1: commit + draw
   // Round 2: commit only (no draw/swap)
   // Round 3: draw only (no commit)
 
   void DidCommit() override {
-    int commit = layer_tree_host()->source_frame_number();
+    int commit = layer_tree_host()->SourceFrameNumber();
     switch (commit) {
       case 2:
         // Round 2 done.
         EXPECT_EQ(1, frame_);
         layer_tree_host()->SetNeedsRedraw();
         break;
     }
   }
 
   void DidCompleteSwapBuffers() override {
-    int commit = layer_tree_host()->source_frame_number();
+    int commit = layer_tree_host()->SourceFrameNumber();
     ++frame_;
     switch (frame_) {
       case 1:
         // Round 1 done.
         EXPECT_EQ(1, commit);
         layer_tree_host()->SetNeedsCommit();
         break;
       case 2:
         // Round 3 done.
         EXPECT_EQ(2, commit);
@@ skipping 41 matching lines @@
   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,
                    base::Unretained(this));
     auto output_surface = base::MakeUnique<OnDrawOutputSurface>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
-        layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
-        false /* synchronous_composite */,
+        layer_tree_host()->GetSettings().renderer_settings,
+        ImplThreadTaskRunner(), false /* synchronous_composite */,
         false /* force_disable_reclaim_resources */,
         std::move(on_draw_callback));
     output_surface_ = output_surface.get();
     return std::move(output_surface);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CallOnDraw() {
     if (!TestEnded()) {
@@ skipping 59 matching lines @@
  public:
   LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->renderer_settings.texture_id_allocation_chunk_size = 1;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    int frame = layer_tree_host()->source_frame_number();
+    int frame = layer_tree_host()->SourceFrameNumber();
     switch (frame) {
       case 1:
         CreateResource();
         CreateResource();
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         // Usually ScopedUIResource are deleted from the manager in their
         // destructor.  Here we just want to test that a direct call to
         // DeleteUIResource works.
@@ skipping 558 matching lines @@
     scrollbar_layer_ = FakePaintedScrollbarLayer::Create(
         paint_scrollbar, has_thumb, root_->id());
 
     root_->AddChild(scrollbar_layer_);
 
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       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();
 
@@ skipping 29 matching lines @@
   void SetupTree() override {
     root_ = PushPropertiesCountingLayer::Create();
     child_ = PushPropertiesCountingLayer::Create();
     root_->AddChild(child_);
 
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       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()));
         EXPECT_FALSE(
@@ skipping 73 matching lines @@
   size_t expected_push_properties_child_;
   size_t expected_push_properties_grandchild1_;
   size_t expected_push_properties_grandchild2_;
   size_t expected_push_properties_grandchild3_;
 };
 
 class LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
-    int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
+    int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 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_);
         EXPECT_TRUE(
             layer_tree()->LayerNeedsPushPropertiesForTesting(root_.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()));
         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;
+    int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(layer_tree()->LayerNeedsPushPropertiesForTesting(
@@ skipping 63 matching lines @@
   }
 };
 
 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;
+    int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree->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(
@@ skipping 28 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(
     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;
+    int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
@@ skipping 48 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(
     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;
+    int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
@@ skipping 44 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(
     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;
+    int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EXPECT_FALSE(
@@ skipping 111 matching lines @@
   void BeginTest() override {
     ASSERT_TRUE(invalidate_layer_)
         << "Derived tests must set this in SetupTree";
 
     // One initial commit.
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommitAndDrawFrame() override {
     // After commit, invalidate the layer.  This should cause a commit.
-    if (layer_tree_host()->source_frame_number() == 1)
+    if (layer_tree_host()->SourceFrameNumber() == 1)
       invalidate_layer_->SetNeedsDisplay();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     num_draws_++;
     if (impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 55 matching lines @@
     parent_layer_->AddChild(child_layer_);
 
     layer_tree()->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()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // The layer type used does not need to push properties every frame.
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_layer_.get()));
 
         // Change the bounds of the child layer, but make it skipped
         // by CalculateDrawProperties.
         parent_layer_->SetOpacity(0.f);
         child_layer_->SetBounds(gfx::Size(5, 5));
         break;
@@ skipping 190 matching lines @@
     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.
-    if (layer_tree_host()->source_frame_number() < 5) {
+    if (layer_tree_host()->SourceFrameNumber() < 5) {
       layer_tree_host()->SetNeedsCommit();
-    } else if (layer_tree_host()->source_frame_number() == 5) {
+    } else if (layer_tree_host()->SourceFrameNumber() == 5) {
       EndTest();
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     switch (impl->active_tree()->source_frame_number()) {
       case 1:
         EXPECT_EQ(first_output_surface_memory_limit_,
                   impl->memory_allocation_limit_bytes());
         // Lose the output surface.
@@ skipping 234 matching lines @@
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&LayerTreeHostTestKeepSwapPromise::ChangeFrame,
                               base::Unretained(this)));
   }
 
   void ChangeFrame() {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         layer_->SetBounds(gfx::Size(10, 11));
         layer_tree_host()->QueueSwapPromise(
             base::MakeUnique<TestSwapPromise>(&swap_promise_result_));
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
@@ skipping 69 matching lines @@
     layer_->SetIsDrawable(true);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_tree()->SetRootLayer(layer_);
     gfx::Size bounds(100, 100);
     layer_tree()->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) {
+    if (layer_tree_host()->SourceFrameNumber() == 0) {
       host_impl->BlockNotifyReadyToActivateForTesting(true);
     } else {
       NOTREACHED();
     }
   }
 
   void DidCommit() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostTestKeepSwapPromiseMFBA::ChangeFrame,
                    base::Unretained(this)));
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     base::AutoLock lock(swap_promise_result_.lock);
     EXPECT_FALSE(swap_promise_result_.did_not_swap_called);
     EXPECT_FALSE(swap_promise_result_.did_activate_called);
     EXPECT_FALSE(swap_promise_result_.did_swap_called);
     host_impl->BlockNotifyReadyToActivateForTesting(false);
   }
 
   void ChangeFrame() {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // Make no changes so that we abort the next commit caused by queuing
         // the swap promise.
         layer_tree_host()->QueueSwapPromise(
             base::MakeUnique<TestSwapPromise>(&swap_promise_result_));
         layer_tree_host()->SetNeedsUpdateLayers();
         break;
       case 2:
         break;
       default:
@@ skipping 191 matching lines @@
   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.
     EXPECT_TRUE(host_impl->RequiresHighResToDraw());
   }
 
   void DidCommit() override {
-    int frame = layer_tree_host()->source_frame_number();
+    int frame = layer_tree_host()->SourceFrameNumber();
     switch (frame) {
       case 1:
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         ui_resource_ = nullptr;
         EndTest();
         break;
     }
   }
@@ skipping 516 matching lines @@
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
 
   std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     bool synchronous_composite =
         !HasImplThread() &&
-        !layer_tree_host()->settings().single_thread_proxy_scheduler;
+        !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
     // Relaiming resources is parameterized for this test.
     bool force_disable_reclaim_resources = !reclaim_resources_;
     return base::MakeUnique<TestDelegatingOutputSurface>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
-        layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
-        synchronous_composite, force_disable_reclaim_resources);
+        layer_tree_host()->GetSettings().renderer_settings,
+        ImplThreadTaskRunner(), synchronous_composite,
+        force_disable_reclaim_resources);
   }
 
   void BeginTest() override {
     // Successful composite.
     std::unique_ptr<SwapPromise> swap_promise0(
         new TestSwapPromise(&swap_promise_result_[0]));
     layer_tree_host()->QueueSwapPromise(std::move(swap_promise0));
     layer_tree_host()->Composite(base::TimeTicks::Now());
 
     // Fail to swap (no damage) if not reclaiming resources from the Display.
@@ skipping 742 matching lines @@
     root->AddChild(child);
     layer_tree()->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()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
         break;
     }
   }
 
   void DidCommit() override {
     gfx::Transform transform;
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(CopyOutputCallback)));
         transform.Scale(2.0, 2.0);
         child->SetTransform(transform);
         break;
       case 2:
         // By changing the scale of a layer which already owns a transform node,
         // a commit will be triggered but a property tree rebuild will not, this
         // is used to test sure that clearing copy requestts does trigger a
@@ skipping 188 matching lines @@
                   render_pass_quad->MaskUVRect().ToString());
         EXPECT_EQ(gfx::Vector2dF(0.005f, 0.005f).ToString(),
                   render_pass_quad->mask_uv_scale.ToString());
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         gfx::Size double_root_size(200, 200);
         layer_tree()->SetViewportSize(double_root_size);
         layer_tree()->SetDeviceScaleFactor(2.f);
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 67 matching lines @@
                   render_pass_quad->MaskUVRect().ToString());
         EXPECT_EQ(gfx::Vector2dF(0.01f, 0.01f).ToString(),
                   render_pass_quad->mask_uv_scale.ToString());
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         gfx::Size double_root_size(200, 200);
         layer_tree()->SetViewportSize(double_root_size);
         layer_tree()->SetDeviceScaleFactor(2.f);
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 72 matching lines @@
                   render_pass_quad->MaskUVRect().ToString());
         EXPECT_EQ(gfx::Vector2dF(0.01f, 0.01f).ToString(),
                   render_pass_quad->mask_uv_scale.ToString());
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         gfx::Size double_root_size(200, 200);
         layer_tree()->SetViewportSize(double_root_size);
         layer_tree()->SetDeviceScaleFactor(2.f);
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 79 matching lines @@
                   replica_quad->MaskUVRect().ToString());
         EXPECT_EQ(gfx::Vector2dF(0.02f, 0.02f).ToString(),
                   replica_quad->mask_uv_scale.ToString());
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // Move the child to (-50, 0) instead. Now the mask should be moved to
         // still cover the layer being replicated.
         content_child_layer_->SetPosition(gfx::PointF(-50.f, 0.f));
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 190 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