Switch to standard integer types in net/.

net/quic/crypto/crypto_handshake_message.cc

 // Copyright (c) 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/crypto/crypto_handshake_message.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 147 matching lines @@
     if (i == index) {
       *out = StringPiece(value.data(), size);
       return QUIC_NO_ERROR;
     }
 
     value.remove_prefix(size);
   }
 }
 
 QuicErrorCode CryptoHandshakeMessage::GetUint32(QuicTag tag,
-                                                uint32* out) const {
-  return GetPOD(tag, out, sizeof(uint32));
+                                                uint32_t* out) const {
+  return GetPOD(tag, out, sizeof(uint32_t));
 }
 
 QuicErrorCode CryptoHandshakeMessage::GetUint64(QuicTag tag,
-                                                uint64* out) const {
-  return GetPOD(tag, out, sizeof(uint64));
+                                                uint64_t* out) const {
+  return GetPOD(tag, out, sizeof(uint64_t));
 }
 
 size_t CryptoHandshakeMessage::size() const {
-  size_t ret = sizeof(QuicTag) + sizeof(uint16) /* number of entries */ +
-               sizeof(uint16) /* padding */;
-  ret += (sizeof(QuicTag) + sizeof(uint32) /* end offset */) *
+  size_t ret = sizeof(QuicTag) + sizeof(uint16_t) /* number of entries */ +
+               sizeof(uint16_t) /* padding */;
+  ret += (sizeof(QuicTag) + sizeof(uint32_t) /* end offset */) *
          tag_value_map_.size();
   for (QuicTagValueMap::const_iterator i = tag_value_map_.begin();
        i != tag_value_map_.end(); ++i) {
     ret += i->second.size();
   }
 
   return ret;
 }
 
 void CryptoHandshakeMessage::set_minimum_size(size_t min_bytes) {
@@ skipping 42 matching lines @@
 
     bool done = false;
     switch (it->first) {
       case kICSL:
       case kCFCW:
       case kSFCW:
       case kIRTT:
       case kMSPC:
       case kSRBF:
       case kSWND:
-        // uint32 value
+        // uint32_t value
         if (it->second.size() == 4) {
-          uint32 value;
+          uint32_t value;
           memcpy(&value, it->second.data(), sizeof(value));
           ret += base::UintToString(value);
           done = true;
         }
         break;
       case kTBKP:
       case kKEXS:
       case kAEAD:
       case kCOPT:
       case kPDMD:
       case kVER:
         // tag lists
         if (it->second.size() % sizeof(QuicTag) == 0) {
           for (size_t j = 0; j < it->second.size(); j += sizeof(QuicTag)) {
             QuicTag tag;
             memcpy(&tag, it->second.data() + j, sizeof(tag));
             if (j > 0) {
               ret += ",";
             }
             ret += "'" + QuicUtils::TagToString(tag) + "'";
           }
           done = true;
         }
         break;
       case kRREJ:
-        // uint32 lists
-        if (it->second.size() % sizeof(uint32) == 0) {
-          for (size_t j = 0; j < it->second.size(); j += sizeof(uint32)) {
-            uint32 value;
+        // uint32_t lists
+        if (it->second.size() % sizeof(uint32_t) == 0) {
+          for (size_t j = 0; j < it->second.size(); j += sizeof(uint32_t)) {
+            uint32_t value;
             memcpy(&value, it->second.data() + j, sizeof(value));
             if (j > 0) {
               ret += ",";
             }
             ret += CryptoUtils::HandshakeFailureReasonToString(
                 static_cast<HandshakeFailureReason>(value));
           }
           done = true;
         }
         break;
@@ skipping 38 matching lines @@
       ret += "0x" + base::HexEncode(it->second.data(), it->second.size());
     }
     ret += "\n";
   }
   --indent;
   ret += string(2 * indent, ' ') + ">";
   return ret;
 }
 
 }  // namespace net