Revert of cc: Refactor layer/tile manager unittest to extract common code.

cc/tiles/tile_manager_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/playback/raster_source.h"
 #include "cc/playback/recording_source.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "cc/test/fake_raster_source.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/fake_tile_manager.h"
 #include "cc/test/fake_tile_task_manager.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
-#include "cc/test/test_layer_tree_host_base.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_tile_priorities.h"
 #include "cc/tiles/eviction_tile_priority_queue.h"
 #include "cc/tiles/raster_tile_priority_queue.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #include "cc/tiles/tiling_set_raster_queue_all.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace cc {
 namespace {
 
-class TileManagerTilePriorityQueueTest : public TestLayerTreeHostBase {
+class LowResTilingsSettings : public LayerTreeSettings {
  public:
-  LayerTreeSettings CreateSettings() override {
-    LayerTreeSettings settings;
-    settings.create_low_res_tiling = true;
-    settings.verify_clip_tree_calculations = true;
-    return settings;
+  LowResTilingsSettings() {
+    create_low_res_tiling = true;
+    verify_clip_tree_calculations = true;
+  }
+};
+
+class TileManagerTilePriorityQueueTest : public testing::Test {
+ public:
+  TileManagerTilePriorityQueueTest()
+      : memory_limit_policy_(ALLOW_ANYTHING),
+        max_tiles_(10000),
+        ready_to_activate_(false),
+        id_(7),
+        task_runner_provider_(base::ThreadTaskRunnerHandle::Get()),
+        output_surface_(FakeOutputSurface::Create3d()),
+        host_impl_(LowResTilingsSettings(),
+                   &task_runner_provider_,
+                   &shared_bitmap_manager_,
+                   &task_graph_runner_,
+                   &gpu_memory_buffer_manager_) {}
+
+  void SetTreePriority(TreePriority tree_priority) {
+    GlobalStateThatImpactsTilePriority state;
+    gfx::Size tile_size(256, 256);
+
+    state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
+    state.num_resources_limit = max_tiles_;
+    state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
+    state.memory_limit_policy = memory_limit_policy_;
+    state.tree_priority = tree_priority;
+
+    global_state_ = state;
+    host_impl_.resource_pool()->SetResourceUsageLimits(
+        state.soft_memory_limit_in_bytes,
+        state.num_resources_limit);
+    host_impl_.tile_manager()->SetGlobalStateForTesting(state);
   }
 
-  TileManager* tile_manager() { return host_impl()->tile_manager(); }
+  void SetUp() override {
+    InitializeRenderer();
+    SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
+  }
+
+  virtual void InitializeRenderer() {
+    host_impl_.SetVisible(true);
+    host_impl_.InitializeRenderer(output_surface_.get());
+  }
+
+  void SetupDefaultTrees(const gfx::Size& layer_bounds) {
+    scoped_refptr<FakeRasterSource> pending_raster_source =
+        FakeRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeRasterSource> active_raster_source =
+        FakeRasterSource::CreateFilled(layer_bounds);
+
+    SetupTrees(pending_raster_source, active_raster_source);
+  }
+
+  // This matches picture_layer_impl_unittest's ActivateTree.
+  void ActivateTree() {
+    host_impl_.ActivateSyncTree();
+    CHECK(!host_impl_.pending_tree());
+    pending_layer_ = NULL;
+    active_layer_ = static_cast<FakePictureLayerImpl*>(
+        host_impl_.active_tree()->LayerById(id_));
+    bool update_lcd_text = false;
+    host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
+  }
+
+  void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
+                                          const gfx::Size& tile_size) {
+    SetupDefaultTrees(layer_bounds);
+    pending_layer_->set_fixed_tile_size(tile_size);
+    active_layer_->set_fixed_tile_size(tile_size);
+  }
+
+  void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+                  scoped_refptr<RasterSource> active_raster_source) {
+    SetupPendingTree(active_raster_source);
+    ActivateTree();
+    SetupPendingTree(pending_raster_source);
+  }
+
+  void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
+    host_impl_.CreatePendingTree();
+    LayerTreeImpl* pending_tree = host_impl_.pending_tree();
+
+    // Steal from the recycled tree.
+    LayerImpl* old_pending_root = pending_tree->root_layer();
+    DCHECK(!old_pending_root || old_pending_root->id() == id_);
+
+    FakePictureLayerImpl* pending_layer = nullptr;
+    if (old_pending_root) {
+      pending_layer = static_cast<FakePictureLayerImpl*>(old_pending_root);
+      pending_layer->SetRasterSourceOnPending(raster_source, Region());
+    } else {
+      std::unique_ptr<FakePictureLayerImpl> new_root =
+          FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
+                                                       raster_source);
+      pending_layer = new_root.get();
+      pending_tree->SetRootLayer(std::move(new_root));
+      pending_layer->SetDrawsContent(true);
+      pending_layer->SetHasRenderSurface(true);
+    }
+    // The bounds() just mirror the raster source size.
+    pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
+
+    pending_layer_ = static_cast<FakePictureLayerImpl*>(
+        host_impl_.pending_tree()->LayerById(id_));
+
+    // Add tilings/tiles for the layer.
+    bool update_lcd_text = false;
+    host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+    host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
+  }
+
+  TileManager* tile_manager() { return host_impl_.tile_manager(); }
+
+ protected:
+  GlobalStateThatImpactsTilePriority global_state_;
+
+  TestSharedBitmapManager shared_bitmap_manager_;
+  TestTaskGraphRunner task_graph_runner_;
+  TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
+  TileMemoryLimitPolicy memory_limit_policy_;
+  int max_tiles_;
+  bool ready_to_activate_;
+  int id_;
+  FakeImplTaskRunnerProvider task_runner_provider_;
+  std::unique_ptr<OutputSurface> output_surface_;
+  FakeLayerTreeHostImpl host_impl_;
+  FakePictureLayerImpl* pending_layer_;
+  FakePictureLayerImpl* active_layer_;
 };
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_tiles;
   while (!queue->IsEmpty()) {
     EXPECT_TRUE(queue->Top().tile());
     all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   // Sanity check, all tiles should be visible.
   std::set<Tile*> smoothness_tiles;
-  queue = host_impl()->BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
-                                        RasterTilePriorityQueue::Type::ALL);
+  queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+                                      RasterTilePriorityQueue::Type::ALL);
   bool had_low_res = false;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile());
     EXPECT_EQ(TilePriority::NOW, prioritized_tile.priority().priority_bin);
     if (prioritized_tile.priority().resolution == LOW_RESOLUTION)
       had_low_res = true;
     else
       smoothness_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
   EXPECT_TRUE(had_low_res);
 
   // Check that everything is required for activation.
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   std::set<Tile*> required_for_activation_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
     required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, required_for_activation_tiles);
 
   // Check that everything is required for draw.
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   std::set<Tile*> required_for_draw_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
     required_for_draw_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, required_for_draw_tiles);
 
   Region invalidation(gfx::Rect(0, 0, 500, 500));
 
   // Invalidate the pending tree.
-  pending_layer()->set_invalidation(invalidation);
-  pending_layer()->HighResTiling()->Invalidate(invalidation);
+  pending_layer_->set_invalidation(invalidation);
+  pending_layer_->HighResTiling()->Invalidate(invalidation);
 
   // Renew all of the tile priorities.
   gfx::Rect viewport(50, 50, 100, 100);
