changing std::vector to std::set for all_tiles_

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 191 matching lines @@
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(global_state_.memory_limit_in_bytes);
   ScheduleManageTiles();
 }
 
 void TileManager::RegisterTile(Tile* tile) {
-  all_tiles_.push_back(tile);
+  all_tiles_.insert(tile);
 
   const ManagedTileState& mts = tile->managed_state();
   for (int i = 0; i < NUM_TREES; ++i)
     ++raster_state_count_[mts.raster_state][i][mts.tree_bin[i]];
 
   ScheduleManageTiles();
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
   for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
@@ skipping 10 matching lines @@
       break;
     }
   }
   for (TileVector::iterator it = live_or_allocated_tiles_.begin();
        it != live_or_allocated_tiles_.end(); it++) {
     if (*it == tile) {
       live_or_allocated_tiles_.erase(it);
       break;
     }
   }
-  for (TileVector::iterator it = all_tiles_.begin();
-       it != all_tiles_.end(); it++) {
-    if (*it == tile) {
-      const ManagedTileState& mts = tile->managed_state();
-      for (int i = 0; i < NUM_TREES; ++i)
-        --raster_state_count_[mts.raster_state][i][mts.tree_bin[i]];
-      FreeResourcesForTile(tile);
-      all_tiles_.erase(it);
-      return;
-    }
-  }
-  DCHECK(false) << "Could not find tile version.";
+  TileSet::iterator it = all_tiles_.find(tile);
+  DCHECK(it != all_tiles_.end());
+  const ManagedTileState& mts = tile->managed_state();
+  for (int i = 0; i < NUM_TREES; ++i)
+    --raster_state_count_[mts.raster_state][i][mts.tree_bin[i]];
+  FreeResourcesForTile(tile);
+  all_tiles_.erase(it);
 }
 
 class BinComparator {
 public:
   bool operator() (const Tile* a, const Tile* b) const {
     const ManagedTileState& ams = a->managed_state();
     const ManagedTileState& bms = b->managed_state();
     if (ams.bin[HIGH_PRIORITY_BIN] != bms.bin[HIGH_PRIORITY_BIN])
       return ams.bin[HIGH_PRIORITY_BIN] < bms.bin[HIGH_PRIORITY_BIN];
 
@@ skipping 50 matching lines @@
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else {
     bin_map[NOW_BIN] = NOW_BIN;
     bin_map[SOON_BIN] = SOON_BIN;
     bin_map[EVENTUALLY_BIN] = EVENTUALLY_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   }
 
   live_or_allocated_tiles_.clear();
   // For each tree, bin into different categories of tiles.
-  for (TileVector::iterator it = all_tiles_.begin();
+  for (TileSet::iterator it = all_tiles_.begin();
        it != all_tiles_.end(); ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
 
     TilePriority prio[NUM_BIN_PRIORITIES];
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
         prio[HIGH_PRIORITY_BIN] = prio[LOW_PRIORITY_BIN] =
             tile->combined_priority();
         break;
@@ skipping 126 matching lines @@
     scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
     state->SetInteger("tile_count", all_tiles_.size());
 
     state->Set("global_state", global_state_.AsValue().release());
 
     state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
     return state.PassAs<base::Value>();
 }
 scoped_ptr<base::Value> TileManager::AllTilesAsValue() const {
     scoped_ptr<base::ListValue> state(new base::ListValue());
-    for (size_t i = 0; i < all_tiles_.size(); i++)
-        state->Append(all_tiles_[i]->AsValue().release());
+    for (TileSet::const_iterator it = all_tiles_.begin();
+         it != all_tiles_.end(); it++) {
+        state->Append((*it)->AsValue().release());
+    }
     return state.PassAs<base::Value>();
 }
 
 scoped_ptr<base::Value> TileManager::GetMemoryRequirementsAsValue() const {
   scoped_ptr<base::DictionaryValue> requirements(
       new base::DictionaryValue());
 
   size_t memoryRequiredBytes;
   size_t memoryNiceToHaveBytes;
   size_t memoryUsedBytes;
@@ skipping 470 matching lines @@
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc