Replace uses of hash_map in //base

base/id_map.h

 // Copyright (c) 2011 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_ID_MAP_H_
 #define BASE_ID_MAP_H_
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <memory>
 #include <set>
 #include <type_traits>
+#include <unordered_map>
 #include <utility>
 
-#include "base/containers/hash_tables.h"
+#include "base/containers/flat_set.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sequence_checker.h"
 
 // This object maintains a list of IDs that can be quickly converted to
 // pointers to objects. It is implemented as a hash table, optimized for
 // relatively small data sets (in the common case, there will be exactly one
 // item in the list).
 //
 // Items can be inserted into the container with arbitrary ID, but the caller
 // must ensure they are unique. Inserting IDs and relying on automatically
 // generated ones is not allowed because they can collide.
 
 // The map's value type (the V param) can be any dereferenceable type, such as a
 // raw pointer or smart pointer
 template <typename V, typename K = int32_t>
 class IDMap final {
  public:
   using KeyType = K;
 
  private:
   using T = typename std::remove_reference<decltype(*V())>::type;
-  using HashTable = base::hash_map<KeyType, V>;
+
+  using HashTable = std::unordered_map<KeyType, V>;
 
  public:
   IDMap() : iteration_depth_(0), next_id_(1), check_on_null_data_(false) {
     // A number of consumers of IDMap create it on one thread but always
     // access it from a different, but consistent, thread (or sequence)
     // post-construction. The first call to CalledOnValidSequence() will re-bind
     // it.
     sequence_checker_.DetachFromSequence();
   }
 
@@ skipping 180 matching lines @@
     removed_ids_.clear();
   }
 
   // Keep track of how many iterators are currently iterating on us to safely
   // handle removing items during iteration.
   int iteration_depth_;
 
   // Keep set of IDs that should be removed after the outermost iteration has
   // finished. This way we manage to not invalidate the iterator when an element
   // is removed.
-  std::set<KeyType> removed_ids_;
+  base::flat_set<KeyType> removed_ids_;
 
   // The next ID that we will return from Add()
   KeyType next_id_;
 
   HashTable data_;
 
   // See description above setter.
   bool check_on_null_data_;
 
   base::SequenceChecker sequence_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(IDMap);
 };
 
 #endif  // BASE_ID_MAP_H_