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/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 91 matching lines @@
     return SOON_BIN;
 
   if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
     return NEVER_BIN;
 
   return EVENTUALLY_BIN;
 }
 
 }  // namespace
 
+class RasterWorkerPoolDelegate : public RasterWorkerPoolClient {

[vmpstr, 2014/02/14 17:16:51]

Can you please make this a separate file?

I was thinking of making this more generic where you can pass a vector of raster
worker pools, and then pass a vector of tasks to schedule of the same size and
iterate over each and schedule. That way, if say gpu raster is disabled, we only
have a vector of 1 element and avoid unnecessary schedules or whatnot. But I
think this is fine as well. No need to over-engineer.

[reveman, 2014/02/14 23:30:52]

Done.
Have a look at the latest patch. I'm currently not doing anything to avoid
scheduling tasks to all worker pools. I'm hoping we can get away with that for
simplicity.

+ public:
+  RasterWorkerPoolDelegate(
+      scoped_ptr<RasterWorkerPool> raster_worker_pool,
+      scoped_ptr<RasterWorkerPool> direct_raster_worker_pool)
+      : client_(NULL),
+        raster_worker_pool_(raster_worker_pool.Pass()),
+        direct_raster_worker_pool_(direct_raster_worker_pool.Pass()),
+        did_finish_running_tasks_pending_count_(0u),
+        did_finish_running_tasks_required_for_activation_pending_count_(0u) {
+    raster_worker_pool_->SetClient(this);
+    direct_raster_worker_pool_->SetClient(this);
+  }
+
+  void SetClient(RasterWorkerPoolClient* client) { client_ = client; }
+
+  void Shutdown() {
+    raster_worker_pool_->Shutdown();
+    direct_raster_worker_pool_->Shutdown();
+  }
+
+  void ScheduleTasks(RasterTaskQueue* raster_queue,
+                     RasterTaskQueue* direct_raster_queue) {
+    raster_worker_pool_->ScheduleTasks(raster_queue);
+    direct_raster_worker_pool_->ScheduleTasks(direct_raster_queue);
+
+    did_finish_running_tasks_pending_count_ = 2u;
+    did_finish_running_tasks_required_for_activation_pending_count_ = 2u;
+  }
+
+  void CheckForCompletedTasks() {
+    raster_worker_pool_->CheckForCompletedTasks();
+    direct_raster_worker_pool_->CheckForCompletedTasks();
+  }
+
+  // Overriden from RasterWorkerPoolClient:
+  virtual bool ShouldForceTasksRequiredForActivationToComplete()
+      const OVERRIDE {
+    return client_->ShouldForceTasksRequiredForActivationToComplete();
+  }
+  virtual void DidFinishRunningTasks() OVERRIDE {
+    DCHECK_LT(0u, did_finish_running_tasks_pending_count_);
+    if (--did_finish_running_tasks_pending_count_)
+      return;
+    client_->DidFinishRunningTasks();
+  }
+  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {
+    DCHECK_LT(0u,
+              did_finish_running_tasks_required_for_activation_pending_count_);
+    if (--did_finish_running_tasks_required_for_activation_pending_count_)
+      return;
+    client_->DidFinishRunningTasksRequiredForActivation();
+  }
+
+ private:
+  RasterWorkerPoolClient* client_;
+  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+  scoped_ptr<RasterWorkerPool> direct_raster_worker_pool_;
+  size_t did_finish_running_tasks_pending_count_;
+  size_t did_finish_running_tasks_required_for_activation_pending_count_;
+};
+
 RasterTaskCompletionStats::RasterTaskCompletionStats()
     : completed_count(0u), canceled_count(0u) {}
 
 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
     const RasterTaskCompletionStats& stats) {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("completed_count", stats.completed_count);
   state->SetInteger("canceled_count", stats.canceled_count);
   return state.PassAs<base::Value>();
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     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),

[alokp, 2014/02/14 18:50:59]

I was under the impression that we would create a HybridRasterWorkerPool and
push all the complexity of managing two raster worker pools from the tile
manager to the new class.

[reveman, 2014/02/14 23:30:52]

Yes, that might be what we want to do long term but I prefer to wait until we're
done with all cleanup to the RasterWorkerPool interface first.

       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_format_(raster_worker_pool->GetResourceFormat()),
       resource_pool_(
           ResourcePool::Create(resource_provider,
                                raster_worker_pool->GetResourceTarget(),
-                               raster_worker_pool->GetResourceFormat())),
-      raster_worker_pool_(raster_worker_pool.Pass()),
+                               resource_format_)),
+      raster_worker_pool_(
+          new RasterWorkerPoolDelegate(raster_worker_pool.Pass(),
+                                       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);
 }
 
 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);
+  RasterTaskQueue empty;
+  raster_worker_pool_->ScheduleTasks(&empty, &empty);
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_->Shutdown();
   raster_worker_pool_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
 }
 
@@ skipping 118 matching lines @@
   const TreePriority tree_priority = global_state_.tree_priority;
 
   // For each tree, bin into different categories of tiles.
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = it->second;
     ManagedTileState& mts = tile->managed_state();
 
     const ManagedTileState::TileVersion& tile_version =
         tile->GetTileVersionForDrawing();
     bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
-    bool tile_is_active =
-        tile_is_ready_to_draw ||
-        !mts.tile_versions[mts.raster_mode].raster_task_.is_null();
+    bool tile_is_active = tile_is_ready_to_draw ||
+                          mts.tile_versions[mts.raster_mode].raster_task_;
 
     // Get the active priority and bin.
     TilePriority active_priority = tile->priority(ACTIVE_TREE);
     ManagedTileBin active_bin = BinFromTilePriority(active_priority);
 
     // Get the pending priority and bin.
     TilePriority pending_priority = tile->priority(PENDING_TREE);
     ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
 
     bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
@@ skipping 295 matching lines @@
         tile_resources++;
       }
     }
 
     // Allow lower priority tiles with initialized resources to keep
     // their memory by only assigning memory to new raster tasks if
     // they can be scheduled.
     if (raster_bytes_if_rastered <= max_raster_bytes) {
       // If we don't have the required version, and it's not in flight
       // then we'll have to pay to create a new task.
-      if (!tile_version.resource_ && tile_version.raster_task_.is_null()) {
+      if (!tile_version.resource_ && !tile_version.raster_task_) {
         tile_bytes += bytes_if_allocated;
         tile_resources++;
       }
     }
 
     // Tile is OOM.
     if (tile_bytes > bytes_left || tile_resources > resources_left) {
       FreeResourcesForTile(tile);
 
       // This tile was already on screen and now its resources have been
@@ skipping 91 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();
+  raster_queue_.Reset();
+  gpu_raster_queue_.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())
+    if (!tile_version.raster_task_)
       tile_version.raster_task_ = CreateRasterTask(tile);
 
-    raster_tasks_.Append(tile_version.raster_task_,
-                         tile->required_for_activation());
+    if (tile->use_gpu_rasterization()) {
+      gpu_raster_queue_.tasks.push_back(RasterTaskQueue::Task(
+          tile_version.raster_task_.get(), tile->required_for_activation()));
+      gpu_raster_queue_.required_for_activation_count +=
+          tile->required_for_activation();
+    } else {
+      raster_queue_.tasks.push_back(RasterTaskQueue::Task(
+          tile_version.raster_task_.get(), tile->required_for_activation()));
+      raster_queue_.required_for_activation_count +=
+          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_->ScheduleTasks(&raster_queue_, &gpu_raster_queue_);
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
-RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
+scoped_refptr<internal::WorkerPoolTask> TileManager::CreateImageDecodeTask(
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
       tile->layer_id(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref)));
 }
 
-RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
+scoped_refptr<internal::RasterWorkerPoolTask> TileManager::CreateRasterTask(
+    Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ScopedResource> resource =
       resource_pool_->AcquireResource(tile->tile_size_.size());
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
-  RasterWorkerPool::Task::Set decode_tasks;
+  internal::WorkerPoolTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   for (PicturePileImpl::PixelRefIterator iter(
            tile->content_rect(), tile->contents_scale(), tile->picture_pile());
        iter;
        ++iter) {
     SkPixelRef* pixel_ref = *iter;
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
     if (decode_task_it != existing_pixel_refs.end()) {
-      decode_tasks.Insert(decode_task_it->second);
+      decode_tasks.push_back(decode_task_it->second);
       continue;
     }
 
     // Create and append new image decode task for this pixel ref.
-    RasterWorkerPool::Task decode_task = CreateImageDecodeTask(tile, pixel_ref);
-    decode_tasks.Insert(decode_task);
+    scoped_refptr<internal::WorkerPoolTask> decode_task =
+        CreateImageDecodeTask(tile, pixel_ref);
+    decode_tasks.push_back(decode_task);
     existing_pixel_refs[id] = decode_task;
   }
 
   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 19 matching lines @@
   TileMap::iterator it = tiles_.find(tile_id);
   if (it == tiles_.end()) {
     ++update_visible_tiles_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   Tile* tile = it->second;
   ManagedTileState& mts = tile->managed_state();
   ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode];
-  DCHECK(!tile_version.raster_task_.is_null());
-  tile_version.raster_task_.Reset();
+  DCHECK(tile_version.raster_task_);
+  tile_version.raster_task_ = NULL;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   ++update_visible_tiles_stats_.completed_count;
 
   tile_version.set_has_text(analysis.has_text);
@@ skipping 32 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