Make RegistryControlledDomainService a static-function container class, rather than a Singleton

net/base/registry_controlled_domain.h

-//* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// Copyright (c) 2011 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.h)
 /* ***** 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,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
@@ skipping 17 matching lines @@
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-// NB: Modelled after Mozilla's code (originally written by Pamela Greene,
-// later modified by others), but almost entirely rewritten for Chrome.
-
 /*
   (Documentation based on the Mozilla documentation currently at
   http://wiki.mozilla.org/Gecko:Effective_TLD_Service, written by the same
   author.)
 
   The RegistryControlledDomainService examines the hostname of a GURL passed to
   it and determines the longest portion that is controlled by a registrar.
   Although technically the top-level domain (TLD) for a hostname is the last
   dot-portion of the name (such as .com or .org), many domains (such as co.uk)
   function as though they were TLDs, allocating any number of more specific,
@@ skipping 59 matching lines @@
 #define NET_BASE_REGISTRY_CONTROLLED_DOMAIN_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "net/base/net_export.h"
 
 class GURL;
 
-template <typename T>
-struct DefaultSingletonTraits;
 struct DomainRule;
 
 namespace net {
 
-struct RegistryControlledDomainServiceSingletonTraits;
-
-// This class is a singleton.
 class NET_EXPORT RegistryControlledDomainService {
  public:
-   ~RegistryControlledDomainService() { }
-
   // Returns the registered, organization-identifying host and all its registry
   // information, but no subdomains, from the given GURL.  Returns an empty
   // string if the GURL is invalid, has no host (e.g. a file: URL), has multiple
   // trailing dots, is an IP address, has only one subcomponent (i.e. no dots
   // other than leading/trailing ones), or is itself a recognized registry
   // identifier.  If no matching rule is found in the effective-TLD data (or in
   // the default data, if the resource failed to load), the last subcomponent of
   // the host is assumed to be the registry.
   //
   // Examples:
@@ skipping 45 matching lines @@
   //   http://foo.bar/file.html        -> 0 or 3, depending (no rule; assume
   //                                                         bar)
   static size_t GetRegistryLength(const GURL& gurl,
                                   bool allow_unknown_registries);
 
   // Like the GURL version, but takes a host (which is canonicalized internally)
   // instead of a full GURL.
   static size_t GetRegistryLength(const std::string& host,
                                   bool allow_unknown_registries);
 
-  // Returns the singleton instance, after attempting to initialize it.
-  // NOTE that if the effective-TLD data resource can't be found, the instance
-  // will be initialized and continue operation with simple default TLD data.
-  static RegistryControlledDomainService* GetInstance();
-
- protected:
-  typedef const struct DomainRule* (*FindDomainPtr)(const char *, unsigned int);
-
-  // The entire protected API is only for unit testing.  I mean it.  Don't make
-  // me come over there!
-  RegistryControlledDomainService();
-
-  // Set the RegistryControledDomainService instance to be used internally.
-  // |instance| will supersede the singleton instance normally used.  If
-  // |instance| is NULL, normal behavior is restored, and internal operations
-  // will return to using the singleton.  This function always returns the
-  // instance set by the most recent call to SetInstance.
-  static RegistryControlledDomainService* SetInstance(
-      RegistryControlledDomainService* instance);
-
-  // Used for unit tests, so that a different perfect hash map from the full
-  // list is used.
-  static void UseFindDomainFunction(FindDomainPtr function);
-
  private:
-  // To allow construction of the internal singleton instance.
-  friend struct DefaultSingletonTraits<RegistryControlledDomainService>;
+  friend class RegistryControlledDomainTest;
 
   // Internal workings of the static public methods.  See above.
   static std::string GetDomainAndRegistryImpl(const std::string& host);
-  size_t GetRegistryLengthImpl(const std::string& host,
-                               bool allow_unknown_registries);
+  static size_t GetRegistryLengthImpl(const std::string& host,
+                                      bool allow_unknown_registries);
+
+  typedef const struct DomainRule* (*FindDomainPtr)(const char *, unsigned int);

[wtc, 2011/10/27 22:44:09]

Nit: list this typedef at the beginning of the private section.

[Ryan Sleevi, 2011/10/27 22:48:04]

Will send a quick cleanup CL.

+
+  // Used for unit tests, so that a different perfect hash map from the full
+  // list is used. Set to NULL to use the Default function.
+  static void UseFindDomainFunction(FindDomainPtr function);
 
   // Function that returns a DomainRule given a domain.
-  FindDomainPtr find_domain_function_;
+  static FindDomainPtr find_domain_function_;
 
-  DISALLOW_COPY_AND_ASSIGN(RegistryControlledDomainService);
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(RegistryControlledDomainService);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_REGISTRY_CONTROLLED_DOMAIN_H_