cc: Refactor TileTaskWorkerPool.

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 61 matching lines @@
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/tiles/eviction_tile_priority_queue.h"
 #include "cc/tiles/gpu_image_decode_controller.h"
 #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"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ skipping 2052 matching lines @@
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
   // initialized to get max texture size.  Also, after releasing resources,
   // trees need another update to generate new ones.
   active_tree_->set_needs_update_draw_properties();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
   client_->UpdateRendererCapabilitiesOnImplThread();
 }
 
 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(
         output_surface_->worker_context_provider(),
         settings_.renderer_settings.preferred_tile_format));
   } else {
     image_decode_controller_ =
         base::WrapUnique(new SoftwareImageDecodeController(
             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_);
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 }
 
 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
     std::unique_ptr<ResourcePool>* resource_pool) {
   DCHECK(GetTaskRunner());
   // TODO(vmpstr): Make this a DCHECK (or remove) when crbug.com/419086 is
   // 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;
   }
 
   if (use_gpu_rasterization_) {
     DCHECK(resource_provider_->output_surface()->worker_context_provider());
 
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
     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;
   }
 
   DCHECK(GetRendererCapabilities().using_image);
 
   bool use_zero_copy = settings_.use_zero_copy;
   // TODO(reveman): Remove this when mojo supports worker contexts.
   // crbug.com/522440
   if (!resource_provider_->output_surface()->worker_context_provider()) {
     LOG(ERROR)
         << "Forcing zero-copy tile initialization as worker context is missing";
     use_zero_copy = true;
   }
 
   if (use_zero_copy) {
     *resource_pool = ResourcePool::CreateForGpuMemoryBufferResources(
         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;
   }
 
   *resource_pool =
       ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
   int max_copy_texture_chromium_size = context_provider->ContextCapabilities()
                                            .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);
 }
 
 void LayerTreeHostImpl::RecordMainFrameTiming(
     const BeginFrameArgs& start_of_main_frame_args,
     const BeginFrameArgs& expected_next_main_frame_args) {
   std::vector<int64_t> request_ids;
   active_tree_->GatherFrameTimingRequestIds(&request_ids);
   if (request_ids.empty())
     return;
@@ skipping 14 matching lines @@
 void LayerTreeHostImpl::SetLayerTreeMutator(LayerTreeMutator* mutator) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeHostImpl::SetLayerTreeMutator");
   mutator_ = mutator;
 }
 
 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;
 }
 
 void LayerTreeHostImpl::ReleaseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseOutputSurface");
 
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
@@ skipping 1685 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc