Replace uses of hash_map in //base

base/containers/small_map.h

 // Copyright (c) 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 BASE_CONTAINERS_SMALL_MAP_H_
 #define BASE_CONTAINERS_SMALL_MAP_H_
 
 #include <stddef.h>
 
 #include <map>
 #include <string>
 #include <utility>
 
-#include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/manual_constructor.h"
 
 namespace base {
 
 // An STL-like associative container which starts out backed by a simple
 // array but switches to some other container type if it grows beyond a
 // fixed size.
 //
 // WHAT TYPE OF MAP SHOULD YOU USE?
@@ skipping 15 matching lines @@
 //  - base::small_map combines the performance benefits of the
 //    brute-force-searched vector for small cases (no extra heap allocations),
 //    but can efficiently fall back if you end up adding many items. It will
 //    generate more code than std::map (at least 160 bytes for operator[])
 //    which is bad if you have a "weird" key where map functions can't be
 //    duplicate-code-eliminated. If you have a one-off key and aren't in
 //    performance-critical code, this bloat may negate some of the benefits and
 //    you should consider on of the other options.
 //
 // base::small_map will pick up the comparator from the underlying map type. In
-// std::map (and in MSVC additionally hash_map) only a "less" operator is
-// defined, which requires us to do two comparisons per element when doing the
-// brute-force search in the simple array.
+// std::map a "less" operator is defined, which requires us to do two
+// comparisons per element when doing the brute-force search in the simple
+// array.
 //
 // We define default overrides for the common map types to avoid this
 // double-compare, but you should be aware of this if you use your own
 // operator< for your map and supply yor own version of == to the small_map.
 // You can use regular operator== by just doing:
 //
 //   base::small_map<std::map<MyKey, MyValue>, 4, std::equal_to<KyKey>>
 //
 //
 // USAGE
 // -----
 //
 // NormalMap:  The map type to fall back to.  This also defines the key
 //             and value types for the small_map.
 // kArraySize:  The size of the initial array of results. This will be
 //              allocated with the small_map object rather than separately on
 //              the heap. Once the map grows beyond this size, the map type
 //              will be used instead.
-// EqualKey:  A functor which tests two keys for equality.  If the wrapped
-//            map type has a "key_equal" member (hash_map does), then that will
-//            be used by default. If the wrapped map type has a strict weak
-//            ordering "key_compare" (std::map does), that will be used to
+// EqualKey:  A functor which tests two keys for equality. If the wrapped
+//            map type has a "key_equal" member (unordered_map does), then that
+//            will be used by default. If the wrapped map type has a strict
+//            weak ordering "key_compare" (std::map does), that will be used to
 //            implement equality by default.
 // MapInit: A functor that takes a ManualConstructor<NormalMap>* and uses it to
 //          initialize the map. This functor will be called at most once per
 //          small_map, when the map exceeds the threshold of kArraySize and we
 //          are about to copy values from the array to the map. The functor
 //          *must* call one of the Init() methods provided by
 //          ManualConstructor, since after it runs we assume that the NormalMap
 //          has been initialized.
 //
 // example:
@@ skipping 50 matching lines @@
                     const typename M::key_type& right) {
       // Implements equality in terms of a strict weak ordering comparator.
       typename M::key_compare comp;
       return !comp(left, right) && !comp(right, left);
     }
   };
 };
 
 // Provide overrides to use operator== for key compare for the "normal" map and
 // hash map types. If you override the default comparator or allocator for a
-// map or hash_map, or use another type of map, this won't get used.
-//
-// If we switch to using std::unordered_map for base::hash_map, then the
-// hash_map specialization can be removed.
+// map or unordered_map, or use another type of map, this won't get used.
 template <typename KeyType, typename ValueType>
-struct select_equal_key< std::map<KeyType, ValueType>, false> {
+struct select_equal_key<std::map<KeyType, ValueType>, false> {
   struct equal_key {
     bool operator()(const KeyType& left, const KeyType& right) {
       return left == right;
-    }
-  };
-};
-template <typename KeyType, typename ValueType>
-struct select_equal_key< base::hash_map<KeyType, ValueType>, false> {
-  struct equal_key {
-    bool operator()(const KeyType& left, const KeyType& right) {
-      return left == right;
     }
   };
 };
 
 // Partial template specialization handles case where M::key_equal exists, e.g.,
-// hash_map<>.
+// unordered_map<>.
 template <typename M>
 struct select_equal_key<M, true> {
   typedef typename M::key_equal equal_key;
 };
 
 }  // namespace internal
 
 template <typename NormalMap,
           int kArraySize = 4,
           typename EqualKey = typename internal::select_equal_key<
@@ skipping 377 matching lines @@
   inline NormalMap* map() {
     CHECK(UsingFullMap());
     return map_.get();
   }
   inline const NormalMap* map() const {
     CHECK(UsingFullMap());
     return map_.get();
   }
 
  private:
-  int size_;  // negative = using hash_map
+  int size_;  // negative = using map

[Łukasz Anforowicz, 2017/04/24 18:46:10]

nit: s/using map/using |map_| instead of |array_|./g ?

 
   MapInit functor_;
 
   // We want to call constructors and destructors manually, but we don't
   // want to allocate and deallocate the memory used for them separately.
   // So, we use this crazy ManualConstructor class. Since C++11 it's possible
   // to use objects in unions like this, but the ManualDestructor syntax is
   // a bit better and doesn't have limitations on object type.
   //
   // Since array_ and map_ are mutually exclusive, we'll put them in a
@@ skipping 60 matching lines @@
           typename EqualKey,
           typename Functor>
 inline bool small_map<NormalMap, kArraySize, EqualKey, Functor>::iterator::
 operator!=(const const_iterator& other) const {
   return other != *this;
 }
 
 }  // namespace base
 
 #endif  // BASE_CONTAINERS_SMALL_MAP_H_