-  pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
-  active_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  active_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
 
   // Populate all tiles directly from the tilings.
   all_tiles.clear();
   std::set<Tile*> high_res_tiles;
   std::vector<Tile*> pending_high_res_tiles =
-      pending_layer()->HighResTiling()->AllTilesForTesting();
+      pending_layer_->HighResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i) {
     all_tiles.insert(pending_high_res_tiles[i]);
     high_res_tiles.insert(pending_high_res_tiles[i]);
   }
 
   std::vector<Tile*> active_high_res_tiles =
-      active_layer()->HighResTiling()->AllTilesForTesting();
+      active_layer_->HighResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < active_high_res_tiles.size(); ++i) {
     all_tiles.insert(active_high_res_tiles[i]);
     high_res_tiles.insert(active_high_res_tiles[i]);
   }
 
   std::vector<Tile*> active_low_res_tiles =
-      active_layer()->LowResTiling()->AllTilesForTesting();
+      active_layer_->LowResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
     all_tiles.insert(active_low_res_tiles[i]);
 
   PrioritizedTile last_tile;
   smoothness_tiles.clear();
   tile_count = 0;
   size_t correct_order_tiles = 0u;
   // Here we expect to get increasing ACTIVE_TREE priority_bin.
-  queue = host_impl()->BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
-                                        RasterTilePriorityQueue::Type::ALL);
+  queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+                                      RasterTilePriorityQueue::Type::ALL);
   std::set<Tile*> expected_required_for_draw_tiles;
   std::set<Tile*> expected_required_for_activation_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile());
 
     if (!last_tile.tile())
       last_tile = prioritized_tile;
 
     EXPECT_LE(last_tile.priority().priority_bin,
@@ skipping 28 matching lines @@
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, smoothness_tiles.size());
   EXPECT_EQ(all_tiles, smoothness_tiles);
   // Since we don't guarantee increasing distance due to spiral iterator, we
   // should check that we're _mostly_ right.
   EXPECT_GT(correct_order_tiles, 3 * tile_count / 4);
 
   // Check that we have consistent required_for_activation tiles.
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   required_for_activation_tiles.clear();
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
     required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_activation_tiles,
             required_for_activation_tiles);
   EXPECT_NE(all_tiles, required_for_activation_tiles);
 
   // Check that we have consistent required_for_draw tiles.
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   required_for_draw_tiles.clear();
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
     required_for_draw_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
   EXPECT_NE(all_tiles, required_for_draw_tiles);
 
   std::set<Tile*> new_content_tiles;
   last_tile = PrioritizedTile();
   size_t increasing_distance_tiles = 0u;
   // Here we expect to get increasing PENDING_TREE priority_bin.
-  queue = host_impl()->BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
-                                        RasterTilePriorityQueue::Type::ALL);
+  queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
+                                      RasterTilePriorityQueue::Type::ALL);
   tile_count = 0;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile());
 
     if (!last_tile.tile())
       last_tile = prioritized_tile;
 
     EXPECT_LE(last_tile.priority().priority_bin,
               prioritized_tile.priority().priority_bin);
@@ skipping 17 matching lines @@
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(high_res_tiles, new_content_tiles);
   // Since we don't guarantee increasing distance due to spiral iterator, we
   // should check that we're _mostly_ right.
   EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
 
   // Check that we have consistent required_for_activation tiles.
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       NEW_CONTENT_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   required_for_activation_tiles.clear();
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
     required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_activation_tiles,
             required_for_activation_tiles);
   EXPECT_NE(new_content_tiles, required_for_activation_tiles);
 
   // Check that we have consistent required_for_draw tiles.
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       NEW_CONTENT_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   required_for_draw_tiles.clear();
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
     required_for_draw_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
   EXPECT_NE(new_content_tiles, required_for_draw_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueHighNonIdealTilings) {
   const gfx::Size layer_bounds(1000, 1000);
   const gfx::Size viewport(800, 800);
-  host_impl()->SetViewportSize(viewport);
+  host_impl_.SetViewportSize(viewport);
   SetupDefaultTrees(layer_bounds);
 
-  pending_layer()->tilings()->AddTiling(1.5f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.5f, active_layer()->raster_source());
-  pending_layer()->tilings()->AddTiling(1.7f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
+  pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
+  pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
 
-  pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
-                                                   5.0, Occlusion(), true);
-  active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+  pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
+  active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+                                                 Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
-  for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     if (tiling->contents_scale() == 1.f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
     }
   }
 
