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

webrtc/base/httpcommon.h

 /*
  *  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 94 matching lines @@
   HH_SET_COOKIE,
   HH_TE,
   HH_TRAILERS,
   HH_TRANSFER_ENCODING,
   HH_UPGRADE,
   HH_USER_AGENT,
   HH_WWW_AUTHENTICATE,
   HH_LAST = HH_WWW_AUTHENTICATE
 };
 
-const uint16 HTTP_DEFAULT_PORT = 80;
-const uint16 HTTP_SECURE_PORT = 443;
+const uint16_t HTTP_DEFAULT_PORT = 80;
+const uint16_t HTTP_SECURE_PORT = 443;
 
 //////////////////////////////////////////////////////////////////////
 // Utility Functions
 //////////////////////////////////////////////////////////////////////
 
 inline HttpError mkerr(HttpError err, HttpError def_err = HE_DEFAULT) {
   return (err != HE_NONE) ? err : def_err;
 }
 
 const char* ToString(HttpVersion version);
 bool FromString(HttpVersion& version, const std::string& str);
 
 const char* ToString(HttpVerb verb);
 bool FromString(HttpVerb& verb, const std::string& str);
 
 const char* ToString(HttpHeader header);
 bool FromString(HttpHeader& header, const std::string& str);
 
-inline bool HttpCodeIsInformational(uint32 code) { return ((code / 100) == 1); }
-inline bool HttpCodeIsSuccessful(uint32 code)    { return ((code / 100) == 2); }
-inline bool HttpCodeIsRedirection(uint32 code)   { return ((code / 100) == 3); }
-inline bool HttpCodeIsClientError(uint32 code)   { return ((code / 100) == 4); }
-inline bool HttpCodeIsServerError(uint32 code)   { return ((code / 100) == 5); }
+inline bool HttpCodeIsInformational(uint32_t code) {
+  return ((code / 100) == 1);
+}
+inline bool HttpCodeIsSuccessful(uint32_t code) {
+  return ((code / 100) == 2);
+}
+inline bool HttpCodeIsRedirection(uint32_t code) {
+  return ((code / 100) == 3);
+}
+inline bool HttpCodeIsClientError(uint32_t code) {
+  return ((code / 100) == 4);
+}
+inline bool HttpCodeIsServerError(uint32_t code) {
+  return ((code / 100) == 5);
+}
 
-bool HttpCodeHasBody(uint32 code);
-bool HttpCodeIsCacheable(uint32 code);
+bool HttpCodeHasBody(uint32_t code);
+bool HttpCodeIsCacheable(uint32_t code);
 bool HttpHeaderIsEndToEnd(HttpHeader header);
 bool HttpHeaderIsCollapsible(HttpHeader header);
 
 struct HttpData;
 bool HttpShouldKeepAlive(const HttpData& data);
 
 typedef std::pair<std::string, std::string> HttpAttribute;
 typedef std::vector<HttpAttribute> HttpAttributeList;
 void HttpComposeAttributes(const HttpAttributeList& attributes, char separator,
                            std::string* composed);
 void HttpParseAttributes(const char * data, size_t len,
                          HttpAttributeList& attributes);
 bool HttpHasAttribute(const HttpAttributeList& attributes,
                       const std::string& name,
                       std::string* value);
 bool HttpHasNthAttribute(HttpAttributeList& attributes,
                          size_t index,
                          std::string* name,
                          std::string* value);
 
 // Convert RFC1123 date (DoW, DD Mon YYYY HH:MM:SS TZ) to unix timestamp
 bool HttpDateToSeconds(const std::string& date, time_t* seconds);
 
-inline uint16 HttpDefaultPort(bool secure) {
+inline uint16_t HttpDefaultPort(bool secure) {
   return secure ? HTTP_SECURE_PORT : HTTP_DEFAULT_PORT;
 }
 
 // Returns the http server notation for a given address
 std::string HttpAddress(const SocketAddress& address, bool secure);
 
 // functional for insensitive std::string compare
 struct iless {
   bool operator()(const std::string& lhs, const std::string& rhs) const {
     return (::_stricmp(lhs.c_str(), rhs.c_str()) < 0);
@@ skipping 12 matching lines @@
 public:
   typedef typename Traits<CTYPE>::string string;
 
   // TODO: Implement Encode/Decode
   static int Encode(const CTYPE* source, CTYPE* destination, size_t len);
   static int Encode(const string& source, string& destination);
   static int Decode(const CTYPE* source, CTYPE* destination, size_t len);
   static int Decode(const string& source, string& destination);
 
   Url(const string& url) { do_set_url(url.c_str(), url.size()); }
-  Url(const string& path, const string& host, uint16 port = HTTP_DEFAULT_PORT)
-  : host_(host), port_(port), secure_(HTTP_SECURE_PORT == port)
-  { set_full_path(path); }
+  Url(const string& path, const string& host, uint16_t port = HTTP_DEFAULT_PORT)
+      : host_(host), port_(port), secure_(HTTP_SECURE_PORT == port) {
+    set_full_path(path);
+  }
 
   bool valid() const { return !host_.empty(); }
   void clear() {
     host_.clear();
     port_ = HTTP_DEFAULT_PORT;
     secure_ = false;
     path_.assign(1, static_cast<CTYPE>('/'));
     query_.clear();
   }
 
@@ skipping 14 matching lines @@
   void set_full_path(const string& val) {
     do_set_full_path(val.c_str(), val.size());
   }
   string full_path() const {
     string val; do_get_full_path(&val); return val;
   }
 
   void set_host(const string& val) { host_ = val; }
   const string& host() const { return host_; }
 
-  void set_port(uint16 val) { port_ = val; }
-  uint16 port() const { return port_; }
+  void set_port(uint16_t val) { port_ = val; }
+  uint16_t port() const { return port_; }
 
   void set_secure(bool val) { secure_ = val; }
   bool secure() const { return secure_; }
 
   void set_path(const string& val) {
     if (val.empty()) {
       path_.assign(1, static_cast<CTYPE>('/'));
     } else {
       ASSERT(val[0] == static_cast<CTYPE>('/'));
       path_ = val;
@@ skipping 12 matching lines @@
 private:
   void do_set_url(const CTYPE* val, size_t len);
   void do_set_address(const CTYPE* val, size_t len);
   void do_set_full_path(const CTYPE* val, size_t len);
 
   void do_get_url(string* val) const;
   void do_get_address(string* val) const;
   void do_get_full_path(string* val) const;
 
   string host_, path_, query_;
-  uint16 port_;
+  uint16_t port_;
   bool secure_;
 };
 
 //////////////////////////////////////////////////////////////////////
 // HttpData
 //////////////////////////////////////////////////////////////////////
 
 struct HttpData {
   typedef std::multimap<std::string, std::string, iless> HeaderMap;
   typedef HeaderMap::const_iterator const_iterator;
@@ skipping 105 matching lines @@
   void copy(const HttpRequestData& src);
 
   size_t formatLeader(char* buffer, size_t size) const override;
   HttpError parseLeader(const char* line, size_t len) override;
 
   bool getAbsoluteUri(std::string* uri) const;
   bool getRelativeUri(std::string* host, std::string* path) const;
 };
 
 struct HttpResponseData : public HttpData {
-  uint32 scode;
+  uint32_t scode;
   std::string message;
 
   HttpResponseData() : scode(HC_INTERNAL_SERVER_ERROR) { }
   void clear(bool release_document);
   void copy(const HttpResponseData& src);
 
   // Convenience methods
-  void set_success(uint32 scode = HC_OK);
-  void set_success(const std::string& content_type, StreamInterface* document,
-                   uint32 scode = HC_OK);
+  void set_success(uint32_t scode = HC_OK);
+  void set_success(const std::string& content_type,
+                   StreamInterface* document,
+                   uint32_t scode = HC_OK);
   void set_redirect(const std::string& location,
-                    uint32 scode = HC_MOVED_TEMPORARILY);
-  void set_error(uint32 scode);
+                    uint32_t scode = HC_MOVED_TEMPORARILY);
+  void set_error(uint32_t scode);
 
   size_t formatLeader(char* buffer, size_t size) const override;
   HttpError parseLeader(const char* line, size_t len) override;
 };
 
 struct HttpTransaction {
   HttpRequestData request;
   HttpResponseData response;
 };
 
@@ skipping 17 matching lines @@
   const SocketAddress& server,
   const std::string& method, const std::string& uri,
   const std::string& username, const CryptString& password,
   HttpAuthContext *& context, std::string& response, std::string& auth_method);
 
 //////////////////////////////////////////////////////////////////////
 
 } // namespace rtc
 
 #endif // WEBRTC_BASE_HTTPCOMMON_H__