cc: Refactor TileTaskWorkerPool.

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 728c2f73a428efc8406dfcffda454f5f96d96fd0..ca650efc4e0584c3dfd331e9a3ead2e6b47b27a3 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -79,6 +79,7 @@
 #include "cc/tiles/picture_layer_tiling.h"
 #include "cc/tiles/raster_tile_priority_queue.h"
 #include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/tile_task_manager.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/latency_info_swap_promise_monitor.h"
@@ -2151,7 +2152,8 @@ void LayerTreeHostImpl::CreateAndSetRenderer() {
 }
 
 void LayerTreeHostImpl::CreateTileManagerResources() {
-  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_);
+  std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool;
+  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool, &resource_pool_);
 
   if (use_gpu_rasterization_) {
     image_decode_controller_ = base::WrapUnique(new GpuImageDecodeController(
@@ -2163,10 +2165,23 @@ void LayerTreeHostImpl::CreateTileManagerResources() {
             settings_.renderer_settings.preferred_tile_format));
   }
 
+  // Pass the single-threaded synchronous task graph runner to the worker pool
+  // if we're in synchronous single-threaded mode.
+  TaskGraphRunner* task_graph_runner = task_graph_runner_;
+  if (is_synchronous_single_threaded_) {
+    DCHECK(!single_thread_synchronous_task_graph_runner_);
+    single_thread_synchronous_task_graph_runner_.reset(
+        new SynchronousTaskGraphRunner);
+    task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
+  }
+
+  tile_task_manager_ = TileTaskManager::Create(std::move(tile_task_worker_pool),
+                                               task_graph_runner);
+
   // TODO(vmpstr): Initialize tile task limit at ctor time.
   tile_manager_->SetResources(
-      resource_pool_.get(), tile_task_worker_pool_.get(),
-      image_decode_controller_.get(),
+      resource_pool_.get(), image_decode_controller_.get(),
+      tile_task_manager_.get(),
       is_synchronous_single_threaded_ ? std::numeric_limits<size_t>::max()
                                       : settings_.scheduled_raster_task_limit,
       use_gpu_rasterization_);
@@ -2181,23 +2196,13 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
   // resolved.
   CHECK(resource_provider_);
 
-  // Pass the single-threaded synchronous task graph runner to the worker pool
-  // if we're in synchronous single-threaded mode.
-  TaskGraphRunner* task_graph_runner = task_graph_runner_;
-  if (is_synchronous_single_threaded_) {
-    DCHECK(!single_thread_synchronous_task_graph_runner_);
-    single_thread_synchronous_task_graph_runner_.reset(
-        new SynchronousTaskGraphRunner);
-    task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
-  }
-
   ContextProvider* context_provider = output_surface_->context_provider();
   if (!context_provider) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
-    *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
-        GetTaskRunner(), task_graph_runner, resource_provider_.get());
+    *tile_task_worker_pool =
+        BitmapTileTaskWorkerPool::Create(resource_provider_.get());
     return;
   }
 
@@ -2210,9 +2215,8 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
     *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
-        GetTaskRunner(), task_graph_runner, context_provider,
-        resource_provider_.get(), settings_.use_distance_field_text,
-        msaa_sample_count);
+        context_provider, resource_provider_.get(),
+        settings_.use_distance_field_text, msaa_sample_count);
     return;
   }
 
@@ -2232,7 +2236,7 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
         resource_provider_.get(), GetTaskRunner());
 
     *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
-        GetTaskRunner(), task_graph_runner, resource_provider_.get(),
+        resource_provider_.get(),
         settings_.renderer_settings.preferred_tile_format);
     return;
   }
@@ -2244,9 +2248,9 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
                                            .gpu.max_copy_texture_chromium_size;
 
   *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
-      GetTaskRunner(), task_graph_runner, context_provider,
-      resource_provider_.get(), max_copy_texture_chromium_size,
-      settings_.use_partial_raster, settings_.max_staging_buffer_usage_in_bytes,
+      GetTaskRunner(), context_provider, resource_provider_.get(),
+      max_copy_texture_chromium_size, settings_.use_partial_raster,
+      settings_.max_staging_buffer_usage_in_bytes,
       settings_.renderer_settings.preferred_tile_format);
 }
 
@@ -2281,7 +2285,7 @@ void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
-  tile_task_worker_pool_ = nullptr;
+  tile_task_manager_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
   image_decode_controller_ = nullptr;
 }