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 b443516887c8e65c6c0ba464dec3820ef926042b..3b898547be714eff5ef4aec3eaf18efa1e6c124d 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_gpu_rasterizing,
     bool use_map_image,
     size_t max_transfer_buffer_usage_bytes,
     size_t max_raster_usage_bytes,
@@ -186,6 +188,10 @@ scoped_ptr<TileManager> TileManager::Create(
                           resource_provider,
                           num_raster_threads,
                           max_transfer_buffer_usage_bytes),
+                      use_gpu_rasterizing ?
+                      GpuRasterizer::Create(
+                         context_provider, resource_provider) :
+                      scoped_ptr<GpuRasterizer>(),
                       num_raster_threads,
                       max_raster_usage_bytes,
                       rendering_stats_instrumentation));
@@ -195,6 +201,7 @@ TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
+    scoped_ptr<GpuRasterizer> gpu_rasterizer,
     size_t num_raster_threads,
     size_t max_raster_usage_bytes,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
@@ -204,6 +211,7 @@ TileManager::TileManager(
                          raster_worker_pool->GetResourceTarget(),
                          raster_worker_pool->GetResourceFormat())),
       raster_worker_pool_(raster_worker_pool.Pass()),
+      gpu_rasterizer_(gpu_rasterizer.Pass()),
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
@@ -217,6 +225,8 @@ TileManager::TileManager(
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true) {
   raster_worker_pool_->SetClient(this);
+  if (gpu_rasterizer_)
+    gpu_rasterizer_->SetClient(this);
 }
 
 TileManager::~TileManager() {
@@ -594,6 +604,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 (gpu_rasterizer_)
+    return GPU_RASTER_MODE;
   RasterMode raster_mode = HIGH_QUALITY_RASTER_MODE;
   if (tile->managed_state().resolution == LOW_RESOLUTION)
     raster_mode = LOW_QUALITY_RASTER_MODE;
@@ -816,10 +830,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 == GPU_RASTER_MODE) {
+      CreateGpuRasterTask(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
@@ -832,6 +850,9 @@ void TileManager::ScheduleTasks(
   raster_worker_pool_->ScheduleTasks(&tasks);
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
+
+  if (gpu_rasterizer_)
+    gpu_rasterizer_->FlushRasterTasks(rendering_stats_instrumentation_);
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
@@ -896,6 +917,14 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
       &decode_tasks);
 }
 
+void TileManager::CreateGpuRasterTask(Tile* tile) {
+  DCHECK(gpu_rasterizer_);
+
+  scoped_ptr<ResourcePool::Resource> resource =
+    resource_pool_->AcquireResource(tile->tile_size_.size());
+  gpu_rasterizer_->PushRasterTask(tile, resource.Pass());
+}
+
 void TileManager::OnImageDecodeTaskCompleted(
     int layer_id,
     skia::LazyPixelRef* pixel_ref,
@@ -964,6 +993,34 @@ void TileManager::OnRasterTaskCompleted(
     did_initialize_visible_tile_ = true;
 }
 
+void TileManager::OnGpuRasterTaskCompleted(
+    Tile* tile,
+    scoped_ptr<ResourcePool::Resource> resource,
+    bool was_canceled) {
+  ManagedTileState& mts = tile->managed_state();
+  ManagedTileState::TileVersion& tile_version =
+      mts.tile_versions[GPU_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,