Renamed namespaces in src/net.

net/base/net_util.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/base/net_util.h"
 
 #include <errno.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 187 matching lines @@
   begin += match.length();
 
   std::string ret;
   base::TrimWhitespace(std::string(begin,
                                    std::find(begin, headers.end(), '\n')),
                        base::TRIM_ALL, &ret);
   return ret;
 }
 
 std::string CanonicalizeHost(const std::string& host,
-                             url_canon::CanonHostInfo* host_info) {
+                             url::CanonHostInfo* host_info) {
   // Try to canonicalize the host.
-  const url_parse::Component raw_host_component(
-      0, static_cast<int>(host.length()));
+  const url::Component raw_host_component(0, static_cast<int>(host.length()));
   std::string canon_host;
-  url_canon::StdStringCanonOutput canon_host_output(&canon_host);
-  url_canon::CanonicalizeHostVerbose(host.c_str(), raw_host_component,
-                                     &canon_host_output, host_info);
+  url::StdStringCanonOutput canon_host_output(&canon_host);
+  url::CanonicalizeHostVerbose(host.c_str(), raw_host_component,
+                               &canon_host_output, host_info);
 
   if (host_info->out_host.is_nonempty() &&
-      host_info->family != url_canon::CanonHostInfo::BROKEN) {
+      host_info->family != url::CanonHostInfo::BROKEN) {
     // Success!  Assert that there's no extra garbage.
     canon_host_output.Complete();
     DCHECK_EQ(host_info->out_host.len, static_cast<int>(canon_host.length()));
   } else {
     // Empty host, or canonicalization failed.  We'll return empty.
     canon_host.clear();
   }
 
   return canon_host;
 }
