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

net/base/registry_controlled_domain_unittest.cc

 // 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.
 
 #include "googleurl/src/gurl.h"
 #include "net/base/registry_controlled_domain.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "effective_tld_names_unittest1.cc"
 #undef TOTAL_KEYWORDS
 #undef MIN_WORD_LENGTH
 #undef MAX_WORD_LENGTH
 #undef MIN_HASH_VALUE
 #undef MAX_HASH_VALUE
 #include "effective_tld_names_unittest2.cc"
 
 namespace net {
 namespace {
 
-class TestRegistryControlledDomainService :
-    public RegistryControlledDomainService {
- public:
-  // Sets the given data.
-  static void UseDomainData(FindDomainPtr function) {
-    RegistryControlledDomainService::UseFindDomainFunction(function);
-  }
-
-  // Creates a new dedicated instance to be used for testing, deleting any
-  // previously-set one.
-  static void UseDedicatedInstance() {
-    delete static_cast<TestRegistryControlledDomainService*>(
-        SetInstance(new TestRegistryControlledDomainService()));
-  }
-
-  // Restores RegistryControlledDomainService to using its default instance,
-  // deleting any previously-set test instance.
-  static void UseDefaultInstance() {
-    delete static_cast<TestRegistryControlledDomainService*>(SetInstance(NULL));
-  }
-};
-
-class RegistryControlledDomainTest : public testing::Test {
- protected:
-  virtual void SetUp() {
-    TestRegistryControlledDomainService::UseDedicatedInstance();
-  }
-
-  virtual void TearDown() {
-    TestRegistryControlledDomainService::UseDefaultInstance();
-  }
-};
-
-
 std::string GetDomainFromURL(const std::string& url) {
-  return TestRegistryControlledDomainService::GetDomainAndRegistry(GURL(url));
+  return RegistryControlledDomainService::GetDomainAndRegistry(GURL(url));
 }
 
 std::string GetDomainFromHost(const std::string& host) {
-  return TestRegistryControlledDomainService::GetDomainAndRegistry(host);
+  return RegistryControlledDomainService::GetDomainAndRegistry(host);
 }
 
 size_t GetRegistryLengthFromURL(const std::string& url,
                                 bool allow_unknown_registries) {
-  return TestRegistryControlledDomainService::GetRegistryLength(GURL(url),
+  return RegistryControlledDomainService::GetRegistryLength(GURL(url),
       allow_unknown_registries);
 }
 
 size_t GetRegistryLengthFromHost(const std::string& host,
                                  bool allow_unknown_registries) {
-  return TestRegistryControlledDomainService::GetRegistryLength(host,
+  return RegistryControlledDomainService::GetRegistryLength(host,
       allow_unknown_registries);
 }
 
 bool CompareDomains(const std::string& url1, const std::string& url2) {
   GURL g1 = GURL(url1);
   GURL g2 = GURL(url2);
-  return TestRegistryControlledDomainService::SameDomainOrHost(g1, g2);
+  return RegistryControlledDomainService::SameDomainOrHost(g1, g2);
 }
 
+}  // namespace
+
+class RegistryControlledDomainTest : public testing::Test {
+ protected:
+  typedef RegistryControlledDomainService::FindDomainPtr FindDomainPtr;
+  void UseDomainData(FindDomainPtr function) {
+    RegistryControlledDomainService::UseFindDomainFunction(function);
+  }
+
+  virtual void TearDown() {
+    RegistryControlledDomainService::UseFindDomainFunction(NULL);
+  }
+};
+
 TEST_F(RegistryControlledDomainTest, TestGetDomainAndRegistry) {
-  TestRegistryControlledDomainService::UseDomainData(
-      Perfect_Hash_Test1::FindDomain);
+  UseDomainData(Perfect_Hash_Test1::FindDomain);
 
   // Test GURL version of GetDomainAndRegistry().
   EXPECT_EQ("baz.jp", GetDomainFromURL("http://a.baz.jp/file.html"));    // 1
   EXPECT_EQ("baz.jp.", GetDomainFromURL("http://a.baz.jp./file.html"));  // 1
   EXPECT_EQ("", GetDomainFromURL("http://ac.jp"));                       // 2
   EXPECT_EQ("", GetDomainFromURL("http://a.bar.jp"));                    // 3
   EXPECT_EQ("", GetDomainFromURL("http://bar.jp"));                      // 3
   EXPECT_EQ("", GetDomainFromURL("http://baz.bar.jp"));                  // 3 4
   EXPECT_EQ("a.b.baz.bar.jp", GetDomainFromURL("http://a.b.baz.bar.jp"));
                                                                          // 4
@@ skipping 38 matching lines @@
 
   EXPECT_EQ("", GetDomainFromHost(""));
   EXPECT_EQ("", GetDomainFromHost("foo.com.."));
   EXPECT_EQ("", GetDomainFromHost("..."));
   EXPECT_EQ("", GetDomainFromHost("192.168.0.1"));
   EXPECT_EQ("", GetDomainFromHost("localhost."));
   EXPECT_EQ("", GetDomainFromHost(".localhost."));
 }
 
 TEST_F(RegistryControlledDomainTest, TestGetRegistryLength) {
-  TestRegistryControlledDomainService::UseDomainData(
-      Perfect_Hash_Test1::FindDomain);
+  UseDomainData(Perfect_Hash_Test1::FindDomain);
 
   // Test GURL version of GetRegistryLength().
   EXPECT_EQ(2U, GetRegistryLengthFromURL("http://a.baz.jp/file.html", false));
                                                                         // 1
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://a.baz.jp./file.html", false));
                                                                         // 1
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://ac.jp", false));       // 2
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://a.bar.jp", false));    // 3
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://bar.jp", false));      // 3
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://baz.bar.jp", false));  // 3 4
@@ skipping 50 matching lines @@
   EXPECT_EQ(0U, GetRegistryLengthFromHost("foo.com..", false));
   EXPECT_EQ(0U, GetRegistryLengthFromHost("..", false));
   EXPECT_EQ(0U, GetRegistryLengthFromHost("192.168.0.1", false));
   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost", false));
   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost", true));
   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.", false));
   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.", true));
 }
 
 TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) {
-  TestRegistryControlledDomainService::UseDomainData(
-      Perfect_Hash_Test2::FindDomain);
+  UseDomainData(Perfect_Hash_Test2::FindDomain);
 
   EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
                              "http://a.b.bar.jp/file.html"));  // b.bar.jp
   EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
                              "http://b.b.bar.jp/file.html"));  // b.bar.jp
   EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",     // foo.jp
                               "http://a.not.jp/file.html"));   // not.jp
   EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",     // foo.jp
                               "http://a.foo.jp./file.html"));  // foo.jp.
   EXPECT_FALSE(CompareDomains("http://a.com/file.html",        // a.com
                               "http://b.com/file.html"));      // b.com
   EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
                              "http://b.x.com/file.html"));     // x.com
   EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
                              "http://.x.com/file.html"));      // x.com
   EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
                              "http://..b.x.com/file.html"));   // x.com
   EXPECT_TRUE(CompareDomains("http://intranet/file.html",
                              "http://intranet/file.html"));    // intranet
   EXPECT_TRUE(CompareDomains("http://127.0.0.1/file.html",
                              "http://127.0.0.1/file.html"));   // 127.0.0.1
   EXPECT_FALSE(CompareDomains("http://192.168.0.1/file.html",  // 192.168.0.1
                               "http://127.0.0.1/file.html"));  // 127.0.0.1
   EXPECT_FALSE(CompareDomains("file:///C:/file.html",
                               "file:///C:/file.html"));        // no host
 }
 
 TEST_F(RegistryControlledDomainTest, TestDefaultData) {
-  TestRegistryControlledDomainService::UseDefaultInstance();
-
   // Note that no data is set: we're using the default rules.
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://google.com", false));
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://stanford.edu", false));
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://ustreas.gov", false));
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://icann.net", false));
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://ferretcentral.org", false));
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://nowhere.foo", false));
   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://nowhere.foo", true));
 }
 
-}  // namespace

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

Why did you need to reduce the unnamed namespace?  Just
curious.

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

friend scope. Because RegistryControlledDomainService is in net::, the implicit
forward declare from "friend class RegistryControlledDomainTest" declares a
net::RegistryControlledDomainTest.

The same pattern is used throughout the GTest friending, as far as I could tell.

 }  // namespace net