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..70337a978184a51a080903977d7368e5863b462f 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -168,6 +168,7 @@ 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_map_image,
@@ -177,6 +178,7 @@ scoped_ptr<TileManager> TileManager::Create(
   return make_scoped_ptr(
       new TileManager(client,
                       resource_provider,
+                      context_provider,
                       use_map_image ?
                       ImageRasterWorkerPool::Create(
                           resource_provider,
@@ -194,6 +196,7 @@ scoped_ptr<TileManager> TileManager::Create(
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
     size_t num_raster_threads,
     size_t max_raster_usage_bytes,
@@ -204,6 +207,8 @@ TileManager::TileManager(
                          raster_worker_pool->GetResourceTarget(),
                          raster_worker_pool->GetResourceFormat())),
       raster_worker_pool_(raster_worker_pool.Pass()),
+      gpu_rasterizer_(GpuRasterizer::Create(

[nduca, 2013/12/02 19:50:17]

you should have unit tests that ensure that tiles enqueued to the tile manager
with raster get rasterized, but using a fake gpu rasterizer.

But, since you're constructing the GpuRasterizer directly in here, you're making
creating that test harder

Please add a unit test for tile manager and adjust the way this works
accordingly.

[slavi, 2013/12/04 02:06:50]

Done.

+          this, context_provider, resource_provider)),
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
@@ -800,6 +805,7 @@ void TileManager::ScheduleTasks(
   TRACE_EVENT1("cc", "TileManager::ScheduleTasks",
                "count", tiles_that_need_to_be_rasterized.size());
   RasterWorkerPool::RasterTask::Queue tasks;
+  GpuRasterizer::Queue gpu_raster_tasks;
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
@@ -816,10 +822,17 @@ 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 (tile->use_gpu_rasterizer()) {
+      scoped_ptr<ResourcePool::Resource> resource =
+          resource_pool_->AcquireResource(tile->tile_size_.size());
 
-    tasks.Append(tile_version.raster_task_, tile->required_for_activation());
+      gpu_raster_tasks.Append(tile, resource.Pass());
+    } else {
+      if (tile_version.raster_task_.is_null())
+        tile_version.raster_task_ = CreateRasterTask(tile);
+
+      tasks.Append(tile_version.raster_task_, tile->required_for_activation());
+    }
   }
 
   // We must reduce the amount of unused resoruces before calling
@@ -832,6 +845,9 @@ void TileManager::ScheduleTasks(
   raster_worker_pool_->ScheduleTasks(&tasks);
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
+
+  gpu_rasterizer_->Rasterize(gpu_raster_tasks,
+                             rendering_stats_instrumentation_);
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
@@ -964,6 +980,27 @@ void TileManager::OnRasterTaskCompleted(
     did_initialize_visible_tile_ = true;
 }
 
+void TileManager::OnGpuRasterTaskCompleted(
+    Tile* tile,
+    scoped_ptr<ResourcePool::Resource> resource) {
+  ManagedTileState& mts = tile->managed_state();
+  ManagedTileState::TileVersion& tile_version =
+      mts.tile_versions[mts.raster_mode];
+  DCHECK(tile_version.raster_task_.is_null());
+
+  ++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,
@@ -971,7 +1008,8 @@ scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             float contents_scale,
                                             int layer_id,
                                             int source_frame_number,
-                                            bool can_use_lcd_text) {
+                                            bool can_use_lcd_text,
+                                            bool use_gpu_rasterizer) {
   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
                                                          picture_pile,
                                                          tile_size,
@@ -980,7 +1018,8 @@ scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                                          contents_scale,
                                                          layer_id,
                                                          source_frame_number,
-                                                         can_use_lcd_text));
+                                                         can_use_lcd_text,
+                                                         use_gpu_rasterizer));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;