@@ skipping 107 matching lines @@
 #endif
 }
 
 bool ParseHostAndPort(std::string::const_iterator host_and_port_begin,
                       std::string::const_iterator host_and_port_end,
                       std::string* host,
                       int* port) {
   if (host_and_port_begin >= host_and_port_end)
     return false;
 
-  // When using url_parse, we use char*.
+  // When using url, we use char*.
   const char* auth_begin = &(*host_and_port_begin);
   int auth_len = host_and_port_end - host_and_port_begin;
 
-  url_parse::Component auth_component(0, auth_len);
-  url_parse::Component username_component;
-  url_parse::Component password_component;
-  url_parse::Component hostname_component;
-  url_parse::Component port_component;
+  url::Component auth_component(0, auth_len);
+  url::Component username_component;
+  url::Component password_component;
+  url::Component hostname_component;
+  url::Component port_component;
 
-  url_parse::ParseAuthority(auth_begin, auth_component, &username_component,
+  url::ParseAuthority(auth_begin, auth_component, &username_component,
       &password_component, &hostname_component, &port_component);
 
   // There shouldn't be a username/password.
   if (username_component.is_valid() || password_component.is_valid())
     return false;
 
   if (!hostname_component.is_nonempty())
     return false;  // Failed parsing.
 
   int parsed_port_number = -1;
   if (port_component.is_nonempty()) {
-    parsed_port_number = url_parse::ParsePort(auth_begin, port_component);
+    parsed_port_number = url::ParsePort(auth_begin, port_component);
 
     // If parsing failed, port_number will be either PORT_INVALID or
     // PORT_UNSPECIFIED, both of which are negative.
     if (parsed_port_number < 0)
       return false;  // Failed parsing the port number.
   }
 
   if (port_component.len == 0)
     return false;  // Reject inputs like "foo:"
 
@@ skipping 23 matching lines @@
   // so it is safe to just append a colon.
   if (url.has_port())
     return base::StringPrintf("%s:%s", url.host().c_str(), url.port().c_str());
   return url.host();
 }
 
 bool IsHostnameNonUnique(const std::string& hostname) {
   // CanonicalizeHost requires surrounding brackets to parse an IPv6 address.
   const std::string host_or_ip = hostname.find(':') != std::string::npos ?
       "[" + hostname + "]" : hostname;
-  url_canon::CanonHostInfo host_info;
+  url::CanonHostInfo host_info;
   std::string canonical_name = CanonicalizeHost(host_or_ip, &host_info);
 
   // If canonicalization fails, then the input is truly malformed. However,
   // to avoid mis-reporting bad inputs as "non-unique", treat them as unique.
   if (canonical_name.empty())
     return false;
 
   // If |hostname| is an IP address, check to see if it's in an IANA-reserved
   // range.
   if (host_info.IsIPAddress()) {
     IPAddressNumber host_addr;
     if (!ParseIPLiteralToNumber(hostname.substr(host_info.out_host.begin,
                                                 host_info.out_host.len),
                                 &host_addr)) {
       return false;
     }
     switch (host_info.family) {
-      case url_canon::CanonHostInfo::IPV4:
-      case url_canon::CanonHostInfo::IPV6:
+      case url::CanonHostInfo::IPV4:
+      case url::CanonHostInfo::IPV6:
         return IsIPAddressReserved(host_addr);
-      case url_canon::CanonHostInfo::NEUTRAL:
-      case url_canon::CanonHostInfo::BROKEN:
+      case url::CanonHostInfo::NEUTRAL:
+      case url::CanonHostInfo::BROKEN:
         return false;
     }
   }
 
   // Check for a registry controlled portion of |hostname|, ignoring private
   // registries, as they already chain to ICANN-administered registries,
   // and explicitly ignoring unknown registries.
   //
   // Note: This means that as new gTLDs are introduced on the Internet, they
   // will be treated as non-unique until the registry controlled domain list
@@ skipping 100 matching lines @@
     return true;
   }
 #endif
 
   return false;  // Unrecognized |sa_family|.
 }
 
 std::string IPAddressToString(const uint8* address,
                               size_t address_len) {
   std::string str;
-  url_canon::StdStringCanonOutput output(&str);
+  url::StdStringCanonOutput output(&str);
 
   if (address_len == kIPv4AddressSize) {
-    url_canon::AppendIPv4Address(address, &output);
+    url::AppendIPv4Address(address, &output);
   } else if (address_len == kIPv6AddressSize) {
-    url_canon::AppendIPv6Address(address, &output);
+    url::AppendIPv6Address(address, &output);
   } else {
     CHECK(false) << "Invalid IP address with length: " << address_len;
   }
 
   output.Complete();
   return str;
 }
 
 std::string IPAddressToStringWithPort(const uint8* address,
                                       size_t address_len,
@@ skipping 216 matching lines @@
   return AF_UNSPEC;
 }
 
 bool ParseIPLiteralToNumber(const std::string& ip_literal,
                             IPAddressNumber* ip_number) {
   // |ip_literal| could be either a IPv4 or an IPv6 literal. If it contains
   // a colon however, it must be an IPv6 address.
   if (ip_literal.find(':') != std::string::npos) {
     // GURL expects IPv6 hostnames to be surrounded with brackets.
     std::string host_brackets = "[" + ip_literal + "]";
-    url_parse::Component host_comp(0, host_brackets.size());
+    url::Component host_comp(0, host_brackets.size());
 
     // Try parsing the hostname as an IPv6 literal.
     ip_number->resize(16);  // 128 bits.
-    return url_canon::IPv6AddressToNumber(host_brackets.data(),
-                                          host_comp,
-                                          &(*ip_number)[0]);
+    return url::IPv6AddressToNumber(host_brackets.data(), host_comp,
+                                    &(*ip_number)[0]);
   }
 
   // Otherwise the string is an IPv4 address.
   ip_number->resize(4);  // 32 bits.
-  url_parse::Component host_comp(0, ip_literal.size());
+  url::Component host_comp(0, ip_literal.size());
   int num_components;
-  url_canon::CanonHostInfo::Family family = url_canon::IPv4AddressToNumber(
+  url::CanonHostInfo::Family family = url::IPv4AddressToNumber(
       ip_literal.data(), host_comp, &(*ip_number)[0], &num_components);
-  return family == url_canon::CanonHostInfo::IPV4;
+  return family == url::CanonHostInfo::IPV4;
 }
 
 namespace {
 
 const unsigned char kIPv4MappedPrefix[] =
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF };
 }
 
 IPAddressNumber ConvertIPv4NumberToIPv6Number(
     const IPAddressNumber& ipv4_number) {
@@ skipping 176 matching lines @@
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net