Switch to standard integer types in net/.

net/http/http_response_info.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/http/http_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
@@ skipping 161 matching lines @@
   if (!iter.ReadInt(&flags))
     return false;
   int version = flags & RESPONSE_INFO_VERSION_MASK;
   if (version < RESPONSE_INFO_MINIMUM_VERSION ||
       version > RESPONSE_INFO_VERSION) {
     DLOG(ERROR) << "unexpected response info version: " << version;
     return false;
   }
 
   // Read request-time
-  int64 time_val;
+  int64_t time_val;
   if (!iter.ReadInt64(&time_val))
     return false;
   request_time = Time::FromInternalValue(time_val);
   was_cached = true;  // Set status to show cache resurrection.
 
   // Read response-time
   if (!iter.ReadInt64(&time_val))
     return false;
   response_time = Time::FromInternalValue(time_val);
 
@@ skipping 29 matching lines @@
     ssl_info.connection_status = connection_status;
   }
 
   if (flags & RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS) {
     int num_scts;
     if (!iter.ReadInt(&num_scts))
       return false;
     for (int i = 0; i < num_scts; ++i) {
       scoped_refptr<ct::SignedCertificateTimestamp> sct(
           ct::SignedCertificateTimestamp::CreateFromPickle(&iter));
-      uint16 status;
+      uint16_t status;
       if (!sct.get() || !iter.ReadUInt16(&status))
         return false;
       ssl_info.signed_certificate_timestamps.push_back(
           SignedCertificateTimestampAndStatus(
               sct, static_cast<ct::SCTVerifyStatus>(status)));
     }
   }
 
   // Read vary-data
   if (flags & RESPONSE_INFO_HAS_VARY_DATA) {
     if (!vary_data.InitFromPickle(&iter))
       return false;
   }
 
   // Read socket_address.
   std::string socket_address_host;
   if (iter.ReadString(&socket_address_host)) {
     // If the host was written, we always expect the port to follow.
-    uint16 socket_address_port;
+    uint16_t socket_address_port;
     if (!iter.ReadUInt16(&socket_address_port))
       return false;
     socket_address = HostPortPair(socket_address_host, socket_address_port);
   } else if (version > 1) {
     // socket_address was not always present in version 1 of the response
     // info, so we don't fail if it can't be read.
     return false;
   }
 
   // Read protocol-version.
@@ skipping 96 matching lines @@
     if (ssl_info.security_bits != -1)
       pickle->WriteInt(ssl_info.security_bits);
     if (ssl_info.connection_status != 0)
       pickle->WriteInt(ssl_info.connection_status);
     if (!ssl_info.signed_certificate_timestamps.empty()) {
       pickle->WriteInt(ssl_info.signed_certificate_timestamps.size());
       for (SignedCertificateTimestampAndStatusList::const_iterator it =
            ssl_info.signed_certificate_timestamps.begin(); it !=
            ssl_info.signed_certificate_timestamps.end(); ++it) {
         it->sct->Persist(pickle);
-        pickle->WriteUInt16(static_cast<uint16>(it->status));
+        pickle->WriteUInt16(static_cast<uint16_t>(it->status));
       }
     }
   }
 
   if (vary_data.is_valid())
     vary_data.Persist(pickle);
 
   pickle->WriteString(socket_address.host());
   pickle->WriteUInt16(socket_address.port());
 
@@ skipping 52 matching lines @@
     case CONNECTION_INFO_QUIC1_SPDY3:
       return "quic/1+spdy/3";
     case NUM_OF_CONNECTION_INFOS:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace net