Switch to standard integer types in net/.

net/quic/quic_protocol.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/quic_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 140 matching lines @@
       offset(offset),
       buffer(std::move(buffer)) {
   if (this->buffer != nullptr) {
     DCHECK(frame_buffer == nullptr);
     this->frame_buffer = this->buffer.get();
   }
 }
 
 QuicStreamFrame::~QuicStreamFrame() {}
 
-uint32 MakeQuicTag(char a, char b, char c, char d) {
-  return static_cast<uint32>(a) | static_cast<uint32>(b) << 8 |
-         static_cast<uint32>(c) << 16 | static_cast<uint32>(d) << 24;
+uint32_t MakeQuicTag(char a, char b, char c, char d) {
+  return static_cast<uint32_t>(a) | static_cast<uint32_t>(b) << 8 |
+         static_cast<uint32_t>(c) << 16 | static_cast<uint32_t>(d) << 24;
 }
 
 bool ContainsQuicTag(const QuicTagVector& tag_vector, QuicTag tag) {
   return std::find(tag_vector.begin(), tag_vector.end(), tag) !=
          tag_vector.end();
 }
 
 QuicVersionVector QuicSupportedVersions() {
   QuicVersionVector supported_versions;
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
@@ skipping 122 matching lines @@
   return error_code;
 }
 
 QuicRstStreamFrame::QuicRstStreamFrame()
     : stream_id(0), error_code(QUIC_STREAM_NO_ERROR), byte_offset(0) {}
 
 QuicRstStreamFrame::QuicRstStreamFrame(QuicStreamId stream_id,
                                        QuicRstStreamErrorCode error_code,
                                        QuicStreamOffset bytes_written)
     : stream_id(stream_id), error_code(error_code), byte_offset(bytes_written) {
-  DCHECK_LE(error_code, numeric_limits<uint8>::max());
+  DCHECK_LE(error_code, numeric_limits<uint8_t>::max());
 }
 
 QuicConnectionCloseFrame::QuicConnectionCloseFrame()
     : error_code(QUIC_NO_ERROR) {}
 
 QuicFrame::QuicFrame() {}
 
 QuicFrame::QuicFrame(QuicPaddingFrame padding_frame)
     : type(PADDING_FRAME), padding_frame(padding_frame) {}
 
@@ skipping 308 matching lines @@
 
 QuicGoAwayFrame::QuicGoAwayFrame()
     : error_code(QUIC_NO_ERROR), last_good_stream_id(0) {}
 
 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
                                  QuicStreamId last_good_stream_id,
                                  const string& reason)
     : error_code(error_code),
       last_good_stream_id(last_good_stream_id),
       reason_phrase(reason) {
-  DCHECK_LE(error_code, numeric_limits<uint8>::max());
+  DCHECK_LE(error_code, numeric_limits<uint8_t>::max());
 }
 
 QuicData::QuicData(const char* buffer, size_t length)
     : buffer_(buffer), length_(length), owns_buffer_(false) {}
 
 QuicData::QuicData(char* buffer, size_t length, bool owns_buffer)
     : buffer_(buffer), length_(length), owns_buffer_(owns_buffer) {}
 
 QuicData::~QuicData() {
   if (owns_buffer_) {
@@ skipping 208 matching lines @@
       transmission_type(transmission_type),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(is_fec_packet),
       all_transmissions(nullptr),
       retransmission(0) {}
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net