adds std:: to stl types (#049)

net/quic/core/quic_received_packet_manager.cc

 // Copyright 2013 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_received_packet_manager.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_connection_stats.h"
 #include "net/quic/core/quic_flags.h"
 
 using std::max;
 using std::min;
-using std::numeric_limits;
 
 namespace net {
 
 namespace {
 
 // The maximum number of packets to ack immediately after a missing packet for
 // fast retransmission to kick in at the sender.  This limit is created to
 // reduce the number of acks sent that have no benefit for fast retransmission.
 // Set to the number of nacks needed for fast retransmit plus one for protection
 // against an ack loss
@@ skipping 174 matching lines @@
 }
 
 namespace {
 struct isTooLarge {
   explicit isTooLarge(QuicPacketNumber n) : largest_observed_(n) {}
   QuicPacketNumber largest_observed_;
 
   // Return true if the packet in p is too different from largest_observed_
   // to express.
   bool operator()(const std::pair<QuicPacketNumber, QuicTime>& p) const {
-    return largest_observed_ - p.first >= numeric_limits<uint8_t>::max();
+    return largest_observed_ - p.first >= std::numeric_limits<uint8_t>::max();
   }
 };
 }  // namespace
 
 const QuicFrame QuicReceivedPacketManager::GetUpdatedAckFrame(
     QuicTime approximate_now) {
   ack_frame_updated_ = false;
   if (ack_frame_.missing) {
     ack_frame_.entropy_hash = EntropyHash(ack_frame_.largest_observed);
   }
 
   if (time_largest_observed_ == QuicTime::Zero()) {
     // We have received no packets.
     ack_frame_.ack_delay_time = QuicTime::Delta::Infinite();
   } else {
     // Ensure the delta is zero if approximate now is "in the past".
     ack_frame_.ack_delay_time = approximate_now < time_largest_observed_
                                     ? QuicTime::Delta::Zero()
                                     : approximate_now - time_largest_observed_;
   }
 
   // Clear all packet times if any are too far from largest observed.
   // It's expected this is extremely rare.
   for (PacketTimeVector::iterator it = ack_frame_.received_packet_times.begin();
        it != ack_frame_.received_packet_times.end();) {
     if (ack_frame_.largest_observed - it->first >=
-        numeric_limits<uint8_t>::max()) {
+        std::numeric_limits<uint8_t>::max()) {
       it = ack_frame_.received_packet_times.erase(it);
     } else {
       ++it;
     }
   }
 
   return QuicFrame(&ack_frame_);
 }
 
 QuicPacketEntropyHash QuicReceivedPacketManager::EntropyHash(
@@ skipping 62 matching lines @@
 
 bool QuicReceivedPacketManager::ack_frame_updated() const {
   return ack_frame_updated_;
 }
 
 QuicPacketNumber QuicReceivedPacketManager::GetLargestObserved() const {
   return ack_frame_.largest_observed;
 }
 
 }  // namespace net