cc: Move GPU raster to DirectRasterWorkerPool.

cc/resources/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/traced_value.h"
+#include "cc/resources/direct_raster_worker_pool.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/raster_worker_pool_delegate.h"
 #include "cc/resources/tile.h"
-#include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
-
 namespace {
 
 // Memory limit policy works by mapping some bin states to the NEVER bin.
 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
     // [ALLOW_NOTHING]
     {NEVER_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
      NEVER_BIN,  // [NOW_BIN]
      NEVER_BIN,  // [SOON_BIN]
      NEVER_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
      NEVER_BIN,  // [EVENTUALLY_BIN]
@@ skipping 116 matching lines @@
     ContextProvider* context_provider,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool use_map_image,
     bool use_rasterize_on_demand,
     size_t max_transfer_buffer_usage_bytes,
     size_t max_raster_usage_bytes,
     unsigned map_image_texture_target) {
   return make_scoped_ptr(new TileManager(
       client,
       resource_provider,
-      use_map_image
-          ? ImageRasterWorkerPool::Create(
-                resource_provider, context_provider, map_image_texture_target)
-          : PixelBufferRasterWorkerPool::Create(
-                resource_provider,
-                context_provider,
-                max_transfer_buffer_usage_bytes),
+      context_provider,
+      use_map_image ? ImageRasterWorkerPool::Create(resource_provider,
+                                                    map_image_texture_target)
+                    : PixelBufferRasterWorkerPool::Create(
+                          resource_provider, max_transfer_buffer_usage_bytes),
+      DirectRasterWorkerPool::Create(resource_provider, context_provider),
       max_raster_usage_bytes,
       rendering_stats_instrumentation,
       use_rasterize_on_demand));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
+    scoped_ptr<RasterWorkerPool> direct_raster_worker_pool,
     size_t max_raster_usage_bytes,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool use_rasterize_on_demand)
     : client_(client),
       resource_pool_(
           ResourcePool::Create(resource_provider,
                                raster_worker_pool->GetResourceTarget(),
                                raster_worker_pool->GetResourceFormat())),
       raster_worker_pool_(raster_worker_pool.Pass()),
+      direct_raster_worker_pool_(direct_raster_worker_pool.Pass()),
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
       memory_required_bytes_(0),
       memory_nice_to_have_bytes_(0),
       bytes_releasable_(0),
       resources_releasable_(0),
       max_raster_usage_bytes_(max_raster_usage_bytes),
       ever_exceeded_memory_budget_(false),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       use_rasterize_on_demand_(use_rasterize_on_demand) {
-  raster_worker_pool_->SetClient(this);
+  RasterWorkerPool* raster_worker_pools[NUM_RASTER_WORKER_POOL_TYPES] = {
+      raster_worker_pool_.get(), direct_raster_worker_pool_.get(), };

[vmpstr, 2014/02/14 23:47:24]

nit: No need for the trailing comma.

[reveman, 2014/02/15 00:02:45]

Done.

+  raster_worker_pool_delegate_ = RasterWorkerPoolDelegate::Create(
+      this,
+      raster_worker_pools,
+      raster_worker_pools + arraysize(raster_worker_pools));

[vmpstr, 2014/02/14 23:47:24]

nit: Maybe pass NUM_RASTER_WORKER_POOL_TYPES instead as a count and do rwps,
rwps + count for the vector constructor? Either one is fine I guess.

[reveman, 2014/02/15 00:02:45]

Done. Passing arraysize.

 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   CleanUpReleasedTiles();
   DCHECK_EQ(0u, tiles_.size());
 
-  RasterWorkerPool::RasterTask::Queue empty;
-  raster_worker_pool_->ScheduleTasks(&empty);
+  RasterWorkerPool::RasterTask::Queue empty[NUM_RASTER_WORKER_POOL_TYPES];
+  raster_worker_pool_delegate_->ScheduleTasks(empty);
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
-  raster_worker_pool_->Shutdown();
-  raster_worker_pool_->CheckForCompletedTasks();
+  raster_worker_pool_delegate_->Shutdown();
+  raster_worker_pool_delegate_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
 }
 
 void TileManager::Release(Tile* tile) {
   prioritized_tiles_dirty_ = true;
   released_tiles_.push_back(tile);
 }
 
@@ skipping 42 matching lines @@
 }
 
 void TileManager::DidFinishRunningTasks() {
   TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   if (all_tiles_that_need_to_be_rasterized_have_memory_)
     return;
 
-  raster_worker_pool_->CheckForCompletedTasks();
+  raster_worker_pool_delegate_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TileVector tiles_that_need_to_be_rasterized;
   AssignGpuMemoryToTiles(&prioritized_tiles_,
                          &tiles_that_need_to_be_rasterized);
 
   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
   // steady memory state. Keep scheduling tasks until we reach this state.
   if (!tiles_that_need_to_be_rasterized.empty()) {
     ScheduleTasks(tiles_that_need_to_be_rasterized);
@@ skipping 174 matching lines @@
     prioritized_tiles_dirty_ = true;
     resource_pool_->SetResourceUsageLimits(
         global_state_.memory_limit_in_bytes,
         global_state_.unused_memory_limit_in_bytes,
         global_state_.num_resources_limit);
   }
 
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
-    raster_worker_pool_->CheckForCompletedTasks();
+    raster_worker_pool_delegate_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
   UpdatePrioritizedTileSetIfNeeded();
 
   TileVector tiles_that_need_to_be_rasterized;
   AssignGpuMemoryToTiles(&prioritized_tiles_,
                          &tiles_that_need_to_be_rasterized);
 
   // Finally, schedule rasterizer tasks.
   ScheduleTasks(tiles_that_need_to_be_rasterized);
 
   TRACE_EVENT_INSTANT1("cc",
                        "DidManage",
                        TRACE_EVENT_SCOPE_THREAD,
                        "state",
                        TracedValue::FromValue(BasicStateAsValue().release()));
 
   TRACE_COUNTER_ID1("cc",
                     "unused_memory_bytes",
                     this,
                     resource_pool_->total_memory_usage_bytes() -
                         resource_pool_->acquired_memory_usage_bytes());
 }
 
 bool TileManager::UpdateVisibleTiles() {
   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 
-  raster_worker_pool_->CheckForCompletedTasks();
+  raster_worker_pool_delegate_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TRACE_EVENT_INSTANT1(
       "cc",
       "DidUpdateVisibleTiles",
       TRACE_EVENT_SCOPE_THREAD,
       "stats",
       TracedValue::FromValue(RasterTaskCompletionStatsAsValue(
                                  update_visible_tiles_stats_).release()));
   update_visible_tiles_stats_ = RasterTaskCompletionStats();
@@ skipping 256 matching lines @@
 
 void TileManager::ScheduleTasks(
     const TileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc",
                "TileManager::ScheduleTasks",
                "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
-  raster_tasks_.Reset();
+  for (size_t i = 0; i < NUM_RASTER_WORKER_POOL_TYPES; ++i)
+    raster_queue_[i].Reset();
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
        it != tiles_that_need_to_be_rasterized.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
     DCHECK(tile_version.requires_resource());
     DCHECK(!tile_version.resource_);
 
     if (tile_version.raster_task_.is_null())
       tile_version.raster_task_ = CreateRasterTask(tile);
 
-    raster_tasks_.Append(tile_version.raster_task_,
-                         tile->required_for_activation());
+    size_t pool_type = tile->use_gpu_rasterization()
+                           ? RASTER_WORKER_POOL_TYPE_DIRECT
+                           : RASTER_WORKER_POOL_TYPE_DEFAULT;
+
+    raster_queue_[pool_type]
+        .Append(tile_version.raster_task_, tile->required_for_activation());
   }
 
   // We must reduce the amount of unused resoruces before calling
   // ScheduleTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Schedule running of |raster_tasks_|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |raster_tasks_|.
-  raster_worker_pool_->ScheduleTasks(&raster_tasks_);
+  raster_worker_pool_delegate_->ScheduleTasks(raster_queue_);
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
       tile->layer_id(),
@@ skipping 37 matching lines @@
   return RasterWorkerPool::CreateRasterTask(
       const_resource,
       tile->picture_pile(),
       tile->content_rect(),
       tile->contents_scale(),
       mts.raster_mode,
       mts.resolution,
       tile->layer_id(),
       static_cast<const void*>(tile),
       tile->source_frame_number(),
-      tile->use_gpu_rasterization(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
-      &decode_tasks);
+      &decode_tasks,
+      context_provider_);
 }
 
 void TileManager::OnImageDecodeTaskCompleted(int layer_id,
                                              SkPixelRef* pixel_ref,
                                              bool was_canceled) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
   if (!was_canceled)
     return;
 
@@ skipping 73 matching lines @@
                                                          flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
   used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
   return tile;
 }
 
 }  // namespace cc