HACK: Rasterize tiles immediately if there are only a few of them

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 516 matching lines @@
   // Because tiles in the image decoding list have higher priorities, we
   // need to process those tiles first before we start to handle the tiles
   // in the need_to_be_rasterized queue.
   for(TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ) {
     DispatchImageDecodeTasksForTile(*it);
     ManagedTileState& managed_state = (*it)->managed_state();
     if (managed_state.pending_pixel_refs.empty()) {
       if (!CanDispatchRasterTask(*it))
         return;
-      DispatchOneRasterTask(*it);
+      DispatchOneRasterTask(*it, false);
       tiles_with_image_decoding_tasks_.erase(it++);
     } else {
       ++it;
     }
   }
 
   // Process all tiles in the need_to_be_rasterized queue. If a tile has
   // image decoding tasks, put it to the back of the image decoding list.
   while (!tiles_that_need_to_be_rasterized_.empty()) {
     Tile* tile = tiles_that_need_to_be_rasterized_.back();
     DispatchImageDecodeTasksForTile(tile);
     ManagedTileState& managed_state = tile->managed_state();
     if (!managed_state.pending_pixel_refs.empty()) {
       tiles_with_image_decoding_tasks_.push_back(tile);
     } else {
       if (!CanDispatchRasterTask(tile))
         return;
-      DispatchOneRasterTask(tile);
+      bool immediate =
+          tiles_that_need_to_be_rasterized_.size() < 5;
+      DispatchOneRasterTask(tile, immediate);
     }
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
 void TileManager::GatherPixelRefsForTile(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::GatherPixelRefsForTile");
   ManagedTileState& managed_state = tile->managed_state();
   if (managed_state.need_to_gather_pixel_refs) {
     base::TimeTicks gather_begin_time = base::TimeTicks::Now();
@@ skipping 62 matching lines @@
       if (pixel_ref_id == (*pixel_it)->getGenerationID()) {
         pixel_refs.erase(pixel_it);
         break;
       }
     }
   }
 
   DispatchMoreTasks();
 }
 
-void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
+void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile,
+                                        bool immediate) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource->id());
 
   managed_tile_state.resource_is_being_initialized = true;
   managed_tile_state.can_be_freed = false;
 
   DidTileRasterStateChange(tile, RASTER_STATE);
 
   ResourceProvider::ResourceId resource_id = resource->id();
 
+  if (immediate) {
+    RunRasterTask(resource_pool_->resource_provider()->mapPixelBuffer(
+                      resource_id),
+                  tile->content_rect_,
+                  tile->contents_scale(),
+                  tile->picture_pile(),
+                  &rendering_stats_);
+    TileManager::OnRasterTaskCompleted(tile, resource.Pass(),
+                                       manage_tiles_call_count_,
+                                       false);
+    return;
+  }
+
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
       base::Bind(&TileManager::RunRasterTask,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
                  tile->contents_scale()),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
-                 manage_tiles_call_count_));
+                 manage_tiles_call_count_,
+                 true));
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
-    int manage_tiles_call_count_when_dispatched) {
+    int manage_tiles_call_count_when_dispatched,
+    bool dispatch_more) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
 
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   managed_tile_state.can_be_freed = true;
 
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
@@ skipping 22 matching lines @@
     bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, SET_PIXELS_STATE);
     tiles_with_pending_set_pixels_.push(tile);
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     managed_tile_state.resource_is_being_initialized = false;
     DidTileRasterStateChange(tile, IDLE_STATE);
   }
 
-  DispatchMoreTasks();
+  if (dispatch_more)
+    DispatchMoreTasks();
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.resource);
   managed_tile_state.resource_is_being_initialized = false;
   managed_tile_state.can_be_freed = true;
 }
 
 void TileManager::DidTileRasterStateChange(Tile* tile, TileRasterState state) {
@@ skipping 49 matching lines @@
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   stats->totalDeferredImageDecodeCount++;
   stats->totalDeferredImageDecodeTime +=
       base::TimeTicks::Now() - decode_begin_time;
 }
 
 }  // namespace cc