Added preliminary support for tile rasterization with Ganesh

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>
 
@@ skipping 150 matching lines @@
   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,
     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) {
   return make_scoped_ptr(
       new TileManager(client,
                       resource_provider,
                       use_map_image ?
                       ImageRasterWorkerPool::Create(
                           resource_provider, num_raster_threads) :
                       PixelBufferRasterWorkerPool::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));
 }
 
 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),
       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) {
   raster_worker_pool_->SetClient(this);
+  if (ganesh_rasterizer_)
+    ganesh_rasterizer_->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());
 
@@ skipping 357 matching lines @@
   return requirements.PassAs<base::Value>();
 }
 
 RasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
   DCHECK(tile);
   DCHECK(tile->picture_pile());
 
   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;
   else if (tile->can_use_lcd_text())
     raster_mode = HIGH_QUALITY_RASTER_MODE;
   else if (mts.tile_versions[current_mode].has_text_ ||
            !mts.tile_versions[current_mode].IsReadyToDraw())
     raster_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
 
   return std::min(raster_mode, current_mode);
@@ skipping 202 matching lines @@
        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);
+    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
   // ScheduleTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Schedule running of |tasks|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |tasks|.
   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(
     Tile* tile, skia::LazyPixelRef* pixel_ref) {
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
       tile->layer_id(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
@@ skipping 46 matching lines @@
       tile->source_frame_number(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
       &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,
     bool was_canceled) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
   if (!was_canceled)
     return;
 
   LayerPixelRefTaskMap::iterator layer_it =
@@ skipping 48 matching lines @@
 
     bytes_releasable_ += BytesConsumedIfAllocated(tile);
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     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,
                                             gfx::Rect opaque_rect,
                                             float contents_scale,
                                             int layer_id,
                                             int source_frame_number,
                                             bool can_use_lcd_text) {
   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
                                                          picture_pile,
                                                          tile_size,
                                                          content_rect,
                                                          opaque_rect,
                                                          contents_scale,
                                                          layer_id,
                                                          source_frame_number,
                                                          can_use_lcd_text));
   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