diff --git a/quic/core/crypto/proof_source_x509.h b/quic/core/crypto/proof_source_x509.h
index 24975ba..83de1de 100644
--- a/quic/core/crypto/proof_source_x509.h
+++ b/quic/core/crypto/proof_source_x509.h
@@ -9,6 +9,7 @@
 #include <memory>
 
 #include "absl/base/attributes.h"
+#include "absl/container/node_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/crypto/certificate_view.h"
 #include "quic/core/crypto/proof_source.h"
@@ -68,7 +69,7 @@
 
   std::forward_list<Certificate> certificates_;
   Certificate* default_certificate_;
-  QuicUnorderedMap<std::string, Certificate*> certificate_map_;
+  absl::node_hash_map<std::string, Certificate*> certificate_map_;
 };
 
 }  // namespace quic
diff --git a/quic/core/crypto/transport_parameters.h b/quic/core/crypto/transport_parameters.h
index f78cd2c..b6ecb69 100644
--- a/quic/core/crypto/transport_parameters.h
+++ b/quic/core/crypto/transport_parameters.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "quic/core/quic_connection_id.h"
@@ -29,7 +30,7 @@
   // The identifier used to differentiate transport parameters.
   enum TransportParameterId : uint64_t;
   // A map used to specify custom parameters.
-  using ParameterMap = QuicHashMap<TransportParameterId, std::string>;
+  using ParameterMap = absl::flat_hash_map<TransportParameterId, std::string>;
   // Represents an individual QUIC transport parameter that only encodes a
   // variable length integer. Can only be created inside the constructor for
   // TransportParameters.
diff --git a/quic/core/http/http_frames.h b/quic/core/http/http_frames.h
index 6669242..34c3d60 100644
--- a/quic/core/http/http_frames.h
+++ b/quic/core/http/http_frames.h
@@ -11,6 +11,7 @@
 #include <ostream>
 #include <sstream>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/http/http_constants.h"
@@ -70,7 +71,7 @@
 //   affect how endpoints communicate, such as preferences and constraints
 //   on peer behavior
 
