Clang format slam.

net/base/net_util.h

 // 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.
 
 #ifndef NET_BASE_NET_UTIL_H_
 #define NET_BASE_NET_UTIL_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
@@ skipping 70 matching lines @@
 // Saves the result into |*host| and |*port|. If the input did not have
 // the optional port, sets |*port| to -1.
 // Returns true if the parsing was successful, false otherwise.
 // The returned host is NOT canonicalized, and may be invalid. If <host> is
 // an IPv6 literal address, the returned host includes the square brackets.
 NET_EXPORT bool ParseHostAndPort(
     std::string::const_iterator host_and_port_begin,
     std::string::const_iterator host_and_port_end,
     std::string* host,
     int* port);
-NET_EXPORT bool ParseHostAndPort(
-    const std::string& host_and_port,
-    std::string* host,
-    int* port);
+NET_EXPORT bool ParseHostAndPort(const std::string& host_and_port,
+                                 std::string* host,
+                                 int* port);
 
 // Returns a host:port string for the given URL.
 NET_EXPORT std::string GetHostAndPort(const GURL& url);
 
 // Returns a host[:port] string for the given URL, where the port is omitted
 // if it is the default for the URL's scheme.
 NET_EXPORT_PRIVATE std::string GetHostAndOptionalPort(const GURL& url);
 
 // Returns true if |hostname| contains a non-registerable or non-assignable
 // domain name (eg: a gTLD that has not been assigned by IANA) or an IP address
 // that falls in an IANA-reserved range.
 NET_EXPORT bool IsHostnameNonUnique(const std::string& hostname);
 
 // Returns true if an IP address hostname is in a range reserved by the IANA.
 // Works with both IPv4 and IPv6 addresses, and only compares against a given
 // protocols's reserved ranges.
 NET_EXPORT bool IsIPAddressReserved(const IPAddressNumber& address);
 
 // Convenience struct for when you need a |struct sockaddr|.
 struct SockaddrStorage {
-  SockaddrStorage() : addr_len(sizeof(addr_storage)),
-                      addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {}
+  SockaddrStorage()
+      : addr_len(sizeof(addr_storage)),
+        addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {}
   struct sockaddr_storage addr_storage;
   socklen_t addr_len;
   struct sockaddr* const addr;
 };
 
 // Extracts the IP address and port portions of a sockaddr. |port| is optional,
 // and will not be filled in if NULL.
 bool GetIPAddressFromSockAddr(const struct sockaddr* sock_addr,
                               socklen_t sock_addr_len,
                               const unsigned char** address,
@@ skipping 18 matching lines @@
 
 // Same as IPAddressToStringWithPort() but for a sockaddr. This output will not
 // include the IPv6 scope ID.
 NET_EXPORT std::string NetAddressToStringWithPort(const struct sockaddr* sa,
                                                   socklen_t sock_addr_len);
 
 // Same as IPAddressToString() but for an IPAddressNumber.
 NET_EXPORT std::string IPAddressToString(const IPAddressNumber& addr);
 
 // Same as IPAddressToStringWithPort() but for an IPAddressNumber.
-NET_EXPORT std::string IPAddressToStringWithPort(
-    const IPAddressNumber& addr, uint16 port);
+NET_EXPORT std::string IPAddressToStringWithPort(const IPAddressNumber& addr,
+                                                 uint16 port);
 
 // Returns the address as a sequence of bytes in network-byte-order.
 NET_EXPORT std::string IPAddressToPackedString(const IPAddressNumber& addr);
 
 // Returns the hostname of the current system. Returns empty string on failure.
 NET_EXPORT std::string GetHostName();
 
 // Extracts the unescaped username/password from |url|, saving the results
 // into |*username| and |*password|.
 NET_EXPORT_PRIVATE void GetIdentityFromURL(const GURL& url,
@@ skipping 62 matching lines @@
 // |addRow|.
 //
 // |name| is the file name to be displayed. |raw_bytes| will be used
 // as the actual target of the link (so for example, ftp links should use
 // server's encoding). If |raw_bytes| is an empty string, UTF-8 encoded |name|
 // will be used.
 //
 // Both |name| and |raw_bytes| are escaped internally.
 NET_EXPORT std::string GetDirectoryListingEntry(const base::string16& name,
                                                 const std::string& raw_bytes,
-                                                bool is_dir, int64 size,
+                                                bool is_dir,
+                                                int64 size,
                                                 base::Time modified);
 
 // If text starts with "www." it is removed, otherwise text is returned
 // unmodified.
 NET_EXPORT base::string16 StripWWW(const base::string16& text);
 
 // Runs |url|'s host through StripWWW().  |url| must be valid.
 NET_EXPORT base::string16 StripWWWFromHost(const GURL& url);
 
 // Checks |port| against a list of ports which are restricted by default.
@@ skipping 74 matching lines @@
     UnescapeRule::Type unescape_rules,
     url::Parsed* new_parsed,
     size_t* prefix_end,
     base::OffsetAdjuster::Adjustments* adjustments);
 
 // This is a convenience function for FormatUrl() with
 // format_types = kFormatUrlOmitAll and unescape = SPACES.  This is the typical
 // set of flags for "URLs to display to the user".  You should be cautious about
 // using this for URLs which will be parsed or sent to other applications.
 inline base::string16 FormatUrl(const GURL& url, const std::string& languages) {
-  return FormatUrl(url, languages, kFormatUrlOmitAll, UnescapeRule::SPACES,
-                   NULL, NULL, NULL);
+  return FormatUrl(url,
+                   languages,
+                   kFormatUrlOmitAll,
+                   UnescapeRule::SPACES,
+                   NULL,
+                   NULL,
+                   NULL);
 }
 
 // Returns whether FormatUrl() would strip a trailing slash from |url|, given a
 // format flag including kFormatUrlOmitTrailingSlashOnBareHostname.
 NET_EXPORT bool CanStripTrailingSlash(const GURL& url);
 
 // Strip the portions of |url| that aren't core to the network request.
 //   - user name / password
 //   - reference section
 NET_EXPORT_PRIVATE GURL SimplifyUrlForRequest(const GURL& url);
@@ skipping 10 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ScopedPortException);
 };
 
 // Returns true if it can determine that only loopback addresses are configured.
 // i.e. if only 127.0.0.1 and ::1 are routable.
 // Also returns false if it cannot determine this.
 bool HaveOnlyLoopbackAddresses();
 
 // Returns AddressFamily of the address.
