adds std:: to stl types (#049)

net/quic/core/quic_framer.cc

 // Copyright (c) 2012 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_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_data_reader.h"
 #include "net/quic/core/quic_data_writer.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 
 using base::ContainsKey;
 using base::StringPiece;
-using std::map;
 using std::max;
 using std::min;
-using std::numeric_limits;
 using std::string;
-using std::vector;
 #define PREDICT_FALSE(x) (x)
 
 namespace net {
 
 namespace {
 
 // Mask to select the lowest 48 bits of a packet number.
 const QuicPacketNumber k6ByteSequenceNumberMask = UINT64_C(0x0000FFFFFFFFFFFF);
 const QuicPacketNumber k4ByteSequenceNumberMask = UINT64_C(0x00000000FFFFFFFF);
 const QuicPacketNumber k2ByteSequenceNumberMask = UINT64_C(0x000000000000FFFF);
@@ skipping 945 matching lines @@
     const QuicAckFrame& frame) {
   AckFrameInfo ack_info;
   if (frame.packets.Empty()) {
     return ack_info;
   }
   DCHECK_GE(frame.largest_observed, frame.packets.Max());
   QuicPacketNumber last_largest_missing = 0;
   for (const Interval<QuicPacketNumber>& interval : frame.packets) {
     for (QuicPacketNumber interval_start = interval.min();
          interval_start < interval.max();
-         interval_start += (1ull + numeric_limits<uint8_t>::max())) {
+         interval_start += (1ull + std::numeric_limits<uint8_t>::max())) {
       uint8_t cur_range_length =
-          interval.max() - interval_start > numeric_limits<uint8_t>::max()
-              ? numeric_limits<uint8_t>::max()
+          interval.max() - interval_start > std::numeric_limits<uint8_t>::max()
+              ? std::numeric_limits<uint8_t>::max()
               : (interval.max() - interval_start) - 1;
       ack_info.nack_ranges[interval_start] = cur_range_length;
     }
     ack_info.max_delta =
         max(ack_info.max_delta, last_largest_missing == 0
                                     ? QuicPacketNumber{0}
                                     : (interval.min() - last_largest_missing));
     last_largest_missing = interval.max() - 1;
   }
   // Include the range to the largest observed.
@@ skipping 13 matching lines @@
   // encoding, so skip it.
   new_ack_info.first_block_length = frame.packets.LastIntervalLength();
   auto itr = frame.packets.rbegin();
   QuicPacketNumber previous_start = itr->min();
   new_ack_info.max_block_length = itr->Length();
   ++itr;
 
   // Don't do any more work after getting information for 256 ACK blocks; any
   // more can't be encoded anyway.
   for (; itr != frame.packets.rend() &&
-         new_ack_info.num_ack_blocks < numeric_limits<uint8_t>::max();
+         new_ack_info.num_ack_blocks < std::numeric_limits<uint8_t>::max();
        previous_start = itr->min(), ++itr) {
     const auto& interval = *itr;
     const QuicPacketNumber total_gap = previous_start - interval.max();
     new_ack_info.num_ack_blocks +=
-        (total_gap + numeric_limits<uint8_t>::max() - 1) /
-        numeric_limits<uint8_t>::max();
+        (total_gap + std::numeric_limits<uint8_t>::max() - 1) /
+        std::numeric_limits<uint8_t>::max();
     new_ack_info.max_block_length =
         max(new_ack_info.max_block_length, interval.Length());
   }
   return new_ack_info;
 }
 
 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
                                               QuicPacketHeader* header) {
   header->path_id = kDefaultPathId;
   if (header->public_header.multipath_flag &&
@@ skipping 1024 matching lines @@
                                    QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
     QUIC_BUG << "Writing stream id size failed.";
     return false;
   }
   if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
     QUIC_BUG << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
-    if ((frame.data_length > numeric_limits<uint16_t>::max()) ||
+    if ((frame.data_length > std::numeric_limits<uint16_t>::max()) ||
         !writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) {
       QUIC_BUG << "Writing stream frame length failed";
       return false;
     }
   }
 
   if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
     QUIC_BUG << "Writing frame data failed.";
     return false;
   }
@@ skipping 190 matching lines @@
   }
   if (!writer->WriteUFloat16(ack_delay_time_us)) {
     return false;
   }
 
   size_t max_num_ack_blocks = available_timestamp_and_ack_block_bytes /
                               (ack_block_length + PACKET_1BYTE_PACKET_NUMBER);
 
   // Number of ack blocks.
   size_t num_ack_blocks = min(new_ack_info.num_ack_blocks, max_num_ack_blocks);