-using SettingsMap = QuicHashMap<uint64_t, uint64_t>;
+using SettingsMap = absl::flat_hash_map<uint64_t, uint64_t>;
 
 struct QUIC_EXPORT_PRIVATE SettingsFrame {
   SettingsMap values;
diff --git a/quic/core/http/quic_spdy_client_session_base.h b/quic/core/http/quic_spdy_client_session_base.h
index 01361fd..71236bf 100644
--- a/quic/core/http/quic_spdy_client_session_base.h
+++ b/quic/core/http/quic_spdy_client_session_base.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/quic_crypto_client_stream.h"
 #include "quic/platform/api/quic_containers.h"
@@ -24,7 +25,8 @@
 // to authority constraints).  Clients should use this map to enforce
 // session affinity for requests corresponding to cross-origin push
 // promised streams.
-using QuicPromisedByUrlMap = QuicHashMap<std::string, QuicClientPromisedInfo*>;
+using QuicPromisedByUrlMap =
+    absl::flat_hash_map<std::string, QuicClientPromisedInfo*>;
 
 // The maximum time a promises stream can be reserved without being
 // claimed by a client request.
@@ -126,7 +128,8 @@
   // For QuicSpdyClientStream to detect that a response corresponds to a
   // promise.
   using QuicPromisedByIdMap =
-      QuicHashMap<QuicStreamId, std::unique_ptr<QuicClientPromisedInfo>>;
+      absl::flat_hash_map<QuicStreamId,
+                          std::unique_ptr<QuicClientPromisedInfo>>;
 
   // As per rfc7540, section 10.5: track promise streams in "reserved
   // (remote)".  The primary key is URL from the promise request
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index cda619b..3c3d558 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "quic/core/http/http_frames.h"
@@ -591,7 +592,7 @@
 
   // Priority values received in PRIORITY_UPDATE frames for streams that are not
   // open yet.
-  QuicHashMap<QuicStreamId, int> buffered_stream_priorities_;
+  absl::flat_hash_map<QuicStreamId, int> buffered_stream_priorities_;
 
   // An integer used for live check. The indicator is assigned a value in
   // constructor. As long as it is not the assigned value, that would indicate
diff --git a/quic/core/qpack/qpack_blocking_manager.h b/quic/core/qpack/qpack_blocking_manager.h
index d8c10f1..70870a6 100644
--- a/quic/core/qpack/qpack_blocking_manager.h
+++ b/quic/core/qpack/qpack_blocking_manager.h
@@ -9,6 +9,7 @@
 #include <map>
 #include <set>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/platform/api/quic_export.h"
@@ -77,7 +78,7 @@
   // same time.  Use std::list instead of QuicCircularDeque because it has lower
   // memory footprint when holding few elements.
   using HeaderBlocksForStream = std::list<IndexSet>;
-  using HeaderBlocks = QuicHashMap<QuicStreamId, HeaderBlocksForStream>;
+  using HeaderBlocks = absl::flat_hash_map<QuicStreamId, HeaderBlocksForStream>;
 
   // Increase or decrease the reference count for each index in |indices|.
   void IncreaseReferenceCounts(const IndexSet& indices);
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 14ca07c..4245a5d 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -13,6 +13,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/crypto/quic_compressed_certs_cache.h"
 #include "quic/core/crypto/quic_random.h"
@@ -119,13 +120,14 @@
   void OnConnectionAddedToTimeWaitList(
       QuicConnectionId server_connection_id) override;
 
-  using SessionMap = QuicHashMap<QuicConnectionId,
-                                 std::unique_ptr<QuicSession>,
-                                 QuicConnectionIdHash>;
+  using SessionMap = absl::flat_hash_map<QuicConnectionId,
+                                         std::unique_ptr<QuicSession>,
+                                         QuicConnectionIdHash>;
 
-  using ReferenceCountedSessionMap = QuicHashMap<QuicConnectionId,
-                                                 std::shared_ptr<QuicSession>,
-                                                 QuicConnectionIdHash>;
+  using ReferenceCountedSessionMap =
+      absl::flat_hash_map<QuicConnectionId,
+                          std::shared_ptr<QuicSession>,
+                          QuicConnectionIdHash>;
 
   size_t NumSessions() const;
 
@@ -134,8 +136,8 @@
   // Deletes all sessions on the closed session list and clears the list.
   virtual void DeleteSessions();
 
-  using ConnectionIdMap =
-      QuicHashMap<QuicConnectionId, QuicConnectionId, QuicConnectionIdHash>;
+  using ConnectionIdMap = absl::
+      flat_hash_map<QuicConnectionId, QuicConnectionId, QuicConnectionIdHash>;
 
   // QuicBufferedPacketStore::VisitorInterface implementation.
   void OnExpiredPackets(QuicConnectionId server_connection_id,
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index d9c9b93..cf7f9f7 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "quic/core/frames/quic_ack_frequency_frame.h"
@@ -612,15 +613,16 @@
   }
 
  protected:
-  using StreamMap = QuicHashMap<QuicStreamId, std::unique_ptr<QuicStream>>;
+  using StreamMap =
+      absl::flat_hash_map<QuicStreamId, std::unique_ptr<QuicStream>>;
 
   using PendingStreamMap =
-      QuicHashMap<QuicStreamId, std::unique_ptr<PendingStream>>;
+      absl::flat_hash_map<QuicStreamId, std::unique_ptr<PendingStream>>;
 
   using ClosedStreams = std::vector<std::unique_ptr<QuicStream>>;
 
   using ZombieStreamMap =
-      QuicHashMap<QuicStreamId, std::unique_ptr<QuicStream>>;
+      absl::flat_hash_map<QuicStreamId, std::unique_ptr<QuicStream>>;
 
   // Creates a new stream to handle a peer-initiated stream.
   // Caller does not own the returned stream.
@@ -833,7 +835,7 @@
 
   // Keep track of highest received byte offset of locally closed streams, while
   // waiting for a definitive final highest offset from the peer.
-  QuicHashMap<QuicStreamId, QuicStreamOffset>
+  absl::flat_hash_map<QuicStreamId, QuicStreamOffset>
       locally_closed_streams_highest_offset_;
 
   QuicConnection* connection_;
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index 4e685f9..9b3739b 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -11,6 +11,7 @@
 #include <cstddef>
 #include <memory>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/quic_blocked_writer_interface.h"
 #include "quic/core/quic_connection_id.h"
 #include "quic/core/quic_framer.h"
@@ -294,7 +295,7 @@
   // find the entry, look up the cannoical ConnectionId in
   // indirect_connection_id_map_ first, and look up connection_id_map_ with the
   // cannoical ConnectionId.
-  QuicHashMap<QuicConnectionId, QuicConnectionId, QuicConnectionIdHash>
+  absl::flat_hash_map<QuicConnectionId, QuicConnectionId, QuicConnectionIdHash>
       indirect_connection_id_map_;
 
   // Find an iterator for the given connection_id. Returns
diff --git a/quic/masque/masque_client_session.h b/quic/masque/masque_client_session.h
index 4fc531c..0eab5b2 100644
--- a/quic/masque/masque_client_session.h
+++ b/quic/masque/masque_client_session.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_MASQUE_MASQUE_CLIENT_SESSION_H_
 #define QUICHE_QUIC_MASQUE_MASQUE_CLIENT_SESSION_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/http/quic_spdy_client_session.h"
 #include "quic/masque/masque_compression_engine.h"
@@ -86,9 +87,9 @@
   void UnregisterConnectionId(QuicConnectionId client_connection_id);
 
  private:
-  QuicHashMap<QuicConnectionId,
-              EncapsulatedClientSession*,
-              QuicConnectionIdHash>
+  absl::flat_hash_map<QuicConnectionId,
+                      EncapsulatedClientSession*,
+                      QuicConnectionIdHash>
       client_connection_id_registrations_;
   Owner* owner_;  // Unowned;
   MasqueCompressionEngine compression_engine_;
diff --git a/quic/masque/masque_compression_engine.h b/quic/masque/masque_compression_engine.h
index 1cfc6a1..96c5948 100644
--- a/quic/masque/masque_compression_engine.h
+++ b/quic/masque/masque_compression_engine.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
 #define QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_connection_id.h"
 #include "quic/core/quic_session.h"
@@ -117,7 +118,7 @@
                                bool* version_present);
 
   QuicSession* masque_session_;  // Unowned.