-NET_EXPORT_PRIVATE AddressFamily GetAddressFamily(
-    const IPAddressNumber& address);
+NET_EXPORT_PRIVATE AddressFamily
+    GetAddressFamily(const IPAddressNumber& address);
 
 // Maps the given AddressFamily to either AF_INET, AF_INET6 or AF_UNSPEC.
 NET_EXPORT_PRIVATE int ConvertAddressFamily(AddressFamily address_family);
 
 // Parses an IP address literal (either IPv4 or IPv6) to its numeric value.
 // Returns true on success and fills |ip_number| with the numeric value.
 NET_EXPORT_PRIVATE bool ParseIPLiteralToNumber(const std::string& ip_literal,
                                                IPAddressNumber* ip_number);
 
 // Converts an IPv4 address to an IPv4-mapped IPv6 address.
 // For example 192.168.0.1 would be converted to ::ffff:192.168.0.1.
-NET_EXPORT_PRIVATE IPAddressNumber ConvertIPv4NumberToIPv6Number(
-    const IPAddressNumber& ipv4_number);
+NET_EXPORT_PRIVATE IPAddressNumber
+    ConvertIPv4NumberToIPv6Number(const IPAddressNumber& ipv4_number);
 
 // Returns true iff |address| is an IPv4-mapped IPv6 address.
 NET_EXPORT_PRIVATE bool IsIPv4Mapped(const IPAddressNumber& address);
 
 // Converts an IPv4-mapped IPv6 address to IPv4 address. Should only be called
 // on IPv4-mapped IPv6 addresses.
-NET_EXPORT_PRIVATE IPAddressNumber ConvertIPv4MappedToIPv4(
-    const IPAddressNumber& address);
+NET_EXPORT_PRIVATE IPAddressNumber
+    ConvertIPv4MappedToIPv4(const IPAddressNumber& address);
 
 // Parses an IP block specifier from CIDR notation to an
 // (IP address, prefix length) pair. Returns true on success and fills
 // |*ip_number| with the numeric value of the IP address and sets
 // |*prefix_length_in_bits| with the length of the prefix.
 //
 // CIDR notation literals can use either IPv4 or IPv6 literals. Some examples:
 //
 //    10.10.3.1/20
 //    a:b:c::/46