-  if (num_ack_blocks > numeric_limits<uint8_t>::max()) {
-    num_ack_blocks = numeric_limits<uint8_t>::max();
+  if (num_ack_blocks > std::numeric_limits<uint8_t>::max()) {
+    num_ack_blocks = std::numeric_limits<uint8_t>::max();
   }
 
   if (num_ack_blocks > 0) {
     if (!writer->WriteBytes(&num_ack_blocks, 1)) {
       return false;
     }
   }
 
   // First ack block length.
   if (!AppendPacketSequenceNumber(ack_block_length,
@@ skipping 15 matching lines @@
     auto itr = frame.packets.rbegin();
     QuicPacketNumber previous_start = itr->min();
     ++itr;
 
     for (;
          itr != frame.packets.rend() && num_ack_blocks_written < num_ack_blocks;
          previous_start = itr->min(), ++itr) {
       const auto& interval = *itr;
       const QuicPacketNumber total_gap = previous_start - interval.max();
       const size_t num_encoded_gaps =
-          (total_gap + numeric_limits<uint8_t>::max() - 1) /
-          numeric_limits<uint8_t>::max();
+          (total_gap + std::numeric_limits<uint8_t>::max() - 1) /
+          std::numeric_limits<uint8_t>::max();
       DCHECK_GT(num_encoded_gaps, 0u);
 
       // Append empty ACK blocks because the gap is longer than a single gap.
       for (size_t i = 1;
            i < num_encoded_gaps && num_ack_blocks_written < num_ack_blocks;
            ++i) {
-        if (!AppendAckBlock(numeric_limits<uint8_t>::max(), ack_block_length, 0,
-                            writer)) {
+        if (!AppendAckBlock(std::numeric_limits<uint8_t>::max(),
+                            ack_block_length, 0, writer)) {
           return false;
         }
         ++num_ack_blocks_written;
       }
       if (num_ack_blocks_written >= num_ack_blocks) {
         if (PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
           QUIC_BUG << "Wrote " << num_ack_blocks_written
                    << ", expected to write " << num_ack_blocks;
         }
         break;
       }
 
       const uint8_t last_gap =
-          total_gap - (num_encoded_gaps - 1) * numeric_limits<uint8_t>::max();
+          total_gap -
+          (num_encoded_gaps - 1) * std::numeric_limits<uint8_t>::max();
       // Append the final ACK block with a non-empty size.
       if (!AppendAckBlock(last_gap, ack_block_length, interval.Length(),
                           writer)) {
         return false;
       }
       ++num_ack_blocks_written;
     }
     DCHECK_EQ(num_ack_blocks, num_ack_blocks_written);
   }
 
@@ skipping 10 matching lines @@
     if (!writer->WriteBytes(&num_received_packets, 1)) {
       return false;
     }
   }
 
   return true;
 }
 
 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
                                            QuicDataWriter* writer) {
-  DCHECK_GE(numeric_limits<uint8_t>::max(), frame.received_packet_times.size());
+  DCHECK_GE(std::numeric_limits<uint8_t>::max(),
+            frame.received_packet_times.size());
   // num_received_packets is only 1 byte.
-  if (frame.received_packet_times.size() > numeric_limits<uint8_t>::max()) {
+  if (frame.received_packet_times.size() >
+      std::numeric_limits<uint8_t>::max()) {
     return false;
   }
 
   uint8_t num_received_packets = frame.received_packet_times.size();
   if (!writer->WriteBytes(&num_received_packets, 1)) {
     return false;
   }
   if (num_received_packets == 0) {
     return true;
   }
 
   PacketTimeVector::const_iterator it = frame.received_packet_times.begin();
   QuicPacketNumber packet_number = it->first;
   QuicPacketNumber delta_from_largest_observed =
       frame.largest_observed - packet_number;
 
-  DCHECK_GE(numeric_limits<uint8_t>::max(), delta_from_largest_observed);
-  if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) {
+  DCHECK_GE(std::numeric_limits<uint8_t>::max(), delta_from_largest_observed);
+  if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
     return false;
   }
 
   if (!writer->WriteUInt8(delta_from_largest_observed &
                           k1ByteSequenceNumberMask)) {
     return false;
   }
 
   // Use the lowest 4 bytes of the time delta from the creation_time_.
   const uint64_t time_epoch_delta_us = UINT64_C(1) << 32;
   uint32_t time_delta_us =
       static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() &
                             (time_epoch_delta_us - 1));
   if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
     return false;
   }
 
   QuicTime prev_time = it->second;
 
   for (++it; it != frame.received_packet_times.end(); ++it) {
     packet_number = it->first;
     delta_from_largest_observed = frame.largest_observed - packet_number;
 
-    if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) {
+    if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
       return false;
     }
 
     if (!writer->WriteUInt8(delta_from_largest_observed &
                             k1ByteSequenceNumberMask)) {
       return false;
     }
 
     uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds();
     prev_time = it->second;
@@ skipping 116 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net