-  for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
     if (tiling->contents_scale() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
       // Non ideal tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
       if (tiling->contents_scale() == 1.f) {
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_actual_tiles;
   while (!queue->IsEmpty()) {
     EXPECT_TRUE(queue->Top().tile());
     all_actual_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_actual_tiles.size());
   EXPECT_EQ(all_expected_tiles.size(), all_actual_tiles.size());
   EXPECT_EQ(all_expected_tiles, all_actual_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueHighLowTilings) {
   const gfx::Size layer_bounds(1000, 1000);
   const gfx::Size viewport(800, 800);
-  host_impl()->SetViewportSize(viewport);
+  host_impl_.SetViewportSize(viewport);
   SetupDefaultTrees(layer_bounds);
 
-  pending_layer()->tilings()->AddTiling(1.5f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.5f, active_layer()->raster_source());
-  pending_layer()->tilings()->AddTiling(1.7f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
+  pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
+  pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
 
-  pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
-                                                   5.0, Occlusion(), true);
-  active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+  pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
+  active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+                                                 Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
-  for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     if (tiling->contents_scale() == 1.f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
     }
   }
 
-  for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
     if (tiling->contents_scale() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(LOW_RESOLUTION);
       // Low res tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
       if (tiling->contents_scale() == 1.f) {
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_actual_tiles;
   while (!queue->IsEmpty()) {
     EXPECT_TRUE(queue->Top().tile());
     all_actual_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_actual_tiles.size());
   EXPECT_EQ(all_expected_tiles.size(), all_actual_tiles.size());
   EXPECT_EQ(all_expected_tiles, all_actual_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(gfx::Size(500, 500));
+  host_impl_.SetViewportSize(gfx::Size(500, 500));
   SetupDefaultTrees(layer_bounds);
 
   // Use a tile's content rect as an invalidation. We should inset it a bit to
   // ensure that border math doesn't invalidate neighbouring tiles.
   gfx::Rect invalidation =
-      active_layer()->HighResTiling()->TileAt(1, 0)->content_rect();
+      active_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
   invalidation.Inset(2, 2);
 
-  pending_layer()->set_invalidation(invalidation);
-  pending_layer()->HighResTiling()->Invalidate(invalidation);
-  pending_layer()->HighResTiling()->CreateMissingTilesInLiveTilesRect();
+  pending_layer_->set_invalidation(invalidation);
+  pending_layer_->HighResTiling()->Invalidate(invalidation);
+  pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
 
   // Sanity checks: Tile at 0, 0 not exist on the pending tree (it's not
   // invalidated). Tile 1, 0 should exist on both.
-  EXPECT_FALSE(pending_layer()->HighResTiling()->TileAt(0, 0));
-  EXPECT_TRUE(active_layer()->HighResTiling()->TileAt(0, 0));
-  EXPECT_TRUE(pending_layer()->HighResTiling()->TileAt(1, 0));
-  EXPECT_TRUE(active_layer()->HighResTiling()->TileAt(1, 0));
-  EXPECT_NE(pending_layer()->HighResTiling()->TileAt(1, 0),
-            active_layer()->HighResTiling()->TileAt(1, 0));
+  EXPECT_FALSE(pending_layer_->HighResTiling()->TileAt(0, 0));
+  EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(0, 0));
+  EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(1, 0));
+  EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(1, 0));
+  EXPECT_NE(pending_layer_->HighResTiling()->TileAt(1, 0),
+            active_layer_->HighResTiling()->TileAt(1, 0));
 
   std::set<Tile*> expected_now_tiles;
   std::set<Tile*> expected_required_for_draw_tiles;
   std::set<Tile*> expected_required_for_activation_tiles;
   for (int i = 0; i <= 1; ++i) {
     for (int j = 0; j <= 1; ++j) {
       bool have_pending_tile = false;
-      if (pending_layer()->HighResTiling()->TileAt(i, j)) {
+      if (pending_layer_->HighResTiling()->TileAt(i, j)) {
         expected_now_tiles.insert(
-            pending_layer()->HighResTiling()->TileAt(i, j));
+            pending_layer_->HighResTiling()->TileAt(i, j));
         expected_required_for_activation_tiles.insert(
-            pending_layer()->HighResTiling()->TileAt(i, j));
+            pending_layer_->HighResTiling()->TileAt(i, j));
         have_pending_tile = true;
       }
-      Tile* active_tile = active_layer()->HighResTiling()->TileAt(i, j);
+      Tile* active_tile = active_layer_->HighResTiling()->TileAt(i, j);
       EXPECT_TRUE(active_tile);
       expected_now_tiles.insert(active_tile);
       expected_required_for_draw_tiles.insert(active_tile);
       if (!have_pending_tile)
         expected_required_for_activation_tiles.insert(active_tile);
     }
   }
   // Expect 3 shared tiles and 1 unshared tile in total.
   EXPECT_EQ(5u, expected_now_tiles.size());
   // Expect 4 tiles for each draw and activation, but not all the same.
   EXPECT_EQ(4u, expected_required_for_activation_tiles.size());
   EXPECT_EQ(4u, expected_required_for_draw_tiles.size());
   EXPECT_NE(expected_required_for_draw_tiles,
             expected_required_for_activation_tiles);
 
   std::set<Tile*> expected_all_tiles;
   for (int i = 0; i <= 3; ++i) {
     for (int j = 0; j <= 3; ++j) {
-      if (pending_layer()->HighResTiling()->TileAt(i, j))
+      if (pending_layer_->HighResTiling()->TileAt(i, j))
         expected_all_tiles.insert(
-            pending_layer()->HighResTiling()->TileAt(i, j));
-      EXPECT_TRUE(active_layer()->HighResTiling()->TileAt(i, j));
-      expected_all_tiles.insert(active_layer()->HighResTiling()->TileAt(i, j));
+            pending_layer_->HighResTiling()->TileAt(i, j));
+      EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(i, j));
+      expected_all_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
     }
   }
   // Expect 15 shared tiles and 1 unshared tile.
   EXPECT_EQ(17u, expected_all_tiles.size());
 
   // The actual test will now build different queues and verify that the queues
   // return the same information as computed manually above.
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   std::set<Tile*> actual_now_tiles;
   std::set<Tile*> actual_all_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     queue->Pop();
     if (prioritized_tile.priority().priority_bin == TilePriority::NOW)
       actual_now_tiles.insert(prioritized_tile.tile());
     actual_all_tiles.insert(prioritized_tile.tile());
   }
   EXPECT_EQ(expected_now_tiles, actual_now_tiles);
   EXPECT_EQ(expected_all_tiles, actual_all_tiles);
 
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   std::set<Tile*> actual_required_for_draw_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     queue->Pop();
     actual_required_for_draw_tiles.insert(prioritized_tile.tile());
   }
   EXPECT_EQ(expected_required_for_draw_tiles, actual_required_for_draw_tiles);
 
-  queue = host_impl()->BuildRasterQueue(
+  queue = host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   std::set<Tile*> actual_required_for_activation_tiles;
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top().tile();
     queue->Pop();
     actual_required_for_activation_tiles.insert(tile);
   }
   EXPECT_EQ(expected_required_for_activation_tiles,
             actual_required_for_activation_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
   SetupDefaultTrees(layer_bounds);
 
   // Create a pending child layer.
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   std::unique_ptr<FakePictureLayerImpl> pending_child =
       FakePictureLayerImpl::CreateWithRasterSource(
-          host_impl()->pending_tree(), layer_id() + 1, pending_raster_source);
+          host_impl_.pending_tree(), id_ + 1, pending_raster_source);
   FakePictureLayerImpl* pending_child_raw = pending_child.get();
   pending_child_raw->SetDrawsContent(true);
-  pending_layer()->AddChild(std::move(pending_child));
+  pending_layer_->AddChild(std::move(pending_child));
 
   // Set a small viewport, so we have soon and eventually tiles.
-  host_impl()->SetViewportSize(gfx::Size(200, 200));
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.SetViewportSize(gfx::Size(200, 200));
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
-  host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
-  host_impl()->pending_tree()->BuildPropertyTreesForTesting();
-  host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_.pending_tree()->property_trees()->needs_rebuild = true;
+  host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+  host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
-  host_impl()->SetRequiresHighResToDraw();
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  host_impl_.SetRequiresHighResToDraw();
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   // Get all the tiles that are NOW or SOON and make sure they are ready to
   // draw.
   std::vector<Tile*> all_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     if (prioritized_tile.priority().priority_bin >= TilePriority::EVENTUALLY)
       break;
 
     all_tiles.push_back(prioritized_tile.tile());
     queue->Pop();
   }
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   // Ensure we can activate.
   EXPECT_TRUE(tile_manager()->IsReadyToActivate());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
-  ASSERT_TRUE(active_layer()->HighResTiling());
-  ASSERT_TRUE(active_layer()->LowResTiling());
-  ASSERT_TRUE(pending_layer()->HighResTiling());
-  EXPECT_FALSE(pending_layer()->LowResTiling());
+  ASSERT_TRUE(active_layer_->HighResTiling());
+  ASSERT_TRUE(active_layer_->LowResTiling());
+  ASSERT_TRUE(pending_layer_->HighResTiling());
+  EXPECT_FALSE(pending_layer_->LowResTiling());
 
   std::unique_ptr<EvictionTilePriorityQueue> empty_queue(
-      host_impl()->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+      host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
   EXPECT_TRUE(empty_queue->IsEmpty());
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
 
   std::unique_ptr<RasterTilePriorityQueue> raster_queue(
-      host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
-                                    RasterTilePriorityQueue::Type::ALL));
+      host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+                                  RasterTilePriorityQueue::Type::ALL));
   while (!raster_queue->IsEmpty()) {
     ++tile_count;
     EXPECT_TRUE(raster_queue->Top().tile());
     all_tiles.insert(raster_queue->Top().tile());
     raster_queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   std::unique_ptr<EvictionTilePriorityQueue> queue(
-      host_impl()->BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
+      host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
   EXPECT_FALSE(queue->IsEmpty());
 
   // Sanity check, all tiles should be visible.
   std::set<Tile*> smoothness_tiles;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile());
     EXPECT_EQ(TilePriority::NOW, prioritized_tile.priority().priority_bin);
     EXPECT_TRUE(prioritized_tile.tile()->draw_info().has_resource());
     smoothness_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   tile_manager()->ReleaseTileResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   Region invalidation(gfx::Rect(0, 0, 500, 500));
 
   // Invalidate the pending tree.
-  pending_layer()->set_invalidation(invalidation);
-  pending_layer()->HighResTiling()->Invalidate(invalidation);
-  pending_layer()->HighResTiling()->CreateMissingTilesInLiveTilesRect();
-  EXPECT_FALSE(pending_layer()->LowResTiling());
+  pending_layer_->set_invalidation(invalidation);
+  pending_layer_->HighResTiling()->Invalidate(invalidation);
+  pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
+  EXPECT_FALSE(pending_layer_->LowResTiling());
 
   // Renew all of the tile priorities.
   gfx::Rect viewport(50, 50, 100, 100);
-  pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
-  active_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  active_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
 
   // Populate all tiles directly from the tilings.
   all_tiles.clear();
   std::vector<Tile*> pending_high_res_tiles =
-      pending_layer()->HighResTiling()->AllTilesForTesting();
+      pending_layer_->HighResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
     all_tiles.insert(pending_high_res_tiles[i]);
 
   std::vector<Tile*> active_high_res_tiles =
-      active_layer()->HighResTiling()->AllTilesForTesting();
+      active_layer_->HighResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
     all_tiles.insert(active_high_res_tiles[i]);
 
   std::vector<Tile*> active_low_res_tiles =
-      active_layer()->LowResTiling()->AllTilesForTesting();
+      active_layer_->LowResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
     all_tiles.insert(active_low_res_tiles[i]);
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   PrioritizedTile last_tile;
   smoothness_tiles.clear();
   tile_count = 0;
   // Here we expect to get increasing combined priority_bin.
-  queue = host_impl()->BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
+  queue = host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
   int distance_increasing = 0;
   int distance_decreasing = 0;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
     EXPECT_TRUE(tile);
     EXPECT_TRUE(tile->draw_info().has_resource());
 
     if (!last_tile.tile())
       last_tile = prioritized_tile;
@@ skipping 22 matching lines @@
 
   // Ensure that the distance is decreasing many more times than increasing.
   EXPECT_EQ(3, distance_increasing);
   EXPECT_EQ(16, distance_decreasing);
   EXPECT_EQ(tile_count, smoothness_tiles.size());
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   std::set<Tile*> new_content_tiles;
   last_tile = PrioritizedTile();
   // Again, we expect to get increasing combined priority_bin.
-  queue = host_impl()->BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
+  queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
   distance_decreasing = 0;
   distance_increasing = 0;
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
     EXPECT_TRUE(tile);
 
     if (!last_tile.tile())
       last_tile = prioritized_tile;
 
@@ skipping 20 matching lines @@
 
   // Ensure that the distance is decreasing many more times than increasing.
   EXPECT_EQ(3, distance_increasing);
   EXPECT_EQ(16, distance_decreasing);
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        EvictionTilePriorityQueueWithOcclusion) {
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
 
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTree(pending_raster_source);
 
   std::unique_ptr<FakePictureLayerImpl> pending_child =
-      FakePictureLayerImpl::CreateWithRasterSource(host_impl()->pending_tree(),
-                                                   2, pending_raster_source);
-  pending_layer()->AddChild(std::move(pending_child));
+      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
+                                                   pending_raster_source);
+  pending_layer_->AddChild(std::move(pending_child));
 
   FakePictureLayerImpl* pending_child_layer =
-      static_cast<FakePictureLayerImpl*>(pending_layer()->children()[0]);
+      static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
   pending_child_layer->SetDrawsContent(true);
 
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
-  host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
-  host_impl()->pending_tree()->BuildPropertyTreesForTesting();
-  host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_.pending_tree()->property_trees()->needs_rebuild = true;
+  host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+  host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   ActivateTree();
   SetupPendingTree(pending_raster_source);
 
   FakePictureLayerImpl* active_child_layer =
-      static_cast<FakePictureLayerImpl*>(active_layer()->children()[0]);
+      static_cast<FakePictureLayerImpl*>(active_layer_->children()[0]);
 
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
   std::unique_ptr<RasterTilePriorityQueue> raster_queue(
-      host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
-                                    RasterTilePriorityQueue::Type::ALL));
+      host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+                                  RasterTilePriorityQueue::Type::ALL));
   while (!raster_queue->IsEmpty()) {
     ++tile_count;
     EXPECT_TRUE(raster_queue->Top().tile());
     all_tiles.insert(raster_queue->Top().tile());
     raster_queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(32u, tile_count);
 
   // Renew all of the tile priorities.
   gfx::Rect viewport(layer_bounds);
-  pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
   pending_child_layer->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
 
-  active_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  active_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
   active_child_layer->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
 
   // Populate all tiles directly from the tilings.
   all_tiles.clear();
   std::vector<Tile*> pending_high_res_tiles =
-      pending_layer()->HighResTiling()->AllTilesForTesting();
+      pending_layer_->HighResTiling()->AllTilesForTesting();
   all_tiles.insert(pending_high_res_tiles.begin(),
                    pending_high_res_tiles.end());
 
   // Set all tiles on the pending_child_layer as occluded on the pending tree.
   std::vector<Tile*> pending_child_high_res_tiles =
       pending_child_layer->HighResTiling()->AllTilesForTesting();
   pending_child_layer->HighResTiling()->SetAllTilesOccludedForTesting();
   active_child_layer->HighResTiling()->SetAllTilesOccludedForTesting();
   active_child_layer->LowResTiling()->SetAllTilesOccludedForTesting();
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   // Verify occlusion is considered by EvictionTilePriorityQueue.
   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
   size_t occluded_count = 0u;
   PrioritizedTile last_tile;
   std::unique_ptr<EvictionTilePriorityQueue> queue(
-      host_impl()->BuildEvictionQueue(tree_priority));
+      host_impl_.BuildEvictionQueue(tree_priority));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     if (!last_tile.tile())
       last_tile = prioritized_tile;
 
     bool tile_is_occluded = prioritized_tile.is_occluded();
 
     // The only way we will encounter an occluded tile after an unoccluded
     // tile is if the priorty bin decreased, the tile is required for
     // activation, or the scale changed.
@@ skipping 15 matching lines @@
     }
     last_tile = prioritized_tile;
     queue->Pop();
   }
   size_t expected_occluded_count = pending_child_high_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        EvictionTilePriorityQueueWithTransparentLayer) {
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTree(pending_raster_source);
 
   std::unique_ptr<FakePictureLayerImpl> pending_child =
-      FakePictureLayerImpl::CreateWithRasterSource(host_impl()->pending_tree(),
-                                                   2, pending_raster_source);
+      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
+                                                   pending_raster_source);
   FakePictureLayerImpl* pending_child_layer = pending_child.get();
-  pending_layer()->AddChild(std::move(pending_child));
+  pending_layer_->AddChild(std::move(pending_child));
 
   // Create a fully transparent child layer so that its tile priorities are not
   // considered to be valid.
   pending_child_layer->SetDrawsContent(true);
   pending_child_layer->test_properties()->force_render_surface = true;
 
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
-  host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
-  host_impl()->pending_tree()->BuildPropertyTreesForTesting();
-  host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_.pending_tree()->property_trees()->needs_rebuild = true;
+  host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+  host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   pending_child_layer->OnOpacityAnimated(0.0);
 
