Switch to standard integer types in url/.

url/scheme_host_port.h

 // Copyright 2015 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.
 
 #ifndef URL_SCHEME_HOST_PORT_H_
 #define URL_SCHEME_HOST_PORT_H_
 
+#include <stdint.h>
+
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/strings/string_piece.h"
 #include "url/url_export.h"
 
 class GURL;
 
 namespace url {
 
 // This class represents a (scheme, host, port) tuple extracted from a URL.
 //
 // The primary purpose of this class is to represent relevant network-authority
@@ skipping 53 matching lines @@
   // Creates an invalid (scheme, host, port) tuple, which represents an invalid
   // or non-standard URL.
   SchemeHostPort();
 
   // Creates a (scheme, host, port) tuple. |host| must be a canonicalized
   // A-label (that is, '☃.net' must be provided as 'xn--n3h.net'). |scheme|
   // must be a standard scheme. |port| must not be 0, unless |scheme| does not
   // support ports (e.g. 'file'). In that case, |port| must be 0.
   //
   // Copies the data in |scheme| and |host|.
-  SchemeHostPort(base::StringPiece scheme, base::StringPiece host, uint16 port);
+  SchemeHostPort(base::StringPiece scheme,
+                 base::StringPiece host,
+                 uint16_t port);
 
   // Creates a (scheme, host, port) tuple from |url|, as described at
   // https://tools.ietf.org/html/rfc6454#section-4
   //
   // If |url| is invalid or non-standard, the result will be an invalid
   // SchemeHostPort object.
   explicit SchemeHostPort(const GURL& url);
 
   ~SchemeHostPort();
 
   // Returns the host component, in URL form. That is all IDN domain names will
   // be expressed as A-Labels ('☃.net' will be returned as 'xn--n3h.net'), and
   // and all IPv6 addresses will be enclosed in brackets ("[2001:db8::1]").
   const std::string& host() const { return host_; }
   const std::string& scheme() const { return scheme_; }
-  uint16 port() const { return port_; }
+  uint16_t port() const { return port_; }
   bool IsInvalid() const;
 
   // Serializes the SchemeHostPort tuple to a canonical form.
   //
   // While this string form resembles the Origin serialization specified in
   // Section 6.2 of RFC 6454, it is important to note that invalid
   // SchemeHostPort tuples serialize to the empty string, rather than being
   // serialized as a unique Origin.
   std::string Serialize() const;
 
   // Two SchemeHostPort objects are "equal" iff their schemes, hosts, and ports
   // are exact matches.
   //
   // Note that this comparison is _not_ the same as an origin-based comparison.
   // In particular, invalid SchemeHostPort objects match each other (and
   // themselves). Unique origins, on the other hand, would not.
   bool Equals(const SchemeHostPort& other) const;
 
   // Allows SchemeHostPort to be used as a key in STL (for example, a std::set
   // or std::map).
   bool operator<(const SchemeHostPort& other) const;
 
  private:
   std::string scheme_;
   std::string host_;
-  uint16 port_;
+  uint16_t port_;
 };
 
 }  // namespace url
 
 #endif  // URL_SCHEME_HOST_PORT_H_