More net/ reordering.

net/base/registry_controlled_domain.cc

 //* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 33 matching lines @@
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 #include "net/base/net_module.h"
 #include "net/base/net_util.h"
 
 #include "effective_tld_names.cc"
 
 namespace net {
 
-static const int kExceptionRule = 1;
-static const int kWildcardRule = 2;
+namespace {
 
-RegistryControlledDomainService::RegistryControlledDomainService()
-    : find_domain_function_(Perfect_Hash::FindDomain) {
-}
+const int kExceptionRule = 1;
+const int kWildcardRule = 2;
+
+RegistryControlledDomainService* test_instance_;
+
+}  // namespace
 
 // static
 std::string RegistryControlledDomainService::GetDomainAndRegistry(
     const GURL& gurl) {
   const url_parse::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));
@@ skipping 78 matching lines @@
   const std::string canon_host(net::CanonicalizeHost(host, &host_info));
   if (canon_host.empty())
     return std::string::npos;
   if (host_info.IsIPAddress())
     return 0;
   return GetInstance()->GetRegistryLengthImpl(canon_host,
                                               allow_unknown_registries);
 }
 
 // static
+RegistryControlledDomainService* RegistryControlledDomainService::GetInstance()
+{
+  if (test_instance_)
+    return test_instance_;
+
+  return Singleton<RegistryControlledDomainService>::get();
+}
+
+RegistryControlledDomainService::RegistryControlledDomainService()
+    : find_domain_function_(Perfect_Hash::FindDomain) {
+}
+
+// static
+RegistryControlledDomainService* RegistryControlledDomainService::SetInstance(
+    RegistryControlledDomainService* instance) {
+  RegistryControlledDomainService* old_instance = test_instance_;
+  test_instance_ = instance;
+  return old_instance;
+}
+
+// static
+void RegistryControlledDomainService::UseFindDomainFunction(
+    FindDomainPtr function) {
+  RegistryControlledDomainService* instance = GetInstance();
+  instance->find_domain_function_ = function;
+}
+
+// static
 std::string RegistryControlledDomainService::GetDomainAndRegistryImpl(
     const std::string& host) {
   DCHECK(!host.empty());
 
   // Find the length of the registry for this host.
   const size_t registry_length =
       GetInstance()->GetRegistryLengthImpl(host, true);
   if ((registry_length == std::string::npos) || (registry_length == 0))
     return std::string();  // No registry.
   // The "2" in this next line is 1 for the dot, plus a 1-char minimum preceding
@@ skipping 86 matching lines @@
     curr_start = next_dot + 1;
     next_dot = host.find('.', curr_start);
   }
 
   // No rule found in the registry.  curr_start now points to the first
   // character of the last subcomponent of the host, so if we allow unknown
   // registries, return the length of this subcomponent.
   return allow_unknown_registries ? (host.length() - curr_start) : 0;
 }
 
-static RegistryControlledDomainService* test_instance_;
-
-// static
-RegistryControlledDomainService* RegistryControlledDomainService::SetInstance(
-    RegistryControlledDomainService* instance) {
-  RegistryControlledDomainService* old_instance = test_instance_;
-  test_instance_ = instance;
-  return old_instance;
-}
-
-// static
-RegistryControlledDomainService* RegistryControlledDomainService::GetInstance()
-{
-  if (test_instance_)
-    return test_instance_;
-
-  return Singleton<RegistryControlledDomainService>::get();
-}
-
-// static
-void RegistryControlledDomainService::UseFindDomainFunction(
-    FindDomainPtr function) {
-  RegistryControlledDomainService* instance = GetInstance();
-  instance->find_domain_function_ = function;
-}
-
 }  // namespace net