-  host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-  host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+  host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   // Renew all of the tile priorities.
   gfx::Rect viewport(layer_bounds);
-  pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+  pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
   pending_child_layer->picture_layer_tiling_set()->UpdateTilePriorities(
       viewport, 1.0f, 1.0, Occlusion(), true);
 
   // Populate all tiles directly from the tilings.
   std::set<Tile*> all_pending_tiles;
   std::vector<Tile*> pending_high_res_tiles =
-      pending_layer()->HighResTiling()->AllTilesForTesting();
+      pending_layer_->HighResTiling()->AllTilesForTesting();
   all_pending_tiles.insert(pending_high_res_tiles.begin(),
                            pending_high_res_tiles.end());
   EXPECT_EQ(16u, pending_high_res_tiles.size());
 
   std::set<Tile*> all_pending_child_tiles;
   std::vector<Tile*> pending_child_high_res_tiles =
       pending_child_layer->HighResTiling()->AllTilesForTesting();
   all_pending_child_tiles.insert(pending_child_high_res_tiles.begin(),
                                  pending_child_high_res_tiles.end());
   EXPECT_EQ(16u, pending_child_high_res_tiles.size());
 
   std::set<Tile*> all_tiles = all_pending_tiles;
   all_tiles.insert(all_pending_child_tiles.begin(),
                    all_pending_child_tiles.end());
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
-  EXPECT_TRUE(pending_layer()->HasValidTilePriorities());
+  EXPECT_TRUE(pending_layer_->HasValidTilePriorities());
   EXPECT_FALSE(pending_child_layer->HasValidTilePriorities());
 
   // Verify that eviction queue returns tiles also from layers without valid
   // tile priorities and that the tile priority bin of those tiles is (at most)
   // EVENTUALLY.
   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
   std::set<Tile*> new_content_tiles;
   size_t tile_count = 0;
   std::unique_ptr<EvictionTilePriorityQueue> queue(
-      host_impl()->BuildEvictionQueue(tree_priority));
+      host_impl_.BuildEvictionQueue(tree_priority));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
     const TilePriority& pending_priority = prioritized_tile.priority();
     EXPECT_NE(std::numeric_limits<float>::infinity(),
               pending_priority.distance_to_visible);
     if (all_pending_child_tiles.find(tile) != all_pending_child_tiles.end())
       EXPECT_EQ(TilePriority::EVENTUALLY, pending_priority.priority_bin);
     else
       EXPECT_EQ(TilePriority::NOW, pending_priority.priority_bin);
     new_content_tiles.insert(tile);
     ++tile_count;
     queue->Pop();
   }
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_tiles;
   while (!queue->IsEmpty()) {
     EXPECT_TRUE(queue->Top().tile());
     all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   for (int i = 1; i < 10; ++i) {
-    std::unique_ptr<FakePictureLayerImpl> pending_child_layer =
-        FakePictureLayerImpl::Create(host_impl()->pending_tree(),
-                                     layer_id() + i);
-    pending_child_layer->SetDrawsContent(true);
-    pending_child_layer->set_has_valid_tile_priorities(true);
-    pending_layer()->AddChild(std::move(pending_child_layer));
+    std::unique_ptr<FakePictureLayerImpl> pending_layer =
+        FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
+    pending_layer->SetDrawsContent(true);
+    pending_layer->set_has_valid_tile_priorities(true);
+    pending_layer_->AddChild(std::move(pending_layer));
   }
 
-  queue = host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
-                                        RasterTilePriorityQueue::Type::ALL);
+  queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+                                      RasterTilePriorityQueue::Type::ALL);
   EXPECT_FALSE(queue->IsEmpty());
 
   tile_count = 0;
   all_tiles.clear();
   while (!queue->IsEmpty()) {
     EXPECT_TRUE(queue->Top().tile());
     all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   std::unique_ptr<RasterTilePriorityQueue> raster_queue(
-      host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
-                                    RasterTilePriorityQueue::Type::ALL));
+      host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+                                  RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(raster_queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_tiles;
   while (!raster_queue->IsEmpty()) {
     EXPECT_TRUE(raster_queue->Top().tile());
     all_tiles.insert(raster_queue->Top().tile());
     ++tile_count;
     raster_queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
-  host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
+  host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   for (int i = 1; i < 10; ++i) {
-    std::unique_ptr<FakePictureLayerImpl> pending_child_layer =
-        FakePictureLayerImpl::Create(host_impl()->pending_tree(),
-                                     layer_id() + i);
-    pending_child_layer->SetDrawsContent(true);
-    pending_child_layer->set_has_valid_tile_priorities(true);
-    pending_layer()->AddChild(std::move(pending_child_layer));
+    std::unique_ptr<FakePictureLayerImpl> pending_layer =
+        FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
+    pending_layer->SetDrawsContent(true);
+    pending_layer->set_has_valid_tile_priorities(true);
+    pending_layer_->AddChild(std::move(pending_layer));
   }
 
   std::unique_ptr<EvictionTilePriorityQueue> queue(
-      host_impl()->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+      host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
   EXPECT_FALSE(queue->IsEmpty());
 
   tile_count = 0;
   all_tiles.clear();
   while (!queue->IsEmpty()) {
     EXPECT_TRUE(queue->Top().tile());
     all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
@@ skipping 185 matching lines @@
   EXPECT_GT(eventually_bin_order_correct_count,
             eventually_bin_order_incorrect_count);
 
   EXPECT_TRUE(have_tiles[TilePriority::NOW]);
   EXPECT_TRUE(have_tiles[TilePriority::SOON]);
   EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, SetIsLikelyToRequireADraw) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
 
-  EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
-  EXPECT_TRUE(host_impl()->is_likely_to_require_a_draw());
+  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+  host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+  EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
 
-  ManagedMemoryPolicy policy = host_impl()->ActualManagedMemoryPolicy();
+  ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
   policy.bytes_limit_when_visible = 0;
-  host_impl()->SetMemoryPolicy(policy);
+  host_impl_.SetMemoryPolicy(policy);
 
-  EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
-  EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
+  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+  host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
   EXPECT_EQ(gfx::Size(256, 256), queue->Top().tile()->desired_texture_size());
-  EXPECT_EQ(RGBA_8888, host_impl()->resource_provider()->best_texture_format());
+  EXPECT_EQ(RGBA_8888, host_impl_.resource_provider()->best_texture_format());
 
-  ManagedMemoryPolicy policy = host_impl()->ActualManagedMemoryPolicy();
+  ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
   policy.bytes_limit_when_visible = ResourceUtil::UncheckedSizeInBytes<size_t>(
       gfx::Size(256, 256), RGBA_8888);
-  host_impl()->SetMemoryPolicy(policy);
+  host_impl_.SetMemoryPolicy(policy);
 
-  EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
-  EXPECT_TRUE(host_impl()->is_likely_to_require_a_draw());
+  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+  host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+  EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
 
-  Resource* resource = host_impl()->resource_pool()->AcquireResource(
+  Resource* resource = host_impl_.resource_pool()->AcquireResource(
       gfx::Size(256, 256), RGBA_8888);
 
-  host_impl()->tile_manager()->CheckIfMoreTilesNeedToBePreparedForTesting();
-  EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
+  host_impl_.tile_manager()->CheckIfMoreTilesNeedToBePreparedForTesting();
+  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
 
-  host_impl()->resource_pool()->ReleaseResource(resource, 0);
+  host_impl_.resource_pool()->ReleaseResource(resource, 0);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, DefaultMemoryPolicy) {
   const gfx::Size layer_bounds(1000, 1000);
-  host_impl()->SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
 
   // 64MB is the default mem limit.
   EXPECT_EQ(67108864u,
-            host_impl()->global_tile_state().hard_memory_limit_in_bytes);
+            host_impl_.global_tile_state().hard_memory_limit_in_bytes);
   EXPECT_EQ(TileMemoryLimitPolicy::ALLOW_ANYTHING,
-            host_impl()->global_tile_state().memory_limit_policy);
+            host_impl_.global_tile_state().memory_limit_policy);
   EXPECT_EQ(ManagedMemoryPolicy::kDefaultNumResourcesLimit,
-            host_impl()->global_tile_state().num_resources_limit);
+            host_impl_.global_tile_state().num_resources_limit);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterQueueAllUsesCorrectTileBounds) {
   // Verify that we use the real tile bounds when advancing phases during the
   // tile iteration.
   gfx::Size layer_bounds(1, 1);
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
@@ skipping 70 matching lines @@
                                              non_solid_paint);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   FakePictureLayerTilingClient tiling_client;
   tiling_client.SetTileSize(size);
 
   std::unique_ptr<PictureLayerImpl> layer_impl =
