Add quic_map_util.

net/quic/core/quic_buffered_packet_store.cc

 // Copyright (c) 2016 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 "net/quic/core/quic_buffered_packet_store.h"
 
-#include "base/stl_util.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
-
-using base::ContainsKey;
+#include "net/quic/platform/api/quic_map_util.h"
 
 namespace net {
 
 typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
 typedef QuicBufferedPacketStore::BufferedPacketList BufferedPacketList;
 typedef QuicBufferedPacketStore::EnqueuePacketResult EnqueuePacketResult;
 
 // Max number of connections this store can keep track.
 static const size_t kDefaultMaxConnectionsInStore = 100;
 // Up to half of the capacity can be used for storing non-CHLO packets.
@@ skipping 56 matching lines @@
 QuicBufferedPacketStore::~QuicBufferedPacketStore() {}
 
 EnqueuePacketResult QuicBufferedPacketStore::EnqueuePacket(
     QuicConnectionId connection_id,
     const QuicReceivedPacket& packet,
     QuicSocketAddress server_address,
     QuicSocketAddress client_address,
     bool is_chlo) {
   QUIC_BUG_IF(!FLAGS_quic_allow_chlo_buffering)
       << "Shouldn't buffer packets if disabled via flag.";
-  QUIC_BUG_IF(is_chlo && ContainsKey(connections_with_chlo_, connection_id))
+  QUIC_BUG_IF(is_chlo && QuicContainsKey(connections_with_chlo_, connection_id))
       << "Shouldn't buffer duplicated CHLO on connection " << connection_id;
 
-  if (!ContainsKey(undecryptable_packets_, connection_id) &&
+  if (!QuicContainsKey(undecryptable_packets_, connection_id) &&
       ShouldBufferPacket(is_chlo)) {
     // Drop the packet if the upper limit of undecryptable packets has been
     // reached or the whole capacity of the store has been reached.
     return TOO_MANY_CONNECTIONS;
-  } else if (!ContainsKey(undecryptable_packets_, connection_id)) {
+  } else if (!QuicContainsKey(undecryptable_packets_, connection_id)) {
     undecryptable_packets_.emplace(
         std::make_pair(connection_id, BufferedPacketList()));
   }
-  CHECK(ContainsKey(undecryptable_packets_, connection_id));
+  CHECK(QuicContainsKey(undecryptable_packets_, connection_id));
   BufferedPacketList& queue =
       undecryptable_packets_.find(connection_id)->second;
 
   if (!is_chlo) {
     // If current packet is not CHLO, it might not be buffered because store
     // only buffers certain number of undecryptable packets per connection.
     size_t num_non_chlo_packets =
-        ContainsKey(connections_with_chlo_, connection_id)
+        QuicContainsKey(connections_with_chlo_, connection_id)
             ? (queue.buffered_packets.size() - 1)
             : queue.buffered_packets.size();
     if (num_non_chlo_packets >= kDefaultMaxUndecryptablePackets) {
       // If there are kMaxBufferedPacketsPerConnection packets buffered up for
       // this connection, drop the current packet.
       return TOO_MANY_PACKETS;
     }
   }
 
   if (queue.buffered_packets.empty()) {
@@ skipping 12 matching lines @@
   } else {
     // Buffer non-CHLO packets in arrival order.
     queue.buffered_packets.push_back(std::move(new_entry));
   }
   MaybeSetExpirationAlarm();
   return SUCCESS;
 }
 
 bool QuicBufferedPacketStore::HasBufferedPackets(
     QuicConnectionId connection_id) const {
-  return ContainsKey(undecryptable_packets_, connection_id);
+  return QuicContainsKey(undecryptable_packets_, connection_id);
 }
 
 bool QuicBufferedPacketStore::HasChlosBuffered() const {
   return !connections_with_chlo_.empty();
 }
 
 std::list<BufferedPacket> QuicBufferedPacketStore::DeliverPackets(
     QuicConnectionId connection_id) {
   std::list<BufferedPacket> packets_to_deliver;
   auto it = undecryptable_packets_.find(connection_id);
@@ skipping 59 matching lines @@
   *connection_id = connections_with_chlo_.front().first;
   connections_with_chlo_.pop_front();
 
   std::list<BufferedPacket> packets = DeliverPackets(*connection_id);
   DCHECK(!packets.empty()) << "Try to deliver connectons without CHLO";
   return packets;
 }
 
 bool QuicBufferedPacketStore::HasChloForConnection(
     QuicConnectionId connection_id) {
-  return ContainsKey(connections_with_chlo_, connection_id);
+  return QuicContainsKey(connections_with_chlo_, connection_id);
 }
 
 }  // namespace net