cc: Add tile pool to tile manager.

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 136 matching lines @@
     return SOON_BIN;
 
   return EVENTUALLY_BIN;
 }
 
 // Limit to the number of raster tasks that can be scheduled.
 // This is high enough to not cause unnecessary scheduling but
 // gives us an insurance that we're not spending a huge amount
 // of time scheduling one enormous set of tasks.
 const size_t kMaxRasterTasks = 256u;
+const size_t kTilePoolSize = 256u;
 
 }  // namespace
 
 RasterTaskCompletionStats::RasterTaskCompletionStats()
     : completed_count(0u),
       canceled_count(0u) {
 }
 
 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
     const RasterTaskCompletionStats& stats) {
@@ skipping 39 matching lines @@
       all_tiles_required_for_activation_have_memory_(true),
       memory_required_bytes_(0),
       memory_nice_to_have_bytes_(0),
       bytes_releasable_(0),
       resources_releasable_(0),
       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);
+  tile_pool_.reserve(kTilePoolSize);
 }
 
 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());
 
+  for (size_t i = 0; i < tile_pool_.size(); ++i)
+    delete tile_pool_[i];
+  tile_pool_.clear();
+
   RasterWorkerPool::RasterTask::Queue empty;
   raster_worker_pool_->ScheduleTasks(&empty);
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_->Shutdown();
   raster_worker_pool_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
@@ skipping 10 matching lines @@
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
 void TileManager::CleanUpReleasedTiles() {
   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
        it != released_tiles_.end();
        ++it) {
     Tile* tile = *it;
+    ManagedTileState& mts = tile->managed_state();
 
-    FreeResourcesForTile(tile);
+    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+      FreeResourceForTile(tile, static_cast<RasterMode>(mode));
+      mts.tile_versions[mode].set_use_resource();
+      mts.tile_versions[mode].raster_task_.Reset();
+    }
+    tile->reset_picture_pile();
 
     DCHECK(tiles_.find(tile->id()) != tiles_.end());
     tiles_.erase(tile->id());
 
     LayerCountMap::iterator layer_it =
         used_layer_counts_.find(tile->layer_id());
     DCHECK_GT(layer_it->second, 0);
     if (--layer_it->second == 0) {
       used_layer_counts_.erase(layer_it);
       image_decode_tasks_.erase(tile->layer_id());
     }
 
-    delete tile;
+    if (tile_pool_.size() < kTilePoolSize)
+      tile_pool_.push_back(tile);
+    else
+      delete tile;
   }
 
   released_tiles_.clear();
 }
 
 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
   if (!prioritized_tiles_dirty_)
     return;
 
   CleanUpReleasedTiles();
@@ skipping 528 matching lines @@
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref)));
 }
 
 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
-          tile->tile_size_.size(),
+          tile->tile_size_,
           raster_worker_pool_->GetResourceFormat());
   const Resource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   RasterWorkerPool::Task::Set decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
        iter; ++iter) {
@@ skipping 102 matching lines @@
 }
 
 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));
+  scoped_refptr<Tile> tile;
+  if (!tile_pool_.empty()) {
+    tile = make_scoped_refptr(tile_pool_.back());
+    tile_pool_.pop_back();
+  } else {
+    tile = make_scoped_refptr(new Tile(this));
+  }
+
+  tile->Reset(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