Switch to standard integer types in net/.

net/spdy/spdy_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/spdy/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 43 matching lines @@
      if (!(cookie[value_start] == ' ' || cookie[value_start] == '\t')) {
         break;
      }
   }
   return (pos == 0) && ((cookie.size() - value_start) == 0);
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 // Pack parent stream ID and exclusive flag into the format used by HTTP/2
 // headers and priority frames.
-uint32 PackStreamDependencyValues(bool exclusive,
-                                  SpdyStreamId parent_stream_id) {
+uint32_t PackStreamDependencyValues(bool exclusive,
+                                    SpdyStreamId parent_stream_id) {
   // Make sure the highest-order bit in the parent stream id is zeroed out.
-  uint32 parent = parent_stream_id & 0x7fffffff;
+  uint32_t parent = parent_stream_id & 0x7fffffff;
   // Set the one-bit exclusivity flag.
-  uint32 e_bit = exclusive ? 0x80000000 : 0;
+  uint32_t e_bit = exclusive ? 0x80000000 : 0;
   return parent | e_bit;
 }
 
 // Unpack parent stream ID and exclusive flag from the format used by HTTP/2
 // headers and priority frames.
-void UnpackStreamDependencyValues(uint32 packed,
+void UnpackStreamDependencyValues(uint32_t packed,
                                   bool* exclusive,
                                   SpdyStreamId* parent_stream_id) {
   *exclusive = (packed >> 31) != 0;
   // Zero out the highest-order bit to get the parent stream id.
   *parent_stream_id = packed & 0x7fffffff;
 }
 
 struct DictionaryIds {
   DictionaryIds()
     : v2_dictionary_id(CalculateDictionaryId(kV2Dictionary, kV2DictionarySize)),
       v3_dictionary_id(CalculateDictionaryId(kV3Dictionary, kV3DictionarySize))
   {}
   const uLong v2_dictionary_id;
   const uLong v3_dictionary_id;
 };
 
 // Adler ID for the SPDY header compressor dictionaries. Note that they are
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
 // Used to indicate no flags in a SPDY flags field.
-const uint8 kNoFlags = 0;
+const uint8_t kNoFlags = 0;
 
 // Wire sizes of priority payloads.
 const size_t kPriorityDependencyPayloadSize = 4;
 const size_t kPriorityWeightPayloadSize = 1;
 
 // Wire size of pad length field.
 const size_t kPadLengthFieldSize = 1;
 
 }  // namespace
 
@@ skipping 20 matching lines @@
 #else
 #define CHANGE_STATE(newstate)                                  \
   do {                                                          \
     DCHECK(state_ != SPDY_ERROR);                               \
     DCHECK_EQ(previous_state_, state_);                         \
     previous_state_ = state_;                                   \
     state_ = newstate;                                          \
   } while (false)
 #endif
 
-SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(
-    SpdyMajorVersion version, uint32 wire) {
+SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(SpdyMajorVersion version,
+                                                      uint32_t wire) {
   if (version < SPDY3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return SettingsFlagsAndId(base::NetToHost32(wire) >> 24,
                             base::NetToHost32(wire) & 0x00ffffff);
 }
 
-SettingsFlagsAndId::SettingsFlagsAndId(uint8 flags, uint32 id)
+SettingsFlagsAndId::SettingsFlagsAndId(uint8_t flags, uint32_t id)
     : flags_(flags), id_(id & 0x00ffffff) {
   LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large: " << id;
 }
 
-uint32 SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version)
-    const {
-  uint32 wire =
+uint32_t SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version) const {
+  uint32_t wire =
       base::HostToNet32(id_ & 0x00ffffff) | base::HostToNet32(flags_ << 24);
   if (version < SPDY3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
 // SPDY 2 had a bug in it with respect to byte ordering of id/flags field.
 // This method is used to preserve buggy behavior and works on both
 // little-endian and big-endian hosts.
 // This method is also bidirectional (can be used to translate SPDY 2 to SPDY 3
 // as well as vice versa).
-void SettingsFlagsAndId::ConvertFlagsAndIdForSpdy2(uint32* val) {
-    uint8* wire_array = reinterpret_cast<uint8*>(val);
+void SettingsFlagsAndId::ConvertFlagsAndIdForSpdy2(uint32_t* val) {
+  uint8_t* wire_array = reinterpret_cast<uint8_t*>(val);
     std::swap(wire_array[0], wire_array[3]);
     std::swap(wire_array[1], wire_array[2]);
 }
 
 bool SpdyFramerVisitorInterface::OnGoAwayFrameData(const char* goaway_data,
                                                    size_t len) {
   return true;
 }
 
 bool SpdyFramerVisitorInterface::OnRstStreamFrameData(
@@ skipping 557 matching lines @@
   SpdyFrameReader reader(current_frame_buffer_.data(),
                          current_frame_buffer_.len());
   bool is_control_frame = false;
 
   int control_frame_type_field =
       SpdyConstants::DataFrameType(protocol_version());
   // ProcessControlFrameHeader() will set current_frame_type_ to the
   // correct value if this is a valid control frame.
   current_frame_type_ = DATA;
   if (protocol_version() <= SPDY3) {
-    uint16 version = 0;
+    uint16_t version = 0;
     bool successful_read = reader.ReadUInt16(&version);
     DCHECK(successful_read);
     is_control_frame = (version & kControlFlagMask) != 0;
     version &= ~kControlFlagMask;  // Only valid for control frames.
     if (is_control_frame) {
       // We check version before we check validity: version can never be
       // 'invalid', it can only be unsupported.
       if (version < SpdyConstants::SerializeMajorVersion(SPDY_MIN_VERSION) ||
           version > SpdyConstants::SerializeMajorVersion(SPDY_MAX_VERSION) ||
           SpdyConstants::ParseMajorVersion(version) != protocol_version()) {
         // Version does not match the version the framer was initialized with.
         DVLOG(1) << "Unsupported SPDY version "
                  << version
                  << " (expected " << protocol_version() << ")";
         set_error(SPDY_UNSUPPORTED_VERSION);
         return 0;
       }
       // We check control_frame_type_field's validity in
       // ProcessControlFrameHeader().
-      uint16 control_frame_type_field_uint16;
+      uint16_t control_frame_type_field_uint16;
       successful_read = reader.ReadUInt16(&control_frame_type_field_uint16);
       control_frame_type_field = control_frame_type_field_uint16;
     } else {
       reader.Rewind();
       successful_read = reader.ReadUInt31(&current_frame_stream_id_);
     }
     DCHECK(successful_read);
 
     successful_read = reader.ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
-    uint32 length_field = 0;
+    uint32_t length_field = 0;
     successful_read = reader.ReadUInt24(&length_field);
     DCHECK(successful_read);
     remaining_data_length_ = length_field;
     current_frame_length_ = remaining_data_length_ + reader.GetBytesConsumed();
   } else {
-    uint32 length_field = 0;
+    uint32_t length_field = 0;
     bool successful_read = reader.ReadUInt24(&length_field);
     DCHECK(successful_read);
 
-    uint8 control_frame_type_field_uint8;
+    uint8_t control_frame_type_field_uint8;
     successful_read = reader.ReadUInt8(&control_frame_type_field_uint8);
     DCHECK(successful_read);
     // We check control_frame_type_field's validity in
     // ProcessControlFrameHeader().
     control_frame_type_field = control_frame_type_field_uint8;
     is_control_frame = control_frame_type_field !=
         SpdyConstants::SerializeFrameType(protocol_version(), DATA);
 
     if (is_control_frame) {
       current_frame_length_ = length_field + GetControlFrameHeaderSize();
@@ skipping 47 matching lines @@
   }
 
   // if we're here, then we have the common header all received.
   if (!is_control_frame) {
     if (protocol_version() > SPDY3) {
       // Catch bogus tests sending oversized DATA frames.
       DCHECK_GE(GetFrameMaximumSize(), current_frame_length_)
           << "DATA frame too large for SPDY >= 4.";
     }
 
-    uint8 valid_data_flags = 0;
+    uint8_t valid_data_flags = 0;
     if (protocol_version() > SPDY3) {
       valid_data_flags =
           DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT | DATA_FLAG_PADDED;
     } else {
       valid_data_flags = DATA_FLAG_FIN;
     }
 
     if (current_frame_flags_ & ~valid_data_flags) {
       set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
     } else {
@@ skipping 242 matching lines @@
   if (current_frame_type_ == RST_STREAM) {
     CHANGE_STATE(SPDY_RST_STREAM_FRAME_PAYLOAD);
     return;
   }
 
   if (current_frame_type_ == ALTSVC) {
     CHANGE_STATE(SPDY_ALTSVC_FRAME_PAYLOAD);
     return;
   }
   // Determine the frame size without variable-length data.
-  int32 frame_size_without_variable_data;
+  int32_t frame_size_without_variable_data;
   switch (current_frame_type_) {
     case SYN_STREAM:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = GetSynStreamMinimumSize();
       break;
     case SYN_REPLY:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = GetSynReplyMinimumSize();
       break;
     case SETTINGS:
@@ skipping 37 matching lines @@
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
     return;
   }
 
   if (frame_size_without_variable_data > 0) {
     // We have a control frame with a header block. We need to parse the
     // remainder of the control frame's header before we can parse the header
     // block. The start of the header block varies with the control type.
     DCHECK_GE(frame_size_without_variable_data,
-              static_cast<int32>(current_frame_buffer_.len()));
+              static_cast<int32_t>(current_frame_buffer_.len()));
     remaining_control_header_ =
         frame_size_without_variable_data - current_frame_buffer_.len();
 
     CHANGE_STATE(SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK);
     return;
   }
 
   CHANGE_STATE(SPDY_CONTROL_FRAME_PAYLOAD);
 }
 
 size_t SpdyFramer::UpdateCurrentFrameBuffer(const char** data, size_t* len,
                                             size_t max_bytes) {
   size_t bytes_to_read = std::min(*len, max_bytes);
   if (bytes_to_read > 0) {
     current_frame_buffer_.CopyFrom(*data, bytes_to_read);
     *data += bytes_to_read;
     *len -= bytes_to_read;
   }
   return bytes_to_read;
 }
 
 size_t SpdyFramer::GetSerializedLength(
     const SpdyMajorVersion spdy_version,
     const SpdyHeaderBlock* headers) {
-  const size_t num_name_value_pairs_size
-      = (spdy_version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
+  const size_t num_name_value_pairs_size =
+      (spdy_version < SPDY3) ? sizeof(uint16_t) : sizeof(uint32_t);
   const size_t length_of_name_size = num_name_value_pairs_size;
   const size_t length_of_value_size = num_name_value_pairs_size;
 
   size_t total_length = num_name_value_pairs_size;
   for (const auto& header : *headers) {
     // We add space for the length of the name and the length of the value as
     // well as the length of the name and the length of the value.
     total_length += length_of_name_size + header.first.size() +
                     length_of_value_size + header.second.size();
   }
   return total_length;
 }
 
 void SpdyFramer::WriteHeaderBlock(SpdyFrameBuilder* frame,
                                   const SpdyMajorVersion spdy_version,
                                   const SpdyHeaderBlock* headers) {
   if (spdy_version < SPDY3) {
-    frame->WriteUInt16(static_cast<uint16>(headers->size()));
+    frame->WriteUInt16(static_cast<uint16_t>(headers->size()));
   } else {
     frame->WriteUInt32(headers->size());
   }
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
     if (spdy_version < SPDY3) {
       frame->WriteStringPiece16(it->first);
       frame->WriteStringPiece16(it->second);
     } else {
       frame->WriteStringPiece32(it->first);
@@ skipping 269 matching lines @@
             reader.Seek(2);
           }
           if (protocol_version() > SPDY3 &&
              !(current_frame_flags_ & HEADERS_FLAG_END_HEADERS) &&
              current_frame_type_ == HEADERS) {
             expect_continuation_ = current_frame_stream_id_;
             end_stream_when_done_ = current_frame_flags_ & CONTROL_FLAG_FIN;
           }
           if (protocol_version() > SPDY3 &&
               current_frame_flags_ & HEADERS_FLAG_PADDED) {
-            uint8 pad_payload_len = 0;
+            uint8_t pad_payload_len = 0;
             DCHECK_EQ(remaining_padding_payload_length_, 0u);
             successful_read = reader.ReadUInt8(&pad_payload_len);
             DCHECK(successful_read);
             remaining_padding_payload_length_ = pad_payload_len;
           }
           const bool has_priority =
               (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0;
           SpdyPriority priority = 0;
-          uint32 parent_stream_id = 0;
+          uint32_t parent_stream_id = 0;
           bool exclusive = false;
           if (protocol_version() > SPDY3 && has_priority) {
-            uint32 stream_dependency;
+            uint32_t stream_dependency;
             successful_read = reader.ReadUInt32(&stream_dependency);
             DCHECK(successful_read);
             UnpackStreamDependencyValues(stream_dependency, &exclusive,
                                          &parent_stream_id);
 
-            uint8 weight = 0;
+            uint8_t weight = 0;
             successful_read = reader.ReadUInt8(&weight);
             if (successful_read) {
               priority = MapWeightToPriority(weight);
             }
           }
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
@@ skipping 18 matching lines @@
         {
           DCHECK_LT(SPDY3, protocol_version());
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
           bool successful_read = true;
           if (protocol_version() > SPDY3 &&
               current_frame_flags_ & PUSH_PROMISE_FLAG_PADDED) {
             DCHECK_EQ(remaining_padding_payload_length_, 0u);
-            uint8 pad_payload_len = 0;
+            uint8_t pad_payload_len = 0;
             successful_read = reader.ReadUInt8(&pad_payload_len);
             DCHECK(successful_read);
             remaining_padding_payload_length_ = pad_payload_len;
           }
         }
         {
           SpdyStreamId promised_stream_id = kInvalidStream;
           bool successful_read = reader.ReadUInt31(&promised_stream_id);
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
@@ skipping 207 matching lines @@
 
   ProcessControlFrameHeaderBlock(frame->data(), frame->size(), false);
 
   remaining_padding_payload_length_ = remaining_padding;
   remaining_data_length_ = remaining_padding;
 }
 
 bool SpdyFramer::ProcessSetting(const char* data) {
   int id_field;
   SpdySettingsIds id;
-  uint8 flags = 0;
-  uint32 value;
+  uint8_t flags = 0;
+  uint32_t value;
 
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
   if (protocol_version() <= SPDY3) {
-    const uint32 id_and_flags_wire = *(reinterpret_cast<const uint32*>(data));
+    const uint32_t id_and_flags_wire =
+        *(reinterpret_cast<const uint32_t*>(data));
     SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(protocol_version(), id_and_flags_wire);
     id_field = id_and_flags.id();
     flags = id_and_flags.flags();
-    value = base::NetToHost32(*(reinterpret_cast<const uint32*>(data + 4)));
+    value = base::NetToHost32(*(reinterpret_cast<const uint32_t*>(data + 4)));
   } else {
-    id_field = base::NetToHost16(*(reinterpret_cast<const uint16*>(data)));
-    value = base::NetToHost32(*(reinterpret_cast<const uint32*>(data + 2)));
+    id_field = base::NetToHost16(*(reinterpret_cast<const uint16_t*>(data)));
+    value = base::NetToHost32(*(reinterpret_cast<const uint32_t*>(data + 2)));
   }
 
   // Validate id.
   if (!SpdyConstants::IsValidSettingId(protocol_version(), id_field)) {
     DLOG(WARNING) << "Unknown SETTINGS ID: " << id_field;
     if (protocol_version() <= SPDY3) {
       return false;
     } else {
       // In HTTP2 we ignore unknown settings for extensibility.
       return true;
     }
   }
   id = SpdyConstants::ParseSettingId(protocol_version(), id_field);
 
   if (protocol_version() <= SPDY3) {
     // Detect duplicates.
     if (id <= settings_scratch_.last_setting_id) {
       DLOG(WARNING) << "Duplicate entry or invalid ordering for id " << id
                     << " in " << display_protocol_ << " SETTINGS frame "
                     << "(last setting id was "
                     << settings_scratch_.last_setting_id << ").";
       return false;
     }
     settings_scratch_.last_setting_id = id;
 
     // Validate flags.
-    uint8 kFlagsMask = SETTINGS_FLAG_PLEASE_PERSIST | SETTINGS_FLAG_PERSISTED;
+    uint8_t kFlagsMask = SETTINGS_FLAG_PLEASE_PERSIST | SETTINGS_FLAG_PERSISTED;
     if ((flags & ~(kFlagsMask)) != 0) {
       DLOG(WARNING) << "Unknown SETTINGS flags provided for id " << id << ": "
                     << flags;
       return false;
     }
   }
 
   // Validation succeeded. Pass on to visitor.
   visitor_->OnSetting(id, flags, value);
   return true;
@@ skipping 10 matching lines @@
     reader.Seek(GetControlFrameHeaderSize());  // Skip frame header.
 
     // Use frame-specific handlers.
     switch (current_frame_type_) {
       case PING: {
           SpdyPingId id = 0;
           bool is_ack = protocol_version() > SPDY3 &&
               (current_frame_flags_ & PING_FLAG_ACK);
           bool successful_read = true;
           if (protocol_version() <= SPDY3) {
-            uint32 id32 = 0;
+            uint32_t id32 = 0;
             successful_read = reader.ReadUInt32(&id32);
             id = id32;
           } else {
             successful_read = reader.ReadUInt64(&id);
           }
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           visitor_->OnPing(id, is_ack);
         }
         break;
       case WINDOW_UPDATE: {
-          uint32 delta_window_size = 0;
+        uint32_t delta_window_size = 0;
           bool successful_read = true;
           if (protocol_version() <= SPDY3) {
             successful_read = reader.ReadUInt31(&current_frame_stream_id_);
             DCHECK(successful_read);
           }
           successful_read = reader.ReadUInt32(&delta_window_size);
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           visitor_->OnWindowUpdate(current_frame_stream_id_,
                                    delta_window_size);
         }
         break;
       case BLOCKED: {
           DCHECK_LT(SPDY3, protocol_version());
           DCHECK(reader.IsDoneReading());
           visitor_->OnBlocked(current_frame_stream_id_);
         }
         break;
       case PRIORITY: {
           DCHECK_LT(SPDY3, protocol_version());
-          uint32 stream_dependency;
-          uint32 parent_stream_id;
+          uint32_t stream_dependency;
+          uint32_t parent_stream_id;
           bool exclusive;
-          uint8 weight;
+          uint8_t weight;
           bool successful_read = reader.ReadUInt32(&stream_dependency);
           DCHECK(successful_read);
           UnpackStreamDependencyValues(stream_dependency, &exclusive,
                                        &parent_stream_id);
 
           successful_read = reader.ReadUInt8(&weight);
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           visitor_->OnPriority(
               current_frame_stream_id_, parent_stream_id, weight, exclusive);
@@ skipping 32 matching lines @@
       // Parse out the last good stream id.
       SpdyFrameReader reader(current_frame_buffer_.data(),
                              current_frame_buffer_.len());
       reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
       bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
       DCHECK(successful_read);
 
       // In SPDYv3 and up, frames also specify a status code - parse it out.
       SpdyGoAwayStatus status = GOAWAY_OK;
       if (protocol_version() >= SPDY3) {
-        uint32 status_raw = GOAWAY_OK;
+        uint32_t status_raw = GOAWAY_OK;
         successful_read = reader.ReadUInt32(&status_raw);
         DCHECK(successful_read);
         if (SpdyConstants::IsValidGoAwayStatus(protocol_version(),
                                                status_raw)) {
           status = SpdyConstants::ParseGoAwayStatus(protocol_version(),
                                                     status_raw);
         } else {
           if (protocol_version() > SPDY3) {
             // Treat unrecognized status codes as INTERNAL_ERROR as
             // recommended by the HTTP/2 spec.
@@ skipping 46 matching lines @@
       // Parse out the last good stream id.
       SpdyFrameReader reader(current_frame_buffer_.data(),
                              current_frame_buffer_.len());
       reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
       if (protocol_version() <= SPDY3) {
         bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
         DCHECK(successful_read);
       }
 
       SpdyRstStreamStatus status = RST_STREAM_INVALID;
-      uint32 status_raw = status;
+      uint32_t status_raw = status;
       bool successful_read = reader.ReadUInt32(&status_raw);
       DCHECK(successful_read);
       if (SpdyConstants::IsValidRstStreamStatus(protocol_version(),
                                                 status_raw)) {
         status =
             SpdyConstants::ParseRstStreamStatus(protocol_version(), status_raw);
       } else {
         if (protocol_version() > SPDY3) {
           // Treat unrecognized status codes as INTERNAL_ERROR as
           // recommended by the HTTP/2 spec.
@@ skipping 70 matching lines @@
   size_t original_len = len;
   if (current_frame_flags_ & DATA_FLAG_PADDED) {
     if (len != 0) {
       if (remaining_data_length_ < kPadLengthFieldSize) {
         set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
         return 0;
       }
 
       static_assert(kPadLengthFieldSize == 1,
                     "Unexpected pad length field size.");
-      remaining_padding_payload_length_ = *reinterpret_cast<const uint8*>(data);
+      remaining_padding_payload_length_ =
+          *reinterpret_cast<const uint8_t*>(data);
       ++data;
       --len;
       --remaining_data_length_;
       visitor_->OnStreamPadding(current_frame_stream_id_, kPadLengthFieldSize);
     } else {
       // We don't have the data available for parsing the pad length field. Keep
       // waiting.
       return 0;
     }
   }
@@ skipping 74 matching lines @@
   }
   return original_len - len;
 }
 
 bool SpdyFramer::ParseHeaderBlockInBuffer(const char* header_data,
                                           size_t header_length,
                                           SpdyHeaderBlock* block) const {
   SpdyFrameReader reader(header_data, header_length);
 
   // Read number of headers.
-  uint32 num_headers;
+  uint32_t num_headers;
   if (protocol_version() <= SPDY2) {
-    uint16 temp;
+    uint16_t temp;
     if (!reader.ReadUInt16(&temp)) {
       DVLOG(1) << "Unable to read number of headers.";
       return false;
     }
     num_headers = temp;
   } else {
     if (!reader.ReadUInt32(&num_headers)) {
       DVLOG(1) << "Unable to read number of headers.";
       return false;
     }
   }
 
   // Read each header.
-  for (uint32 index = 0; index < num_headers; ++index) {
+  for (uint32_t index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
     if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header name (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
     std::string name = temp.as_string();
@@ skipping 22 matching lines @@
                 << reader.GetBytesConsumed() << " bytes consumed, from "
                 << header_length;
     return false;
   }
 
   return true;
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeData(
     const SpdyDataIR& data_ir) const {
-  uint8 flags = DATA_FLAG_NONE;
+  uint8_t flags = DATA_FLAG_NONE;
   if (data_ir.fin()) {
     flags = DATA_FLAG_FIN;
   }
 
   if (protocol_version() > SPDY3) {
     int num_padding_fields = 0;
     if (data_ir.padded()) {
       flags |= DATA_FLAG_PADDED;
       ++num_padding_fields;
     }
@@ skipping 18 matching lines @@
     SpdyFrameBuilder builder(size, protocol_version());
     builder.WriteDataFrameHeader(*this, data_ir.stream_id(), flags);
     builder.WriteBytes(data_ir.data().data(), data_ir.data().length());
     DCHECK_EQ(size, builder.length());
     return builder.take();
   }
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(
     const SpdyDataIR& data_ir) const {
-  uint8 flags = DATA_FLAG_NONE;
+  uint8_t flags = DATA_FLAG_NONE;
   if (data_ir.fin()) {
     flags = DATA_FLAG_FIN;
   }
 
   size_t frame_size = GetDataFrameMinimumSize();
   size_t num_padding_fields = 0;
   if (protocol_version() > SPDY3) {
     if (data_ir.padded()) {
       flags |= DATA_FLAG_PADDED;
       ++num_padding_fields;
@@ skipping 12 matching lines @@
   } else {
     builder.OverwriteLength(*this, data_ir.data().length());
   }
   DCHECK_EQ(frame_size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   DCHECK_GE(SPDY3, protocol_version());
-  uint8 flags = 0;
+  uint8_t flags = 0;
   if (syn_stream.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (syn_stream.unidirectional()) {
     // TODO(hkhalil): invalid for HTTP2.
     flags |= CONTROL_FLAG_UNIDIRECTIONAL;
   }
 
   // Sanitize priority.
-  uint8 priority = syn_stream.priority();
+  uint8_t priority = syn_stream.priority();
   if (priority > GetLowestPriority()) {
     DLOG(DFATAL) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
 
   // The size of this frame, including variable-length header block.
   size_t size = GetSynStreamMinimumSize() +
                 GetSerializedLength(syn_stream.header_block());
 
   SpdyFrameBuilder builder(size, protocol_version());
@@ skipping 13 matching lines @@
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     const SpdySynReplyIR& syn_reply) {
   DCHECK_GE(SPDY3, protocol_version());
-  uint8 flags = 0;
+  uint8_t flags = 0;
   if (syn_reply.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
 
   // The size of this frame, including variable-length header block.
   const size_t size =
       GetSynReplyMinimumSize() + GetSerializedLength(syn_reply.header_block());
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
@@ skipping 43 matching lines @@
 
   builder.WriteUInt32(SpdyConstants::SerializeRstStreamStatus(
       protocol_version(), rst_stream.status()));
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSettings(
     const SpdySettingsIR& settings) const {
-  uint8 flags = 0;
+  uint8_t flags = 0;
 
   if (protocol_version() <= SPDY3) {
     if (settings.clear_settings()) {
       flags |= SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
     }
   } else {
     if (settings.is_ack()) {
       flags |= SETTINGS_FLAG_ACK;
     }
   }
@@ skipping 19 matching lines @@
     builder.WriteUInt32(values->size());
   }
   DCHECK_EQ(GetSettingsMinimumSize(), builder.length());
   for (SpdySettingsIR::ValueMap::const_iterator it = values->begin();
        it != values->end();
        ++it) {
     int setting_id =
         SpdyConstants::SerializeSettingId(protocol_version(), it->first);
     DCHECK_GE(setting_id, 0);
     if (protocol_version() <= SPDY3) {
-      uint8 setting_flags = 0;
+      uint8_t setting_flags = 0;
       if (it->second.persist_value) {
         setting_flags |= SETTINGS_FLAG_PLEASE_PERSIST;
       }
       if (it->second.persisted) {
         setting_flags |= SETTINGS_FLAG_PERSISTED;
       }
       SettingsFlagsAndId flags_and_id(setting_flags, setting_id);
-      uint32 id_and_flags_wire = flags_and_id.GetWireFormat(protocol_version());
+      uint32_t id_and_flags_wire =
+          flags_and_id.GetWireFormat(protocol_version());
       builder.WriteBytes(&id_and_flags_wire, 4);
     } else {
-      builder.WriteUInt16(static_cast<uint16>(setting_id));
+      builder.WriteUInt16(static_cast<uint16_t>(setting_id));
     }
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
   SpdyFrameBuilder builder(GetPingSize(), protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, PING, kNoFlags);
-    builder.WriteUInt32(static_cast<uint32>(ping.id()));
+    builder.WriteUInt32(static_cast<uint32_t>(ping.id()));
   } else {
-    uint8 flags = 0;
+    uint8_t flags = 0;
     if (ping.is_ack()) {
       flags |= PING_FLAG_ACK;
     }
     builder.BeginNewFrame(*this, PING, flags, 0);
     builder.WriteUInt64(ping.id());
   }
   DCHECK_EQ(GetPingSize(), builder.length());
   return builder.take();
 }
 
@@ skipping 29 matching lines @@
     builder.WriteBytes(goaway.description().data(),
                        goaway.description().size());
   }
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeHeaders(
     const SpdyHeadersIR& headers) {
-  uint8 flags = 0;
+  uint8_t flags = 0;
   if (headers.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (protocol_version() > SPDY3) {
     // This will get overwritten if we overflow into a CONTINUATION frame.
     flags |= HEADERS_FLAG_END_HEADERS;
     if (headers.has_priority()) {
       flags |= HEADERS_FLAG_PRIORITY;
     }
     if (headers.padded()) {
@@ skipping 108 matching lines @@
 SpdyFrame* SpdyFramer::SerializeBlocked(const SpdyBlockedIR& blocked) const {
   DCHECK_LT(SPDY3, protocol_version());
   SpdyFrameBuilder builder(GetBlockedSize(), protocol_version());
   builder.BeginNewFrame(*this, BLOCKED, kNoFlags, blocked.stream_id());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
   DCHECK_LT(SPDY3, protocol_version());
-  uint8 flags = 0;
+  uint8_t flags = 0;
   // This will get overwritten if we overflow into a CONTINUATION frame.
   flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   if (push_promise.padded()) {
     flags |= PUSH_PROMISE_FLAG_PADDED;
     size += kPadLengthFieldSize;
     size += push_promise.padding_payload_len();
   }
@@ skipping 51 matching lines @@
 
   return builder.take();
 }
 
 // TODO(jgraettinger): This implementation is incorrect. The continuation
 // frame continues a previously-begun HPACK encoding; it doesn't begin a
 // new one. Figure out whether it makes sense to keep SerializeContinuation().
 SpdyFrame* SpdyFramer::SerializeContinuation(
     const SpdyContinuationIR& continuation) {
   CHECK_LT(SPDY3, protocol_version());
-  uint8 flags = 0;
+  uint8_t flags = 0;
   if (continuation.end_headers()) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetContinuationMinimumSize();
   string hpack_encoding;
   if (enable_compression_) {
     GetHpackEncoder()->EncodeHeaderSet(continuation.header_block(),
                                        &hpack_encoding);
@@ skipping 130 matching lines @@
   size_t payload_size = kMaxControlFrameSize - GetContinuationMinimumSize();
   // This is ceiling(overflow/payload_size) using integer arithmetics.
   return (overflow - 1) / payload_size + 1;
 }
 
 void SpdyFramer::WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                               const string& hpack_encoding,
                                               SpdyStreamId stream_id,
                                               SpdyFrameType type,
                                               int padding_payload_len) {
-  uint8 end_flag = 0;
-  uint8 flags = 0;
+  uint8_t end_flag = 0;
+  uint8_t flags = 0;
   if (type == HEADERS) {
     end_flag = HEADERS_FLAG_END_HEADERS;
   } else if (type == PUSH_PROMISE) {
     end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   } else {
     DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
                 << FrameTypeToString(type);
   }
 
   // Write all the padding payload and as much of the data payload as possible
@@ skipping 102 matching lines @@
 }
 
 HpackDecoder* SpdyFramer::GetHpackDecoder() {
   DCHECK_LT(SPDY3, protocol_version());
   if (hpack_decoder_.get() == nullptr) {
     hpack_decoder_.reset(new HpackDecoder(ObtainHpackHuffmanTable()));
   }
   return hpack_decoder_.get();
 }
 
-uint8 SpdyFramer::MapPriorityToWeight(SpdyPriority priority) {
+uint8_t SpdyFramer::MapPriorityToWeight(SpdyPriority priority) {
   const float kSteps = 255.9f / 7.f;
-  return static_cast<uint8>(kSteps * (7.f - priority));
+  return static_cast<uint8_t>(kSteps * (7.f - priority));
 }
 
-SpdyPriority SpdyFramer::MapWeightToPriority(uint8 weight) {
+SpdyPriority SpdyFramer::MapWeightToPriority(uint8_t weight) {
   const float kSteps = 255.9f / 7.f;
   return static_cast<SpdyPriority>(7.f - weight / kSteps);
 }
 
 // Incrementally decompress the control frame's header block, feeding the
 // result to the visitor in chunks. Continue this until the visitor
 // indicates that it cannot process any more data, or (more commonly) we
 // run out of data to deliver.
 bool SpdyFramer::IncrementallyDecompressControlFrameHeaderData(
     SpdyStreamId stream_id,
@@ skipping 76 matching lines @@
     len -= bytes_to_deliver;
     if (!read_successfully) {
       // Assume that the problem was the header block was too large for the
       // visitor.
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
   }
   return read_successfully;
 }
 
-void SpdyFramer::UpdateHeaderEncoderTableSize(uint32 value) {
+void SpdyFramer::UpdateHeaderEncoderTableSize(uint32_t value) {
   GetHpackEncoder()->ApplyHeaderTableSizeSetting(value);
 }
 
 size_t SpdyFramer::header_encoder_table_size() const {
   if (hpack_encoder_ == nullptr) {
     return kDefaultHeaderTableSizeSetting;
   } else {
     return hpack_encoder_->CurrentHeaderTableSizeSetting();
   }
 }
 
 void SpdyFramer::SerializeHeaderBlockWithoutCompression(
     SpdyFrameBuilder* builder,
     const SpdyHeaderBlock& header_block) const {
   // Serialize number of headers.
   if (protocol_version() <= SPDY2) {
-    builder->WriteUInt16(static_cast<uint16>(header_block.size()));
+    builder->WriteUInt16(static_cast<uint16_t>(header_block.size()));
   } else {
     builder->WriteUInt32(header_block.size());
   }
 
   // Serialize each header.
   for (const auto& header : header_block) {
     if (protocol_version() <= SPDY2) {
       builder->WriteStringPiece16(header.first);
       builder->WriteStringPiece16(header.second);
     } else {
@@ skipping 56 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net