-  QuicHashMap<QuicDatagramFlowId, MasqueCompressionContext> contexts_;
+  absl::flat_hash_map<QuicDatagramFlowId, MasqueCompressionContext> contexts_;
   QuicDatagramFlowId next_flow_id_;
 };
 
diff --git a/quic/masque/masque_dispatcher.h b/quic/masque/masque_dispatcher.h
index 59fc068..2e0186c 100644
--- a/quic/masque/masque_dispatcher.h
+++ b/quic/masque/masque_dispatcher.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_MASQUE_MASQUE_DISPATCHER_H_
 #define QUICHE_QUIC_MASQUE_MASQUE_DISPATCHER_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/masque/masque_server_backend.h"
 #include "quic/masque/masque_server_session.h"
 #include "quic/platform/api/quic_export.h"
@@ -53,7 +54,9 @@
   MasqueServerBackend* masque_server_backend_;  // Unowned.
   // Mapping from client connection IDs to server sessions, allows routing
   // incoming packets to the right MASQUE connection.
-  QuicHashMap<QuicConnectionId, MasqueServerSession*, QuicConnectionIdHash>
+  absl::flat_hash_map<QuicConnectionId,
+                      MasqueServerSession*,
+                      QuicConnectionIdHash>
       client_connection_id_registrations_;
 };
 
diff --git a/quic/masque/masque_server_backend.h b/quic/masque/masque_server_backend.h
index 6fbb623..1809359 100644
--- a/quic/masque/masque_server_backend.h
+++ b/quic/masque/masque_server_backend.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_MASQUE_MASQUE_SERVER_BACKEND_H_
 #define QUICHE_QUIC_MASQUE_MASQUE_SERVER_BACKEND_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/tools/quic_memory_cache_backend.h"
 
