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_map_image,
+    bool use_ganesh,
     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(
+                            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)
+  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 189 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());
   RasterWorkerPool::RasterTask::Queue tasks;
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
+  GaneshRasterizer::RasterTaskVector ganesh_tasks;
+
   // 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())
-      tile_version.raster_task_ = CreateRasterTask(tile);
+    // TODO(skaslev) Set proper raster_mode somewhere else,
+    // e.g. AssignGpuMemoryToTiles.
+    if (mts.raster_mode == GANESH_RASTER_MODE) {
+      ganesh_tasks.push_back(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_tasks.empty()) {
+    ganesh_rasterizer_->Rasterize(
+        ganesh_tasks, rendering_stats_instrumentation_);
+  }
 }
 
 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);
 }
 
+GaneshRasterizer::RasterTask* TileManager::CreateGaneshRasterTask(Tile* tile) {
+  scoped_ptr<ResourcePool::Resource> resource =
+    resource_pool_->AcquireResource(tile->tile_size_.size(),
+                                    ganesh_rasterizer_->GetResourceFormat());
+  return ganesh_rasterizer_->CreateRasterTask(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