@@ skipping 38 matching lines @@
   NetworkInterface(const std::string& name,
                    const std::string& friendly_name,
                    uint32 interface_index,
                    NetworkChangeNotifier::ConnectionType type,
                    const IPAddressNumber& address,
                    size_t network_prefix);
   ~NetworkInterface();
 
   std::string name;
   std::string friendly_name;  // Same as |name| on non-Windows.
-  uint32 interface_index;  // Always 0 on Android.
+  uint32 interface_index;     // Always 0 on Android.
   NetworkChangeNotifier::ConnectionType type;
   IPAddressNumber address;
   size_t network_prefix;
 };
 
 typedef std::vector<NetworkInterface> NetworkInterfaceList;
 
 // Policy settings to include/exclude network interfaces.
 enum HostAddressSelectionPolicy {
-  INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES           = 0x0,
-  EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES           = 0x1,
+  INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES = 0x0,
+  EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES = 0x1,
   // Include temp address only when interface has both permanent and
   // temp addresses.
-  INCLUDE_ONLY_TEMP_IPV6_ADDRESS_IF_POSSIBLE      = 0x2,
+  INCLUDE_ONLY_TEMP_IPV6_ADDRESS_IF_POSSIBLE = 0x2,
 };
 
 // Returns list of network interfaces except loopback interface. If an
 // interface has more than one address, a separate entry is added to
 // the list for each address.
 // Can be called only on a thread that allows IO.
-NET_EXPORT bool GetNetworkList(NetworkInterfaceList* networks,
-                               int policy);
+NET_EXPORT bool GetNetworkList(NetworkInterfaceList* networks, int policy);
 
 // General category of the IEEE 802.11 (wifi) physical layer operating mode.
 enum WifiPHYLayerProtocol {
   // No wifi support or no associated AP.
   WIFI_PHY_LAYER_PROTOCOL_NONE,
   // An obsolete modes introduced by the original 802.11, e.g. IR, FHSS.
   WIFI_PHY_LAYER_PROTOCOL_ANCIENT,
   // 802.11a, OFDM-based rates.
   WIFI_PHY_LAYER_PROTOCOL_A,
   // 802.11b, DSSS or HR DSSS.
@@ skipping 16 matching lines @@
 
 // Computes the number of leading 1-bits in |mask|.
 unsigned MaskPrefixLength(const IPAddressNumber& mask);
 
 // Differentiated Services Code Point.
 // See http://tools.ietf.org/html/rfc2474 for details.
 enum DiffServCodePoint {
   DSCP_NO_CHANGE = -1,
   DSCP_FIRST = DSCP_NO_CHANGE,
   DSCP_DEFAULT = 0,  // Same as DSCP_CS0
-  DSCP_CS0  = 0,   // The default
-  DSCP_CS1  = 8,   // Bulk/background traffic
+  DSCP_CS0 = 0,      // The default
+  DSCP_CS1 = 8,      // Bulk/background traffic
   DSCP_AF11 = 10,
   DSCP_AF12 = 12,
   DSCP_AF13 = 14,
-  DSCP_CS2  = 16,
+  DSCP_CS2 = 16,
   DSCP_AF21 = 18,
   DSCP_AF22 = 20,
   DSCP_AF23 = 22,
-  DSCP_CS3  = 24,
+  DSCP_CS3 = 24,
   DSCP_AF31 = 26,
   DSCP_AF32 = 28,
   DSCP_AF33 = 30,
-  DSCP_CS4  = 32,
+  DSCP_CS4 = 32,
   DSCP_AF41 = 34,  // Video
   DSCP_AF42 = 36,  // Video
   DSCP_AF43 = 38,  // Video
-  DSCP_CS5  = 40,  // Video
-  DSCP_EF   = 46,  // Voice
-  DSCP_CS6  = 48,  // Voice
-  DSCP_CS7  = 56,  // Control messages
+  DSCP_CS5 = 40,   // Video
+  DSCP_EF = 46,    // Voice
+  DSCP_CS6 = 48,   // Voice
+  DSCP_CS7 = 56,   // Control messages
   DSCP_LAST = DSCP_CS7
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_UTIL_H_