Renamed namespaces in src/net.

net/base/registry_controlled_domains/registry_controlled_domain.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.
 
 // NB: Modelled after Mozilla's code (originally written by Pamela Greene,
 // later modified by others), but almost entirely rewritten for Chrome.
 //   (netwerk/dns/src/nsEffectiveTLDService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 176 matching lines @@
   if (dot == std::string::npos)
     return host;
   return host.substr(dot + 1);
 }
 
 }  // namespace
 
 std::string GetDomainAndRegistry(
     const GURL& gurl,
     PrivateRegistryFilter filter) {
-  const url_parse::Component host =
-      gurl.parsed_for_possibly_invalid_spec().host;
+  const url::Component host = gurl.parsed_for_possibly_invalid_spec().host;
   if ((host.len <= 0) || gurl.HostIsIPAddress())
     return std::string();
   return GetDomainAndRegistryImpl(std::string(
       gurl.possibly_invalid_spec().data() + host.begin, host.len), filter);
 }
 
 std::string GetDomainAndRegistry(
     const std::string& host,
     PrivateRegistryFilter filter) {
-  url_canon::CanonHostInfo host_info;
+  url::CanonHostInfo host_info;
   const std::string canon_host(CanonicalizeHost(host, &host_info));
   if (canon_host.empty() || host_info.IsIPAddress())
     return std::string();
   return GetDomainAndRegistryImpl(canon_host, filter);
 }
 
 bool SameDomainOrHost(
     const GURL& gurl1,
     const GURL& gurl2,
     PrivateRegistryFilter filter) {
   // See if both URLs have a known domain + registry, and those values are the
   // same.
   const std::string domain1(GetDomainAndRegistry(gurl1, filter));
   const std::string domain2(GetDomainAndRegistry(gurl2, filter));
   if (!domain1.empty() || !domain2.empty())
     return domain1 == domain2;
 
   // No domains.  See if the hosts are identical.
-  const url_parse::Component host1 =
-      gurl1.parsed_for_possibly_invalid_spec().host;
-  const url_parse::Component host2 =
-      gurl2.parsed_for_possibly_invalid_spec().host;
+  const url::Component host1 = gurl1.parsed_for_possibly_invalid_spec().host;
+  const url::Component host2 = gurl2.parsed_for_possibly_invalid_spec().host;
   if ((host1.len <= 0) || (host1.len != host2.len))
     return false;
   return !strncmp(gurl1.possibly_invalid_spec().data() + host1.begin,
                   gurl2.possibly_invalid_spec().data() + host2.begin,
                   host1.len);
 }
 
 size_t GetRegistryLength(
     const GURL& gurl,
     UnknownRegistryFilter unknown_filter,
     PrivateRegistryFilter private_filter) {
-  const url_parse::Component host =
-      gurl.parsed_for_possibly_invalid_spec().host;
+  const url::Component host = gurl.parsed_for_possibly_invalid_spec().host;
   if (host.len <= 0)
     return std::string::npos;
   if (gurl.HostIsIPAddress())
     return 0;
   return GetRegistryLengthImpl(
       std::string(gurl.possibly_invalid_spec().data() + host.begin, host.len),
       unknown_filter,
       private_filter);
 }
 
 size_t GetRegistryLength(
     const std::string& host,
     UnknownRegistryFilter unknown_filter,
     PrivateRegistryFilter private_filter) {
-  url_canon::CanonHostInfo host_info;
+  url::CanonHostInfo host_info;
   const std::string canon_host(CanonicalizeHost(host, &host_info));
   if (canon_host.empty())
     return std::string::npos;
   if (host_info.IsIPAddress())
     return 0;
   return GetRegistryLengthImpl(canon_host, unknown_filter, private_filter);
 }
 
 void SetFindDomainFunctionAndStringPoolForTesting(FindDomainPtr function,
                                                   const char* stringpool) {
   g_find_domain_function = function ? function : kDefaultFindDomainFunction;
   g_stringpool = stringpool ? stringpool : kDefaultStringPool;
 }
 
 }  // namespace registry_controlled_domains
 }  // namespace net