Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/httpcommon.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 131 matching lines @@
 }
 
 const char* ToString(HttpHeader header) {
   return Enum<HttpHeader>::Name(header);
 }
 
 bool FromString(HttpHeader& header, const std::string& str) {
   return Enum<HttpHeader>::Parse(header, str);
 }
 
-bool HttpCodeHasBody(uint32 code) {
+bool HttpCodeHasBody(uint32_t code) {
   return !HttpCodeIsInformational(code)
          && (code != HC_NO_CONTENT) && (code != HC_NOT_MODIFIED);
 }
 
-bool HttpCodeIsCacheable(uint32 code) {
+bool HttpCodeIsCacheable(uint32_t code) {
   switch (code) {
   case HC_OK:
   case HC_NON_AUTHORITATIVE:
   case HC_PARTIAL_CONTENT:
   case HC_MULTIPLE_CHOICES:
   case HC_MOVED_PERMANENTLY:
   case HC_GONE:
     return true;
   default:
     return false;
@@ skipping 424 matching lines @@
   HttpData::clear(release_document);
 }
 
 void
 HttpResponseData::copy(const HttpResponseData& src) {
   scode = src.scode;
   message = src.message;
   HttpData::copy(src);
 }
 
-void
-HttpResponseData::set_success(uint32 scode) {
+void HttpResponseData::set_success(uint32_t scode) {
   this->scode = scode;
   message.clear();
   setHeader(HH_CONTENT_LENGTH, "0", false);
 }
 
-void
-HttpResponseData::set_success(const std::string& content_type,
-                              StreamInterface* document,
-                              uint32 scode) {
+void HttpResponseData::set_success(const std::string& content_type,
+                                   StreamInterface* document,
+                                   uint32_t scode) {
   this->scode = scode;
   message.erase(message.begin(), message.end());
   setContent(content_type, document);
 }
 
-void
-HttpResponseData::set_redirect(const std::string& location, uint32 scode) {
+void HttpResponseData::set_redirect(const std::string& location,
+                                    uint32_t scode) {
   this->scode = scode;
   message.clear();
   setHeader(HH_LOCATION, location);
   setHeader(HH_CONTENT_LENGTH, "0", false);
 }
 
-void
-HttpResponseData::set_error(uint32 scode) {
+void HttpResponseData::set_error(uint32_t scode) {
   this->scode = scode;
   message.clear();
   setHeader(HH_CONTENT_LENGTH, "0", false);
 }
 
 size_t
 HttpResponseData::formatLeader(char* buffer, size_t size) const {
   size_t len = sprintfn(buffer, size, "HTTP/%s %lu", ToString(version), scode);
   if (!message.empty()) {
     len += sprintfn(buffer + len, size - len, " %.*s",
@@ skipping 266 matching lines @@
       //| ISC_REQ_USE_SUPPLIED_CREDS
       ;
 
     ::TimeStamp lifetime;
     SECURITY_STATUS ret = S_OK;
     ULONG ret_flags = 0, flags = NEG_FLAGS_DEFAULT;
 
     bool specify_credentials = !username.empty();
     size_t steps = 0;
 
-    //uint32 now = Time();
+    // uint32_t now = Time();
 
     NegotiateAuthContext * neg = static_cast<NegotiateAuthContext *>(context);
     if (neg) {
       const size_t max_steps = 10;
       if (++neg->steps >= max_steps) {
         LOG(WARNING) << "AsyncHttpsProxySocket::Authenticate(Negotiate) too many retries";
         return HAR_ERROR;
       }
       steps = neg->steps;
 
@@ skipping 123 matching lines @@
   }
 #endif
 #endif // WEBRTC_WIN
 
   return HAR_IGNORE;
 }
 
 //////////////////////////////////////////////////////////////////////
 
 } // namespace rtc