-      PictureLayerImpl::Create(host_impl()->active_tree(), 1, false);
+      PictureLayerImpl::Create(host_impl_.active_tree(), 1, false);
   layer_impl->set_is_drawn_render_surface_layer_list_member(true);
   PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
 
   PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
   tiling->SetTilePriorityRectsForTesting(
       gfx::Rect(layer_bounds),   // Visible rect.
       gfx::Rect(layer_bounds),   // Skewport rect.
       gfx::Rect(layer_bounds),   // Soon rect.
       gfx::Rect(layer_bounds));  // Eventually rect.
 
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
 
   std::vector<Tile*> tiles = tiling->AllTilesForTesting();
   for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
     Tile* tile = tiles[tile_idx];
     if (tile->id() == 1) {
       // Non-solid tile.
       EXPECT_TRUE(tile->HasRasterTask());
       EXPECT_EQ(TileDrawInfo::RESOURCE_MODE, tile->draw_info().mode());
     } else {
       EXPECT_FALSE(tile->HasRasterTask());
       EXPECT_EQ(TileDrawInfo::SOLID_COLOR_MODE, tile->draw_info().mode());
       EXPECT_EQ(solid_color, tile->draw_info().solid_color());
     }
   }
 }
 
-class TileManagerTest : public TestLayerTreeHostBase {
+// TODO(vmpstr): Merge TileManagerTest and TileManagerTilePriorityQueueTest.
+class TileManagerTest : public testing::Test {
  public:
+  void SetUp() override {
+    LayerTreeSettings settings;
+    settings.verify_clip_tree_calculations = true;
+
+    CustomizeSettings(&settings);
+    output_surface_ = GetOutputSurface();
+    task_graph_runner_ = GetTaskGraphRunner();
+    host_impl_.reset(new MockLayerTreeHostImpl(settings, &task_runner_provider_,
+                                               &shared_bitmap_manager_,
+                                               task_graph_runner_.get()));
+    host_impl_->SetVisible(true);
+    host_impl_->InitializeRenderer(output_surface_.get());
+  }
+
+  void SetupDefaultTrees(const gfx::Size& layer_bounds) {
+    scoped_refptr<FakeRasterSource> pending_raster_source =
+        FakeRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeRasterSource> active_raster_source =
+        FakeRasterSource::CreateFilled(layer_bounds);
+
+    SetupTrees(pending_raster_source, active_raster_source);
+  }
+
+  // This matches picture_layer_impl_unittest's ActivateTree.
+  void ActivateTree() {
+    host_impl_->ActivateSyncTree();
+    CHECK(!host_impl_->pending_tree());
+    bool update_lcd_text = false;
+    host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  }
+
+  void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+                  scoped_refptr<RasterSource> active_raster_source) {
+    SetupPendingTree(active_raster_source);
+    ActivateTree();
+    SetupPendingTree(pending_raster_source);
+  }
+
+  void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
+    host_impl_->CreatePendingTree();
+    LayerTreeImpl* pending_tree = host_impl_->pending_tree();
+
+    // Steal from the recycled tree.
+    LayerImpl* old_pending_root = pending_tree->root_layer();
+    FakePictureLayerImpl* pending_layer = nullptr;
+    if (old_pending_root) {
+      pending_layer = static_cast<FakePictureLayerImpl*>(old_pending_root);
+      pending_layer->SetRasterSourceOnPending(raster_source, Region());
+    } else {
+      int id = 7;
+      std::unique_ptr<FakePictureLayerImpl> new_root =
+          FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id,
+                                                       raster_source);
+      pending_layer = new_root.get();
+      pending_layer->SetDrawsContent(true);
+      pending_layer->SetHasRenderSurface(true);
+      pending_tree->SetRootLayer(std::move(new_root));
+    }
+
+    // The bounds() just mirror the raster source size.
+    pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
+
+    // Add tilings/tiles for the layer.
+    bool update_lcd_text = false;
+    host_impl_->pending_tree()->BuildPropertyTreesForTesting();
+    host_impl_->pending_tree()->UpdateDrawProperties(update_lcd_text);
+  }
+
+ protected:
   // MockLayerTreeHostImpl allows us to intercept tile manager callbacks.
   class MockLayerTreeHostImpl : public FakeLayerTreeHostImpl {
    public:
-    MockLayerTreeHostImpl(
-        const LayerTreeSettings& settings,
-        TaskRunnerProvider* task_runner_provider,
-        SharedBitmapManager* manager,
-        TaskGraphRunner* task_graph_runner,
-        gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
+    MockLayerTreeHostImpl(const LayerTreeSettings& settings,
+                          TaskRunnerProvider* task_runner_provider,
+                          SharedBitmapManager* manager,
+                          TaskGraphRunner* task_graph_runner)
         : FakeLayerTreeHostImpl(settings,
                                 task_runner_provider,
                                 manager,
-                                task_graph_runner,
-                                gpu_memory_buffer_manager) {}
+                                task_graph_runner) {}
 
     MOCK_METHOD0(NotifyAllTileTasksCompleted, void());
     MOCK_METHOD0(NotifyReadyToDraw, void());
   };
 
-  std::unique_ptr<FakeLayerTreeHostImpl> CreateHostImpl(
-      const LayerTreeSettings& settings,
-      TaskRunnerProvider* task_runner_provider,
-      SharedBitmapManager* shared_bitmap_manager,
-      TaskGraphRunner* task_graph_runner,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) override {
-    return base::WrapUnique(new MockLayerTreeHostImpl(
-        settings, task_runner_provider, shared_bitmap_manager,
-        task_graph_runner, gpu_memory_buffer_manager));
+  // By default do no customization.
+  virtual void CustomizeSettings(LayerTreeSettings* settings) {}
+
+  // By default use TestTaskGraphRunner.
+  virtual std::unique_ptr<TaskGraphRunner> GetTaskGraphRunner() const {
+    return base::WrapUnique(new TestTaskGraphRunner());
   }
 
   // By default use SoftwareOutputSurface.
-  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+  virtual std::unique_ptr<OutputSurface> GetOutputSurface() const {
     return FakeOutputSurface::CreateSoftware(
         base::WrapUnique(new SoftwareOutputDevice));
   }
 
-  MockLayerTreeHostImpl& MockHostImpl() {
-    return *static_cast<MockLayerTreeHostImpl*>(host_impl());
-  }
+  TestSharedBitmapManager shared_bitmap_manager_;
+  std::unique_ptr<TaskGraphRunner> task_graph_runner_;
+  FakeImplTaskRunnerProvider task_runner_provider_;
+  std::unique_ptr<OutputSurface> output_surface_;
+  std::unique_ptr<MockLayerTreeHostImpl> host_impl_;
 };
 
 // Test to ensure that we call NotifyAllTileTasksCompleted when PrepareTiles is
 // called.
 TEST_F(TileManagerTest, AllWorkFinishedTest) {
   // Check with no tile work enqueued.
   {
     base::RunLoop run_loop;
-    EXPECT_FALSE(
-        host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
-    EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+    EXPECT_FALSE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
+    EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
-    host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
-    EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+    host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
+    EXPECT_TRUE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
     run_loop.Run();
   }
 
   // Check that the "schedule more work" path also triggers the expected
   // callback.
   {
     base::RunLoop run_loop;
-    EXPECT_FALSE(
-        host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
-    EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+    EXPECT_FALSE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
+    EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
-    host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
-    host_impl()->tile_manager()->SetMoreTilesNeedToBeRasterizedForTesting();
-    EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+    host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
+    host_impl_->tile_manager()->SetMoreTilesNeedToBeRasterizedForTesting();
+    EXPECT_TRUE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
     run_loop.Run();
   }
 }
 
 TEST_F(TileManagerTest, ActivateAndDrawWhenOOM) {
   SetupDefaultTrees(gfx::Size(1000, 1000));
 
-  auto global_state = host_impl()->global_tile_state();
+  auto global_state = host_impl_->global_tile_state();
   global_state.hard_memory_limit_in_bytes = 1u;
   global_state.soft_memory_limit_in_bytes = 1u;
 
   {
     base::RunLoop run_loop;
-    EXPECT_FALSE(
-        host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
-    EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+    EXPECT_FALSE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
+    EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
-    host_impl()->tile_manager()->PrepareTiles(global_state);
-    EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+    host_impl_->tile_manager()->PrepareTiles(global_state);
+    EXPECT_TRUE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
     run_loop.Run();
   }
 
-  EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToDraw());
-  EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToActivate());
-  EXPECT_TRUE(host_impl()->notify_tile_state_changed_called());
+  EXPECT_TRUE(host_impl_->tile_manager()->IsReadyToDraw());
+  EXPECT_TRUE(host_impl_->tile_manager()->IsReadyToActivate());
+  EXPECT_TRUE(host_impl_->notify_tile_state_changed_called());
 
   // Next PrepareTiles should skip NotifyTileStateChanged since all tiles
   // are marked oom already.
   {
     base::RunLoop run_loop;
-    host_impl()->set_notify_tile_state_changed_called(false);
-    EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+    host_impl_->set_notify_tile_state_changed_called(false);
+    EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
-    host_impl()->tile_manager()->PrepareTiles(global_state);
+    host_impl_->tile_manager()->PrepareTiles(global_state);
     run_loop.Run();
-    EXPECT_FALSE(host_impl()->notify_tile_state_changed_called());
+    EXPECT_FALSE(host_impl_->notify_tile_state_changed_called());
   }
 }
 
 TEST_F(TileManagerTest, LowResHasNoImage) {
   gfx::Size size(10, 12);
   TileResolution resolutions[] = {HIGH_RESOLUTION, LOW_RESOLUTION};
 
   for (size_t i = 0; i < arraysize(resolutions); ++i) {
     SCOPED_TRACE(resolutions[i]);
 
@@ skipping 14 matching lines @@
     recording_source->add_draw_rect_with_paint(gfx::Rect(size), paint);
     recording_source->add_draw_image(std::move(blue_image), gfx::Point());
     recording_source->Rerecord();
     scoped_refptr<RasterSource> raster =
         RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
     FakePictureLayerTilingClient tiling_client;
     tiling_client.SetTileSize(size);
 
     std::unique_ptr<PictureLayerImpl> layer =
-        PictureLayerImpl::Create(host_impl()->active_tree(), 1, false);
+        PictureLayerImpl::Create(host_impl_->active_tree(), 1, false);
     PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
     layer->set_is_drawn_render_surface_layer_list_member(true);
 
     auto* tiling = tiling_set->AddTiling(1.0f, raster);
     tiling->set_resolution(resolutions[i]);
     tiling->CreateAllTilesForTesting();
     tiling->SetTilePriorityRectsForTesting(
         gfx::Rect(size),   // Visible rect.
         gfx::Rect(size),   // Skewport rect.
         gfx::Rect(size),   // Soon rect.
         gfx::Rect(size));  // Eventually rect.
 
     // SMOOTHNESS_TAKES_PRIORITY ensures that we will actually raster
     // LOW_RESOLUTION tiles, otherwise they are skipped.
-    host_impl()->SetTreePriority(SMOOTHNESS_TAKES_PRIORITY);
+    host_impl_->SetTreePriority(SMOOTHNESS_TAKES_PRIORITY);
 
     // Call PrepareTiles and wait for it to complete.
-    auto* tile_manager = host_impl()->tile_manager();
+    auto* tile_manager = host_impl_->tile_manager();
     base::RunLoop run_loop;
-    EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+    EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
-    tile_manager->PrepareTiles(host_impl()->global_tile_state());
+    tile_manager->PrepareTiles(host_impl_->global_tile_state());
     run_loop.Run();
     tile_manager->Flush();
 
     Tile* tile = tiling->TileAt(0, 0);
     // The tile in the tiling was rastered.
     EXPECT_EQ(TileDrawInfo::RESOURCE_MODE, tile->draw_info().mode());
     EXPECT_TRUE(tile->draw_info().IsReadyToDraw());
 
     ResourceProvider::ScopedReadLockSoftware lock(
-        host_impl()->resource_provider(), tile->draw_info().resource_id());
+        host_impl_->resource_provider(), tile->draw_info().resource_id());
     const SkBitmap* bitmap = lock.sk_bitmap();
     for (int x = 0; x < size.width(); ++x) {
       for (int y = 0; y < size.height(); ++y) {
         SCOPED_TRACE(y);
         SCOPED_TRACE(x);
         if (resolutions[i] == LOW_RESOLUTION) {
           // Since it's low res, the bitmap was not drawn, and the background
           // (green) is visible instead.
           ASSERT_EQ(SK_ColorGREEN, bitmap->getColor(x, y));
         } else {
           EXPECT_EQ(HIGH_RESOLUTION, resolutions[i]);
           // Since it's high res, the bitmap (blue) was drawn, and the
           // background is not visible.
           ASSERT_EQ(SK_ColorBLUE, bitmap->getColor(x, y));
         }
       }
     }
   }
 }
 
 class ActivationTasksDoNotBlockReadyToDrawTest : public TileManagerTest {
  protected:
-  std::unique_ptr<TaskGraphRunner> CreateTaskGraphRunner() override {
+  std::unique_ptr<TaskGraphRunner> GetTaskGraphRunner() const override {
     return base::WrapUnique(new SynchronousTaskGraphRunner());
   }
 
-  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+  std::unique_ptr<OutputSurface> GetOutputSurface() const override {
     return FakeOutputSurface::Create3d();
   }
 
-  LayerTreeSettings CreateSettings() override {
-    LayerTreeSettings settings = TileManagerTest::CreateSettings();
-    settings.gpu_rasterization_forced = true;
-    return settings;
+  void CustomizeSettings(LayerTreeSettings* settings) override {
+    settings->gpu_rasterization_forced = true;
+  }
+
+  SynchronousTaskGraphRunner* GetSynchronousTaskGraphRunner() const {
+    return static_cast<SynchronousTaskGraphRunner*>(task_graph_runner_.get());
   }
 };
 
 TEST_F(ActivationTasksDoNotBlockReadyToDrawTest,
        ActivationTasksDoNotBlockReadyToDraw) {
   const gfx::Size layer_bounds(1000, 1000);
 
-  EXPECT_TRUE(host_impl()->use_gpu_rasterization());
+  EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Active tree has no non-solid tiles, so it will generate no tile tasks.
   std::unique_ptr<FakeRecordingSource> active_tree_recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
   SkPaint solid_paint;
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
   solid_paint.setColor(solid_color);
   active_tree_recording_source->add_draw_rect_with_paint(
       gfx::Rect(layer_bounds), solid_paint);
@@ skipping 12 matching lines @@
   pending_tree_recording_source->Rerecord();
 
   scoped_refptr<RasterSource> active_tree_raster_source =
       RasterSource::CreateFromRecordingSource(
           active_tree_recording_source.get(), false);
   scoped_refptr<RasterSource> pending_tree_raster_source =
       RasterSource::CreateFromRecordingSource(
           pending_tree_recording_source.get(), false);
 
   SetupTrees(pending_tree_raster_source, active_tree_raster_source);
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
 
   // The first task to run should be ReadyToDraw (this should not be blocked by
   // the tasks required for activation).
   base::RunLoop run_loop;
-  EXPECT_CALL(MockHostImpl(), NotifyReadyToDraw())
+  EXPECT_CALL(*host_impl_, NotifyReadyToDraw())
       .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
-  static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())
-      ->RunSingleTaskForTesting();
+  GetSynchronousTaskGraphRunner()->RunSingleTaskForTesting();
   run_loop.Run();
 }
 
 // Fake TileTaskManager that just cancels all scheduled tasks immediately.
 class CancellingTileTaskManager : public FakeTileTaskManagerImpl {
  public:
   CancellingTileTaskManager() {}
   ~CancellingTileTaskManager() override {}
 
   void ScheduleTasks(TaskGraph* graph) override {
     // Just call CompleteOnOriginThread on each item in the queue. As none of
     // these items have run yet, they will be treated as cancelled tasks.
     for (const auto& node : graph->nodes) {
       static_cast<TileTask*>(node.task)->CompleteOnOriginThread(
           raster_buffer_provider_.get());
     }
   }
   void CheckForCompletedTasks() override {}
 };
 
 class PartialRasterTileManagerTest : public TileManagerTest {
  public:
-  LayerTreeSettings CreateSettings() override {
-    LayerTreeSettings settings = TileManagerTest::CreateSettings();
-    settings.use_partial_raster = true;
-    return settings;
+  void CustomizeSettings(LayerTreeSettings* settings) override {
+    settings->use_partial_raster = true;
   }
 };
 
 // Ensures that if a raster task is cancelled, it gets returned to the resource
 // pool with an invalid content ID, not with its invalidated content ID.
 TEST_F(PartialRasterTileManagerTest, CancelledTasksHaveNoContentId) {
   // Create a CancellingTaskRunner and set it on the tile manager so that all
   // scheduled work is immediately cancelled.
   CancellingTileTaskManager cancelling_task_manager;
-  host_impl()->tile_manager()->SetTileTaskManagerForTesting(
+  host_impl_->tile_manager()->SetTileTaskManagerForTesting(
       &cancelling_task_manager);
 
   // Pick arbitrary IDs - they don't really matter as long as they're constant.
   const int kLayerId = 7;
   const uint64_t kInvalidatedId = 43;
   const gfx::Size kTileSize(128, 128);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(kTileSize);
-  host_impl()->CreatePendingTree();
-  LayerTreeImpl* pending_tree = host_impl()->pending_tree();
+  host_impl_->CreatePendingTree();
+  LayerTreeImpl* pending_tree = host_impl_->pending_tree();
 
   // Steal from the recycled tree.
   std::unique_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::CreateWithRasterSource(pending_tree, kLayerId,
                                                    pending_raster_source);
   pending_layer->SetDrawsContent(true);
   pending_layer->SetHasRenderSurface(true);
 
   // The bounds() just mirror the raster source size.
   pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
   pending_tree->SetRootLayer(std::move(pending_layer));
 
   // Add tilings/tiles for the layer.
-  host_impl()->pending_tree()->BuildPropertyTreesForTesting();
-  host_impl()->pending_tree()->UpdateDrawProperties(
-      false /* update_lcd_text */);
+  host_impl_->pending_tree()->BuildPropertyTreesForTesting();
+  host_impl_->pending_tree()->UpdateDrawProperties(false /* update_lcd_text */);
 
   // Build the raster queue and invalidate the top tile.
-  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_->BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   queue->Top().tile()->SetInvalidated(gfx::Rect(), kInvalidatedId);
 
   // PrepareTiles to schedule tasks. Due to the CancellingTileTaskManager,
   // these tasks will immediately be canceled.
-  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
 
   // Make sure that the tile we invalidated above was not returned to the pool
   // with its invalidated resource ID.
-  host_impl()->resource_pool()->CheckBusyResources();
-  EXPECT_FALSE(host_impl()->resource_pool()->TryAcquireResourceWithContentId(
+  host_impl_->resource_pool()->CheckBusyResources();
+  EXPECT_FALSE(host_impl_->resource_pool()->TryAcquireResourceWithContentId(
       kInvalidatedId));
 
   // Free our host_impl_ before the cancelling_task_manager we passed it, as it
   // will use that class in clean up.
-  TakeHostImpl();
+  host_impl_ = nullptr;
 }
 
 // FakeRasterBufferProviderImpl that verifies the resource content ID of raster
 // tasks.
 class VerifyResourceContentIdRasterBufferProvider
     : public FakeRasterBufferProviderImpl {
  public:
   explicit VerifyResourceContentIdRasterBufferProvider(
       uint64_t expected_resource_id)
       : expected_resource_id_(expected_resource_id) {}
@@ skipping 87 matching lines @@
   host_impl->tile_manager()->PrepareTiles(host_impl->global_tile_state());
 
   // Free our host_impl before the verifying_task_manager we passed it, as it
   // will use that class in clean up.
   host_impl = nullptr;
 }
 
 // Ensures that the tile manager successfully reuses tiles when partial
 // raster is enabled.
 TEST_F(PartialRasterTileManagerTest, PartialRasterSuccessfullyEnabled) {
-  RunPartialRasterCheck(TakeHostImpl(), true /* partial_raster_enabled */);
+  RunPartialRasterCheck(std::move(host_impl_),
+                        true /* partial_raster_enabled */);
 }
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
-  RunPartialRasterCheck(TakeHostImpl(), false /* partial_raster_enabled */);
+  RunPartialRasterCheck(std::move(host_impl_),
+                        false /* partial_raster_enabled */);
 }
 
 }  // namespace
 }  // namespace cc