Switch cc to std::unordered_*.

cc/tiles/picture_layer_tiling.h

 // 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.
 
 #ifndef CC_TILES_PICTURE_LAYER_TILING_H_
 #define CC_TILES_PICTURE_LAYER_TILING_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/tiling_data.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #include "cc/trees/occlusion.h"
 #include "ui/gfx/geometry/rect.h"
 
@@ skipping 34 matching lines @@
       : index_x(index.first), index_y(index.second) {}
 
   bool operator==(const TileMapKey& other) const {
     return index_x == other.index_x && index_y == other.index_y;
   }
 
   int index_x;
   int index_y;
 };
 
-}  // namespace cc
-
-namespace BASE_HASH_NAMESPACE {
-template <>
-struct hash<cc::TileMapKey> {
-  size_t operator()(const cc::TileMapKey& key) const {
+struct TileMapKeyHash {
+  size_t operator()(const TileMapKey& key) const {
     uint16_t value1 = static_cast<uint16_t>(key.index_x);
     uint16_t value2 = static_cast<uint16_t>(key.index_y);
     uint32_t value1_32 = value1;
     return (value1_32 << 16) | value2;
   }
 };
-}  // namespace BASE_HASH_NAMESPACE
-
-namespace cc {
 
 class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
 
   PictureLayerTilingClient* client() const { return client_; }
   ~PictureLayerTiling();
 
   static float CalculateSoonBorderDistance(
       const gfx::Rect& visible_rect_in_content_space,
@@ skipping 38 matching lines @@
     return raster_source_.get();
   }
   gfx::Size tiling_size() const { return tiling_data_.tiling_size(); }
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
   float contents_scale() const { return contents_scale_; }
   const TilingData* tiling_data() const { return &tiling_data_; }
 
   Tile* TileAt(int i, int j) const {
     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
-    return iter == tiles_.end() ? nullptr : iter->second;
+    return iter == tiles_.end() ? nullptr : iter->second.get();
   }
 
   bool has_tiles() const { return !tiles_.empty(); }
   // all_tiles_done() can return false negatives.
   bool all_tiles_done() const { return all_tiles_done_; }
   void set_all_tiles_done(bool all_tiles_done) {
     all_tiles_done_ = all_tiles_done;
   }
 
   void VerifyNoTileNeedsRaster() const {
 #if DCHECK_IS_ON()
-    for (const auto tile_pair : tiles_) {
+    for (const auto& tile_pair : tiles_) {
       DCHECK(!tile_pair.second->draw_info().NeedsRaster() ||
-             IsTileOccluded(tile_pair.second));
+             IsTileOccluded(tile_pair.second.get()));
     }
 #endif  // DCHECK_IS_ON()
   }
 
   // For testing functionality.
   void CreateAllTilesForTesting() {
     SetLiveTilesRect(gfx::Rect(tiling_data_.tiling_size()));
   }
   const TilingData& TilingDataForTesting() const { return tiling_data_; }
   std::vector<Tile*> AllTilesForTesting() const {
     std::vector<Tile*> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-      all_tiles.push_back(it->second);
+      all_tiles.push_back(it->second.get());
     return all_tiles;
   }
 
   void UpdateAllRequiredStateForTesting() {
     for (const auto& key_tile_pair : tiles_)
-      UpdateRequiredStatesOnTile(key_tile_pair.second);
+      UpdateRequiredStatesOnTile(key_tile_pair.second.get());
   }
   std::map<const Tile*, PrioritizedTile>
   UpdateAndGetAllPrioritizedTilesForTesting() const;
 
   void SetAllTilesOccludedForTesting() {
     gfx::Rect viewport_in_layer_space =
         ScaleToEnclosingRect(current_visible_rect_, 1.0f / contents_scale_);
     current_occlusion_in_layer_space_ =
         Occlusion(gfx::Transform(),
                   SimpleEnclosedRegion(viewport_in_layer_space),
@@ skipping 80 matching lines @@
   // here. Note that when processing a pending tree, this rect is the same as
   // the visible rect so no tiles are processed in this case.
   enum PriorityRectType {
     VISIBLE_RECT,
     PENDING_VISIBLE_RECT,
     SKEWPORT_RECT,
     SOON_BORDER_RECT,
     EVENTUALLY_RECT
   };
 
-  using TileMap = base::ScopedPtrHashMap<TileMapKey, ScopedTilePtr>;
+  using TileMap = std::unordered_map<TileMapKey, ScopedTilePtr, TileMapKeyHash>;
 
   struct FrameVisibleRect {
     gfx::Rect visible_rect_in_content_space;
     double frame_time_in_seconds = 0.0;
   };
 
   PictureLayerTiling(WhichTree tree,
                      float contents_scale,
                      scoped_refptr<DisplayListRasterSource> raster_source,
                      PictureLayerTilingClient* client,
@@ skipping 118 matching lines @@
   float current_content_to_screen_scale_;
   Occlusion current_occlusion_in_layer_space_;
 
   bool has_visible_rect_tiles_;
   bool has_skewport_rect_tiles_;
   bool has_soon_border_rect_tiles_;
   bool has_eventually_rect_tiles_;
   bool all_tiles_done_;
 
  private:
-  DISALLOW_ASSIGN(PictureLayerTiling);
+  DISALLOW_COPY_AND_ASSIGN(PictureLayerTiling);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_PICTURE_LAYER_TILING_H_