@@ -57,9 +58,9 @@
       QuicSimpleServerBackend::RequestHandler* request_handler);
 
   std::string server_authority_;
-  QuicHashMap<std::string, std::unique_ptr<QuicBackendResponse>>
+  absl::flat_hash_map<std::string, std::unique_ptr<QuicBackendResponse>>
       active_response_map_;
-  QuicHashMap<QuicConnectionId, BackendClient*, QuicConnectionIdHash>
+  absl::flat_hash_map<QuicConnectionId, BackendClient*, QuicConnectionIdHash>
       backend_clients_;
 };
 
diff --git a/quic/qbone/bonnet/icmp_reachable_test.cc b/quic/qbone/bonnet/icmp_reachable_test.cc
index ae246b7..221e5f6 100644
--- a/quic/qbone/bonnet/icmp_reachable_test.cc
+++ b/quic/qbone/bonnet/icmp_reachable_test.cc
@@ -6,6 +6,7 @@
 
 #include <netinet/ip6.h>
 
+#include "absl/container/node_hash_map.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/platform/api/quic_epoll.h"
 #include "quic/platform/api/quic_ip_address.h"
@@ -73,8 +74,8 @@
 
   std::string current_source_{};
 
-  QuicUnorderedMap<int, int> read_errors_;
-  QuicUnorderedMap<int, int> write_errors_;
+  absl::node_hash_map<int, int> read_errors_;
+  absl::node_hash_map<int, int> write_errors_;
 };
 
 class IcmpReachableTest : public QuicTest {
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 344b1b1..4a8c8ca 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -4,6 +4,7 @@
 
 #include "quic/test_tools/quic_session_peer.h"
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/quic_session.h"
 #include "quic/core/quic_stream.h"
 #include "quic/core/quic_utils.h"
@@ -120,7 +121,7 @@
 }
 
 // static
-QuicHashMap<QuicStreamId, QuicStreamOffset>&
+absl::flat_hash_map<QuicStreamId, QuicStreamOffset>&
 QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(QuicSession* session) {
   return session->locally_closed_streams_highest_offset_;
 }
diff --git a/quic/test_tools/quic_session_peer.h b/quic/test_tools/quic_session_peer.h
index 66a57a7..94f0bf5 100644
--- a/quic/test_tools/quic_session_peer.h
+++ b/quic/test_tools/quic_session_peer.h
@@ -9,6 +9,7 @@
 #include <map>
 #include <memory>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/quic_packets.h"
 #include "quic/core/quic_session.h"
 #include "quic/core/quic_write_blocked_list.h"
@@ -54,7 +55,7 @@
   static QuicWriteBlockedList* GetWriteBlockedStreams(QuicSession* session);
   static QuicStream* GetOrCreateStream(QuicSession* session,
                                        QuicStreamId stream_id);
-  static QuicHashMap<QuicStreamId, QuicStreamOffset>&
+  static absl::flat_hash_map<QuicStreamId, QuicStreamOffset>&
   GetLocallyClosedStreamsHighestOffset(QuicSession* session);
   static QuicSession::StreamMap& stream_map(QuicSession* session);
   static const QuicSession::ClosedStreams& closed_streams(QuicSession* session);
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 7b4b18f..2863ce8 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -13,6 +13,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/congestion_control/loss_detection_interface.h"
@@ -2239,7 +2240,8 @@
   // Used to verify writer-allocated packet buffers are properly released.
   std::vector<PacketBuffer*> packet_buffer_pool_;
   // Buffer address => Address of the owning PacketBuffer.
-  QuicHashMap<char*, PacketBuffer*> packet_buffer_pool_index_;
+  absl::flat_hash_map<char*, PacketBuffer*, absl::Hash<char*>>
+      packet_buffer_pool_index_;
   // Indices in packet_buffer_pool_ that are not allocated.
   std::list<PacketBuffer*> packet_buffer_free_list_;
   // The soruce/peer address passed into WritePacket().
diff --git a/quic/test_tools/simple_data_producer.h b/quic/test_tools/simple_data_producer.h
index 0d6182e..82021e1 100644
--- a/quic/test_tools/simple_data_producer.h
+++ b/quic/test_tools/simple_data_producer.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
 #define QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/core/quic_stream_frame_data_producer.h"
@@ -59,12 +60,12 @@
 
  private:
   using SendBufferMap =
-      QuicHashMap<QuicStreamId, std::unique_ptr<QuicStreamSendBuffer>>;
+      absl::flat_hash_map<QuicStreamId, std::unique_ptr<QuicStreamSendBuffer>>;
 
   using CryptoBufferMap =
-      QuicHashMap<std::pair<EncryptionLevel, QuicStreamOffset>,
-                  absl::string_view,
-                  PairHash>;
+      absl::flat_hash_map<std::pair<EncryptionLevel, QuicStreamOffset>,
+                          absl::string_view,
+                          PairHash>;
 
   SimpleBufferAllocator allocator_;
 
diff --git a/quic/test_tools/simple_session_notifier.h b/quic/test_tools/simple_session_notifier.h
index 5f7d4ae..2219c27 100644
--- a/quic/test_tools/simple_session_notifier.h
+++ b/quic/test_tools/simple_session_notifier.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_NOTIFIER_H_
 #define QUICHE_QUIC_TEST_TOOLS_SIMPLE_SESSION_NOTIFIER_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/quic_circular_deque.h"
 #include "quic/core/quic_interval_set.h"
 #include "quic/core/session_notifier_interface.h"
@@ -106,7 +107,7 @@
 
   friend std::ostream& operator<<(std::ostream& os, const StreamState& s);
 
-  using StreamMap = QuicHashMap<QuicStreamId, StreamState>;
+  using StreamMap = absl::flat_hash_map<QuicStreamId, StreamState>;
 
   void OnStreamDataConsumed(QuicStreamId id,
                             QuicStreamOffset offset,
diff --git a/quic/test_tools/simulator/quic_endpoint_base.h b/quic/test_tools/simulator/quic_endpoint_base.h
index 89e67d7..81b09f1 100644
--- a/quic/test_tools/simulator/quic_endpoint_base.h
+++ b/quic/test_tools/simulator/quic_endpoint_base.h
@@ -7,6 +7,7 @@
 
 #include <memory>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/crypto/null_decrypter.h"
 #include "quic/core/crypto/null_encrypter.h"
 #include "quic/core/quic_connection.h"
@@ -150,7 +151,7 @@
   void Act() override {}
 
  private:
-  QuicHashMap<std::string, QuicEndpointBase*> mapping_;
+  absl::flat_hash_map<std::string, QuicEndpointBase*> mapping_;
 };
 
 }  // namespace simulator
diff --git a/quic/test_tools/simulator/simulator.h b/quic/test_tools/simulator/simulator.h
index cd3c9ba..9b73cc3 100644
--- a/quic/test_tools/simulator/simulator.h
+++ b/quic/test_tools/simulator/simulator.h
@@ -7,6 +7,7 @@
 
 #include <map>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/quic_connection.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/platform/api/quic_bug_tracker.h"
@@ -130,7 +131,7 @@
   std::multimap<QuicTime, Actor*> schedule_;
   // For each actor, maintain the time it is scheduled at.  The value for
   // unscheduled actors is QuicTime::Infinite().
-  QuicHashMap<Actor*, QuicTime> scheduled_times_;
+  absl::flat_hash_map<Actor*, QuicTime> scheduled_times_;
   QuicHashSet<std::string> actor_names_;
 };
 
diff --git a/quic/test_tools/simulator/simulator_test.cc b/quic/test_tools/simulator/simulator_test.cc
index c3c05ac..a71649e 100644
--- a/quic/test_tools/simulator/simulator_test.cc
+++ b/quic/test_tools/simulator/simulator_test.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "absl/container/node_hash_map.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/platform/api/quic_logging.h"
 #include "quic/platform/api/quic_test.h"
