adds std:: to stl types (#049)

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 <list>
 
 #include "base/stl_util.h"
 #include "net/quic/core/quic_bug_tracker.h"
 
-using std::list;
-
 namespace net {
 
 typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
 typedef QuicBufferedPacketStore::EnqueuePacketResult EnqueuePacketResult;
 typedef QuicBufferedPacketStore::BufferedPacketList BufferedPacketList;
 
 // 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.
 static const size_t kMaxConnectionsWithoutCHLO =
@@ skipping 114 matching lines @@
 
 bool QuicBufferedPacketStore::HasBufferedPackets(
     QuicConnectionId connection_id) const {
   return base::ContainsKey(undecryptable_packets_, connection_id);
 }
 
 bool QuicBufferedPacketStore::HasChlosBuffered() const {
   return !connections_with_chlo_.empty();
 }
 
-list<BufferedPacket> QuicBufferedPacketStore::DeliverPackets(
+std::list<BufferedPacket> QuicBufferedPacketStore::DeliverPackets(
     QuicConnectionId connection_id) {
-  list<BufferedPacket> packets_to_deliver;
+  std::list<BufferedPacket> packets_to_deliver;
   auto it = undecryptable_packets_.find(connection_id);
   if (it != undecryptable_packets_.end()) {
     packets_to_deliver = std::move(it->second.buffered_packets);
     undecryptable_packets_.erase(connection_id);
   }
   return packets_to_deliver;
 }
 
 void QuicBufferedPacketStore::DiscardPackets(QuicConnectionId connection_id) {
   undecryptable_packets_.erase(connection_id);
@@ skipping 33 matching lines @@
 
   size_t num_connections_without_chlo =
       undecryptable_packets_.size() - connections_with_chlo_.size();
   bool reach_non_chlo_limit =
       FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
       num_connections_without_chlo >= kMaxConnectionsWithoutCHLO;
 
   return is_store_full || reach_non_chlo_limit;
 }
 
-list<BufferedPacket> QuicBufferedPacketStore::DeliverPacketsForNextConnection(
+std::list<BufferedPacket>
+QuicBufferedPacketStore::DeliverPacketsForNextConnection(
     QuicConnectionId* connection_id) {
   if (connections_with_chlo_.empty()) {
     // Returns empty list if no CHLO has been buffered.
-    return list<BufferedPacket>();
+    return std::list<BufferedPacket>();
   }
   *connection_id = connections_with_chlo_.front().first;
   connections_with_chlo_.erase(connections_with_chlo_.begin());
 
-  list<BufferedPacket> packets = DeliverPackets(*connection_id);
+  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 base::ContainsKey(connections_with_chlo_, connection_id);
 }
 
 }  // namespace net