cc: Reduce time spent in AssignGpuMemoryToTiles().

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 <set>
 
 #include "base/bind.h"
@@ skipping 116 matching lines @@
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider,
                                           Renderer::ImplPool)),
       manage_tiles_pending_(false),
+      manage_tiles_call_count_(0),
       check_for_completed_set_pixels_pending_(false) {
   // Initialize all threads.
   const std::string thread_name_prefix = kRasterThreadNamePrefix;
   while (raster_threads_.size() < num_raster_threads) {
     int thread_number = raster_threads_.size() + 1;
     scoped_ptr<RasterThread> thread = make_scoped_ptr(
         new RasterThread(thread_name_prefix +
                          StringPrintf("Worker%d", thread_number).c_str()));
     raster_threads_.append(thread.Pass());
   }
@@ skipping 80 matching lines @@
 
     return
       ams.time_to_needed_in_seconds <
       bms.time_to_needed_in_seconds;
   }
 };
 
 void TileManager::ManageTiles() {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
   manage_tiles_pending_ = false;
+  ++manage_tiles_call_count_;
 
   // The amount of time for which we want to have prepainting coverage.
   const double prepainting_window_time_seconds = 1.0;
   const double backfling_guard_distance_pixels = 314.0;
 
   const bool smoothness_takes_priority = global_state_.smoothness_takes_priority;
 
   // Bin into three categories of tiles: things we need now, things we need soon, and eventually
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
@@ skipping 308 matching lines @@
       picture_pile_clone.get(),
       resource_pool_->resource_provider()->mapPixelBuffer(resource_id),
       tile->content_rect_,
       tile->contents_scale(),
       stats,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  picture_pile_clone,
+                 manage_tiles_call_count_,
                  stats));
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     scoped_refptr<PicturePileImpl> picture_pile_clone,
+    int manage_tiles_call_count_when_dispatched,
     RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
   rendering_stats_.totalRasterizeTimeInSeconds +=
     stats->totalRasterizeTimeInSeconds;
   rendering_stats_.totalPixelsRasterized += stats->totalPixelsRasterized;
   delete stats;
 
   // 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
-  // tiles. The result of this could be that this tile is no longer
-  // allowed to use gpu memory and in that case we need to abort
-  // initialization and free all associated resources before calling
-  // DispatchMoreTasks().
-  AssignGpuMemoryToTiles();
+  // tiles if ManageTiles() was called since task was dispatched. The result
+  // of this could be that this tile is no longer allowed to use gpu
+  // memory and in that case we need to abort initialization and free all
+  // associated resources before calling DispatchMoreTasks().
+  if (manage_tiles_call_count_when_dispatched != manage_tiles_call_count_)
+    AssignGpuMemoryToTiles();
 
   // Finish resource initialization if |can_use_gpu_memory| is true.
   if (managed_tile_state.can_use_gpu_memory) {
     // The component order may be bgra if we're uploading bgra pixels to rgba
     // texture. Mark contents as swizzled if image component order is
     // different than texture format.
     managed_tile_state.contents_swizzled =
         !PlatformColor::sameComponentOrder(tile->format_);
 
     // Tile resources can't be freed until upload has completed.
@@ skipping 13 matching lines @@
 }
 
 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;
 }
 
 }