Switch cc to std::unordered_*.

cc/tiles/picture_layer_tiling.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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
 
-#include "base/containers/hash_tables.h"
 #include "base/containers/small_map.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/playback/display_list_raster_source.h"
 #include "cc/tiles/prioritized_tile.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
@@ skipping 85 matching lines @@
   const int j = info.tiling_j_index;
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
 
   if (!raster_source_->CoversRect(info.enclosing_layer_rect))
     return nullptr;
 
   all_tiles_done_ = false;
   ScopedTilePtr tile = client_->CreateTile(info);
   Tile* raw_ptr = tile.get();
-  tiles_.add(key, std::move(tile));
+  tiles_[key] = std::move(tile);
   return raw_ptr;
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* active_twin =
       tree_ == PENDING_TREE ? client_->GetPendingOrActiveTwinTiling(this)
                             : nullptr;
   const Region* invalidation =
       active_twin ? client_->GetPendingInvalidation() : nullptr;
 
@@ skipping 48 matching lines @@
     create_missing_tiles = true;
   } else {
     SetLiveTilesRect(pending_twin->live_tiles_rect());
   }
 
   if (tiles_.empty()) {
     tiles_.swap(pending_twin->tiles_);
     all_tiles_done_ = pending_twin->all_tiles_done_;
   } else {
     while (!pending_twin->tiles_.empty()) {
-      TileMapKey key = pending_twin->tiles_.begin()->first;
-      tiles_.set(key, pending_twin->tiles_.take_and_erase(key));
+      auto iter = pending_twin->tiles_.begin();

[danakj, 2016/01/14 21:12:32]

nit: pending_iter?

[davidben, 2016/01/21 01:33:57]

Done.

+      tiles_[iter->first] = std::move(iter->second);
+      pending_twin->tiles_.erase(iter);
     }
     all_tiles_done_ &= pending_twin->all_tiles_done_;
   }
   DCHECK(pending_twin->tiles_.empty());
   pending_twin->all_tiles_done_ = true;
 
   if (create_missing_tiles)
     CreateMissingTilesInLiveTilesRect();
 
   VerifyLiveTilesRect(false);
@@ skipping 88 matching lines @@
   DCHECK(tree_ != ACTIVE_TREE || !client_->GetPendingOrActiveTwinTiling(this));
   RemoveTilesInRegion(layer_invalidation, true /* recreate tiles */);
 }
 
 void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_invalidation,
                                              bool recreate_tiles) {
   // We only invalidate the active tiling when it's orphaned: it has no pending
   // twin, so it's slated for removal in the future.
   if (live_tiles_rect_.IsEmpty())
     return;
-  // Pick 16 for the size of the SmallMap before it promotes to a hash_map.
+  // Pick 16 for the size of the SmallMap before it promotes to a unordered_map.
   // 4x4 tiles should cover most small invalidations, and walking a vector of
   // 16 is fast enough. If an invalidation is huge we will fall back to a
-  // hash_map instead of a vector in the SmallMap.
-  base::SmallMap<base::hash_map<TileMapKey, gfx::Rect>, 16> remove_tiles;
+  // unordered_map instead of a vector in the SmallMap.
+  base::SmallMap<std::unordered_map<TileMapKey, gfx::Rect, TileMapKeyHash>, 16>
+      remove_tiles;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_invalidation); iter.has_rect();
        iter.next()) {
     gfx::Rect layer_rect = iter.rect();
     // The pixels which are invalid in content space.
     gfx::Rect invalid_content_rect =
         gfx::ScaleToEnclosingRect(layer_rect, contents_scale_);
     gfx::Rect coverage_content_rect = invalid_content_rect;
     // Avoid needless work by not bothering to invalidate where there aren't
@@ skipping 226 matching lines @@
     return texture_rect;
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
 
   return texture_rect;
 }
 
 ScopedTilePtr PictureLayerTiling::TakeTileAt(int i, int j) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return nullptr;
-  return tiles_.take_and_erase(found);
+  ScopedTilePtr result = std::move(found->second);
+  tiles_.erase(found);
+  return result;
 }
 
 bool PictureLayerTiling::RemoveTileAt(int i, int j) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
   tiles_.erase(found);
   return true;
 }
 
@@ skipping 366 matching lines @@
 
   return PrioritizedTile(tile, raster_source(),
                          ComputePriorityForTile(tile, priority_rect_type),
                          IsTileOccluded(tile));
 }
 
 std::map<const Tile*, PrioritizedTile>
 PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
-    Tile* tile = key_tile_pair.second;
+    Tile* tile = key_tile_pair.second.get();
     UpdateRequiredStatesOnTile(tile);
     PrioritizedTile prioritized_tile =
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile));
     result.insert(std::make_pair(prioritized_tile.tile(), prioritized_tile));
   }
   return result;
 }
 
 TilePriority PictureLayerTiling::ComputePriorityForTile(
     const Tile* tile,
@@ skipping 50 matching lines @@
   if (current_soon_border_rect_.Intersects(tile_bounds))
     return SOON_BORDER_RECT;
 
   DCHECK(current_eventually_rect_.Intersects(tile_bounds));
   return EVENTUALLY_RECT;
 }
 
 void PictureLayerTiling::GetAllPrioritizedTilesForTracing(
     std::vector<PrioritizedTile>* prioritized_tiles) const {
   for (const auto& tile_pair : tiles_) {
-    Tile* tile = tile_pair.second;
+    Tile* tile = tile_pair.second.get();
     prioritized_tiles->push_back(
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile)));
   }
 }
 
 void PictureLayerTiling::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetInteger("num_tiles", base::saturated_cast<int>(tiles_.size()));
   state->SetDouble("content_scale", contents_scale_);
   MathUtil::AddToTracedValue("visible_rect", current_visible_rect_, state);
   MathUtil::AddToTracedValue("skewport_rect", current_skewport_rect_, state);
   MathUtil::AddToTracedValue("soon_rect", current_soon_border_rect_, state);
   MathUtil::AddToTracedValue("eventually_rect", current_eventually_rect_,
                              state);
   MathUtil::AddToTracedValue("tiling_size", tiling_size(), state);
 }
 
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    const Tile* tile = it->second;
+    const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 }  // namespace cc