Added preliminary support for tile rasterization with Ganesh

cc/resources/tile_manager.cc

Index: cc/resources/tile_manager.cc
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 84842fee29bcad56305bde3af6928c0bc7550074..14a290f1c6068923530ad1147c387f3721be3357 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -168,8 +168,10 @@ scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     size_t num_raster_threads,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
+    bool use_ganesh,
     bool use_map_image,
     size_t max_transfer_buffer_usage_bytes,
     size_t max_raster_usage_bytes) {
@@ -183,6 +185,10 @@ scoped_ptr<TileManager> TileManager::Create(
                           resource_provider,
                           num_raster_threads,
                           max_transfer_buffer_usage_bytes),
+                      use_ganesh ?
+                      GaneshRasterizer::Create(

[enne (OOO), 2013/11/25 23:14:10]

It seems like extra complication to have this optional ganesh rasterizer.  Maybe
it'd simplify life to just have it always be created, but only sometimes used.

+                         context_provider, resource_provider) :
+                      scoped_ptr<GaneshRasterizer>(),
                       num_raster_threads,
                       max_raster_usage_bytes,
                       rendering_stats_instrumentation));
@@ -192,12 +198,14 @@ TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
+    scoped_ptr<GaneshRasterizer> ganesh_rasterizer,
     size_t num_raster_threads,
     size_t max_raster_usage_bytes,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(raster_worker_pool.Pass()),
+      ganesh_rasterizer_(ganesh_rasterizer.Pass()),
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
@@ -211,6 +219,8 @@ TileManager::TileManager(
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true) {
   raster_worker_pool_->SetClient(this);
+  if (ganesh_rasterizer_)
+    ganesh_rasterizer_->SetClient(this);
 }
 
 TileManager::~TileManager() {
@@ -588,6 +598,10 @@ RasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
   const ManagedTileState& mts = tile->managed_state();
   RasterMode current_mode = mts.raster_mode;
 
+  // TODO(skaslev): Add proper a heuristic whether a tile
+  // should go for software or GPU rasterizing.
+  if (ganesh_rasterizer_)
+    return GANESH_RASTER_MODE;
   RasterMode raster_mode = HIGH_QUALITY_RASTER_MODE;
   if (tile->managed_state().resolution == LOW_RESOLUTION)
     raster_mode = LOW_QUALITY_RASTER_MODE;
@@ -810,10 +824,14 @@ void TileManager::ScheduleTasks(
     DCHECK(tile_version.requires_resource());
     DCHECK(!tile_version.resource_);
 
-    if (tile_version.raster_task_.is_null())
-      tile_version.raster_task_ = CreateRasterTask(tile);
+    if (mts.raster_mode == GANESH_RASTER_MODE) {
+      CreateGaneshRasterTask(tile);
+    } else {
+      if (tile_version.raster_task_.is_null())
+        tile_version.raster_task_ = CreateRasterTask(tile);
 
-    tasks.Append(tile_version.raster_task_, tile->required_for_activation());
+      tasks.Append(tile_version.raster_task_, tile->required_for_activation());
+    }
   }
 
   // We must reduce the amount of unused resoruces before calling
@@ -826,6 +844,9 @@ void TileManager::ScheduleTasks(
   raster_worker_pool_->ScheduleTasks(&tasks);
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
+
+  if (ganesh_rasterizer_)
+    ganesh_rasterizer_->FlushRasterTasks(rendering_stats_instrumentation_);

[vmpstr, 2013/11/25 18:11:48]

From the perspective of what TileManager current does, I kind of prefer having
the call to raster be somewhere else. TileManager currently takes tiles, sorts
them, and passes them to something that actually does rasterization. Then, tile
manager glues resources to tiles. Doing the flush here kind of breaks this. I do
like push/flush because it makes it possible to flush at any point in time,
whereas having a queue and passing it back will need more plumbing if this calls
moves somewhere else. 

I'm ok with this if this is truly the best place, but perhaps there is a better
place?

[reveman, 2013/11/25 21:24:10]

It might be cleaner to tally up these tiles in a different vector (not
tiles_that_need_to_be_rasterized) and use a separate function (not
TileManager::ScheduleTasks) to execute them.

I think we should use a queue and pass it to the ganesh rasterizer in a way that
is consistent with how we interact with our RasterWorkerPool instance. Let's
keep things simple and intuitive for what the patch does now and not what it
might do in the future. ie. don't complicate things with a client interface
while gpu raster is synchronous.

 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
@@ -892,6 +913,15 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
       &decode_tasks);
 }
 
+void TileManager::CreateGaneshRasterTask(Tile* tile) {
+  DCHECK(ganesh_rasterizer_);
+
+  scoped_ptr<ResourcePool::Resource> resource =
+    resource_pool_->AcquireResource(tile->tile_size_.size(),
+                                    ganesh_rasterizer_->GetResourceFormat());
+  ganesh_rasterizer_->PushRasterTask(tile, resource.Pass());
+}
+
 void TileManager::OnImageDecodeTaskCompleted(
     int layer_id,
     skia::LazyPixelRef* pixel_ref,
@@ -960,6 +990,34 @@ void TileManager::OnRasterTaskCompleted(
     did_initialize_visible_tile_ = true;
 }
 
+void TileManager::OnGaneshRasterTaskCompleted(
+    Tile* tile,
+    scoped_ptr<ResourcePool::Resource> resource,
+    bool was_canceled) {
+  ManagedTileState& mts = tile->managed_state();
+  ManagedTileState::TileVersion& tile_version =
+      mts.tile_versions[GANESH_RASTER_MODE];
+  DCHECK(tile_version.raster_task_.is_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_use_resource();
+  tile_version.resource_ = resource.Pass();
+
+  bytes_releasable_ += BytesConsumedIfAllocated(tile);
+  ++resources_releasable_;
+
+  FreeUnusedResourcesForTile(tile);
+  if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
+    did_initialize_visible_tile_ = true;
+}
+
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             gfx::Size tile_size,
                                             gfx::Rect content_rect,