@@ -102,7 +103,7 @@
   QuicByteCount bytes_;
   QuicPacketCount packets_;
 
-  QuicUnorderedMap<std::string, QuicPacketCount>
+  absl::node_hash_map<std::string, QuicPacketCount>
       per_destination_packet_counter_;
 };
 
diff --git a/quic/test_tools/simulator/switch.h b/quic/test_tools/simulator/switch.h
index f50df6b..bd4e7b6 100644
--- a/quic/test_tools/simulator/switch.h
+++ b/quic/test_tools/simulator/switch.h
@@ -7,6 +7,7 @@
 
 #include <deque>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/platform/api/quic_containers.h"
 #include "quic/test_tools/simulator/queue.h"
 
@@ -80,7 +81,7 @@
   // This can not be a QuicCircularDeque since pointers into this are
   // assumed to be stable.
   std::deque<Port> ports_;
-  QuicHashMap<std::string, Port*> switching_table_;
+  absl::flat_hash_map<std::string, Port*> switching_table_;
 };
 
 }  // namespace simulator
diff --git a/quic/test_tools/simulator/traffic_policer.h b/quic/test_tools/simulator/traffic_policer.h
index ea6a5d4..bba2b83 100644
--- a/quic/test_tools/simulator/traffic_policer.h
+++ b/quic/test_tools/simulator/traffic_policer.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_SIMULATOR_TRAFFIC_POLICER_H_
 #define QUICHE_QUIC_TEST_TOOLS_SIMULATOR_TRAFFIC_POLICER_H_
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/test_tools/simulator/packet_filter.h"
 #include "quic/test_tools/simulator/port.h"
 
@@ -44,7 +45,7 @@
   QuicTime last_refill_time_;
 
   // Maps each destination to the number of tokens it has left.
-  QuicHashMap<std::string, QuicByteCount> token_buckets_;
+  absl::flat_hash_map<std::string, QuicByteCount> token_buckets_;
 };
 
 }  // namespace simulator
diff --git a/quic/tools/quic_memory_cache_backend.h b/quic/tools/quic_memory_cache_backend.h
index 4df670e..5e4b267 100644
--- a/quic/tools/quic_memory_cache_backend.h
+++ b/quic/tools/quic_memory_cache_backend.h
@@ -10,6 +10,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/http/spdy_utils.h"
 #include "quic/platform/api/quic_containers.h"
@@ -168,8 +169,8 @@
                                  QuicBackendResponse::ServerPushInfo resource);
 
   // Cached responses.
-  QuicHashMap<std::string, std::unique_ptr<QuicBackendResponse>> responses_
-      QUIC_GUARDED_BY(response_mutex_);
+  absl::flat_hash_map<std::string, std::unique_ptr<QuicBackendResponse>>
+      responses_ QUIC_GUARDED_BY(response_mutex_);
 
   // The default response for cache misses, if set.
   std::unique_ptr<QuicBackendResponse> default_response_
diff --git a/quic/tools/quic_tcp_like_trace_converter.h b/quic/tools/quic_tcp_like_trace_converter.h
index d5a1456..b90d455 100644
--- a/quic/tools/quic_tcp_like_trace_converter.h
+++ b/quic/tools/quic_tcp_like_trace_converter.h
@@ -7,6 +7,7 @@
 
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "quic/core/frames/quic_stream_frame.h"
 #include "quic/core/quic_interval.h"
 #include "quic/core/quic_interval_set.h"
@@ -73,8 +74,9 @@
                                         StreamInfo* info);
 
   StreamInfo crypto_frames_info_[NUM_ENCRYPTION_LEVELS];
-  QuicHashMap<QuicStreamId, StreamInfo> streams_info_;
-  QuicHashMap<QuicControlFrameId, QuicInterval<uint64_t>> control_frames_info_;
+  absl::flat_hash_map<QuicStreamId, StreamInfo> streams_info_;
+  absl::flat_hash_map<QuicControlFrameId, QuicInterval<uint64_t>>
+      control_frames_info_;
 
   QuicControlFrameId largest_observed_control_frame_id_;