Revert of Reduce buggy usage of the registry controlled domain service.

net/base/registry_controlled_domains/registry_controlled_domain_unittest.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 "base/strings/utf_string_conversions.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
-#include "url/url_features.h"
 
 namespace {
-
 namespace test1 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc.cc"
 }
 namespace test2 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest2-inc.cc"
 }
 namespace test3 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest3-inc.cc"
 }
 namespace test4 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest4-inc.cc"
 }
 namespace test5 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest5-inc.cc"
 }
 namespace test6 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest6-inc.cc"
 }
-
 }  // namespace
 
 namespace net {
 namespace registry_controlled_domains {
-
 namespace {
 
 std::string GetDomainFromURL(const std::string& url) {
   return GetDomainAndRegistry(GURL(url), EXCLUDE_PRIVATE_REGISTRIES);
 }
 
 std::string GetDomainFromHost(const std::string& host) {
   return GetDomainAndRegistry(host, EXCLUDE_PRIVATE_REGISTRIES);
 }
 
 size_t GetRegistryLengthFromURL(
     const std::string& url,
     UnknownRegistryFilter unknown_filter) {
   return GetRegistryLength(GURL(url),
                            unknown_filter,
                            EXCLUDE_PRIVATE_REGISTRIES);
 }
 
 size_t GetRegistryLengthFromURLIncludingPrivate(
     const std::string& url,
     UnknownRegistryFilter unknown_filter) {
   return GetRegistryLength(GURL(url),
                            unknown_filter,
                            INCLUDE_PRIVATE_REGISTRIES);
 }
 
-size_t PermissiveGetHostRegistryLength(base::StringPiece host) {
-  return PermissiveGetHostRegistryLength(host, EXCLUDE_UNKNOWN_REGISTRIES,
-                                         EXCLUDE_PRIVATE_REGISTRIES);
+size_t GetRegistryLengthFromHost(
+    const std::string& host,
+    UnknownRegistryFilter unknown_filter) {
+  return GetRegistryLength(host, unknown_filter, EXCLUDE_PRIVATE_REGISTRIES);
 }
 
-// Only called when using ICU (avoids unused static function error).
-#if !BUILDFLAG(USE_PLATFORM_ICU_ALTERNATIVES)
-size_t PermissiveGetHostRegistryLength(base::StringPiece16 host) {
-  return PermissiveGetHostRegistryLength(host, EXCLUDE_UNKNOWN_REGISTRIES,
-                                         EXCLUDE_PRIVATE_REGISTRIES);
-}
-#endif
-
-size_t GetCanonicalHostRegistryLength(const std::string& host,
-                                      UnknownRegistryFilter unknown_filter) {
-  return GetCanonicalHostRegistryLength(host, unknown_filter,
-                                        EXCLUDE_PRIVATE_REGISTRIES);
-}
-
-size_t GetCanonicalHostRegistryLengthIncludingPrivate(const std::string& host) {
-  return GetCanonicalHostRegistryLength(host, EXCLUDE_UNKNOWN_REGISTRIES,
-                                        INCLUDE_PRIVATE_REGISTRIES);
+size_t GetRegistryLengthFromHostIncludingPrivate(
+    const std::string& host,
+    UnknownRegistryFilter unknown_filter) {
+  return GetRegistryLength(host, unknown_filter, INCLUDE_PRIVATE_REGISTRIES);
 }
 
 }  // namespace
 
 class RegistryControlledDomainTest : public testing::Test {
  protected:
   template <typename Graph>
   void UseDomainData(const Graph& graph) {
     SetFindDomainGraph(graph, sizeof(Graph));
   }
@@ skipping 130 matching lines @@
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.",
                                          EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.",
                                          INCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http:////Comment",
                                          EXCLUDE_UNKNOWN_REGISTRIES));
 
   // Test std::string version of GetRegistryLength().  Uses the same
   // underpinnings as the GURL version, so this is really more of a check of
   // CanonicalizeHost().
-  EXPECT_EQ(2U, GetCanonicalHostRegistryLength(
-                    "a.baz.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 1
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLength(
-                    "a.baz.jp.", EXCLUDE_UNKNOWN_REGISTRIES));  // 1
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength(
-                    "ac.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 2
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength(
-                    "a.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 3
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength(
-                    "bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 3
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength(
-                    "baz.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 3 4
-  EXPECT_EQ(12U, GetCanonicalHostRegistryLength(
-                     "a.b.baz.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 4
-  EXPECT_EQ(6U, GetCanonicalHostRegistryLength(
-                    "baz.pref.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 5
-  EXPECT_EQ(11U, GetCanonicalHostRegistryLength(
-                     "a.b.bar.baz.com", EXCLUDE_UNKNOWN_REGISTRIES));  // 6
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLength(
-                    "a.d.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLength(
-                    ".a.d.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLength(
-                    "..a.d.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7
-  EXPECT_EQ(1U, GetCanonicalHostRegistryLength(
-                    "a.b.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7 8
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength(
-                    "baz.com", EXCLUDE_UNKNOWN_REGISTRIES));  // none
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength(
-                    "baz.com.", EXCLUDE_UNKNOWN_REGISTRIES));  // none
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLength(
-                    "baz.com", INCLUDE_UNKNOWN_REGISTRIES));  // none
-  EXPECT_EQ(4U, GetCanonicalHostRegistryLength(
-                    "baz.com.", INCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(2U, GetRegistryLengthFromHost("a.baz.jp",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 1
+  EXPECT_EQ(3U, GetRegistryLengthFromHost("a.baz.jp.",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 1
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("ac.jp",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 2
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("a.bar.jp",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 3
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("bar.jp",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 3
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.bar.jp",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 3 4
+  EXPECT_EQ(12U, GetRegistryLengthFromHost("a.b.baz.bar.jp",
+                                           EXCLUDE_UNKNOWN_REGISTRIES)); // 4
+  EXPECT_EQ(6U, GetRegistryLengthFromHost("baz.pref.bar.jp",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 5
+  EXPECT_EQ(11U, GetRegistryLengthFromHost("a.b.bar.baz.com",
+                                           EXCLUDE_UNKNOWN_REGISTRIES)); // 6
+  EXPECT_EQ(3U, GetRegistryLengthFromHost("a.d.c",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7
+  EXPECT_EQ(3U, GetRegistryLengthFromHost(".a.d.c",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7
+  EXPECT_EQ(3U, GetRegistryLengthFromHost("..a.d.c",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7
+  EXPECT_EQ(1U, GetRegistryLengthFromHost("a.b.c",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7 8
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com.",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(3U, GetRegistryLengthFromHost("baz.com",
+                                          INCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(4U, GetRegistryLengthFromHost("baz.com.",
+                                          INCLUDE_UNKNOWN_REGISTRIES));  // none
 
-  EXPECT_EQ(std::string::npos, GetCanonicalHostRegistryLength(
-                                   std::string(), EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength("foo.com..",
-                                               EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength("..", EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength("192.168.0.1",
-                                               EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost",
-                                               EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost",
-                                               INCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost.",
-                                               EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost.",
-                                               INCLUDE_UNKNOWN_REGISTRIES));
-
-  // IDN case.
-  EXPECT_EQ(10U, GetCanonicalHostRegistryLength("foo.xn--fiqs8s",
-                                                EXCLUDE_UNKNOWN_REGISTRIES));
-}
-
-TEST_F(RegistryControlledDomainTest, HostHasRegistryControlledDomain) {
-  UseDomainData(test1::kDafsa);
-
-  // Invalid hosts.
-  EXPECT_FALSE(HostHasRegistryControlledDomain(
-      std::string(), EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES));
-  EXPECT_FALSE(HostHasRegistryControlledDomain(
-      "%00asdf", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES));
-
-  // Invalid host but valid R.C.D.
-  EXPECT_TRUE(HostHasRegistryControlledDomain(
-      "%00foo.jp", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES));
-
-  // Valid R.C.D. when canonicalized, even with an invalid prefix and an
-  // escaped dot.
-  EXPECT_TRUE(HostHasRegistryControlledDomain("%00foo.Google%2EjP",
-                                              EXCLUDE_UNKNOWN_REGISTRIES,
-                                              EXCLUDE_PRIVATE_REGISTRIES));
-
-  // Regular, no match.
-  EXPECT_FALSE(HostHasRegistryControlledDomain(
-      "bar.notatld", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES));
-
-  // Regular, match.
-  EXPECT_TRUE(HostHasRegistryControlledDomain(
-      "www.Google.Jp", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES));
+  EXPECT_EQ(std::string::npos,
+      GetRegistryLengthFromHost(std::string(), EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("foo.com..",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("..",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("192.168.0.1",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost",
+                                          INCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.",
+                                          EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.",
+                                          INCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) {
   UseDomainData(test2::kDafsa);
 
   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
@@ skipping 101 matching lines @@
   const char key0[] =
       "a.b.6____________________________________________________"
       "________________________________________________6";
   const char key1[] =
       "a.b.7____________________________________________________"
       "________________________________________________7";
   const char key2[] =
       "a.b.a____________________________________________________"
       "________________________________________________8";
 
+  EXPECT_EQ(102U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(102U,
-            GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(102U, GetCanonicalHostRegistryLengthIncludingPrivate(key1));
-  EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestDafsaThreeByteOffsets) {
   UseDomainData(test4::kDafsa);
 
   // Testing to lookup keys in a DAFSA with three byte offsets.
   // This DAFSA is constructed so that labels begin and end with unique
   // characters, which makes it impossible to merge labels. The byte array
   // has a size of ~54k. A two byte offset can add at most add 8k to the
   // previous offset. Since we can skip only forward in memory, the nodes
   // representing the return values must be located near the end of the byte
   // array. The probability that we can reach from an arbitrary inner node to
   // a return value without using a three byte offset is small (but not zero).
   // The test is repeated with some different keys and with a reasonable
   // probability at least one of the tested paths has go over a three byte
   // offset.
 
   const char key0[] =
-      "a.b.z6___________________________________________________"
-      "_________________________________________________z6";
+      "a.b.Z6___________________________________________________"
+      "_________________________________________________Z6";
   const char key1[] =
-      "a.b.z7___________________________________________________"
-      "_________________________________________________z7";
+      "a.b.Z7___________________________________________________"
+      "_________________________________________________Z7";
   const char key2[] =
-      "a.b.za___________________________________________________"
-      "_________________________________________________z8";
+      "a.b.Za___________________________________________________"
+      "_________________________________________________Z8";
 
+  EXPECT_EQ(104U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(104U,
-            GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(104U, GetCanonicalHostRegistryLengthIncludingPrivate(key1));
-  EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedPrefixes) {
   UseDomainData(test5::kDafsa);
 
   // Testing to lookup keys in a DAFSA with compressed prefixes.
   // This DAFSA is constructed from words with similar prefixes but distinct
   // suffixes. The DAFSA will then form a trie with the implicit source node
   // as root.
 
   const char key0[] = "a.b.ai";
   const char key1[] = "a.b.bj";
   const char key2[] = "a.b.aak";
   const char key3[] = "a.b.bbl";
   const char key4[] = "a.b.aaa";
   const char key5[] = "a.b.bbb";
   const char key6[] = "a.b.aaaam";
   const char key7[] = "a.b.bbbbn";
 
+  EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(2U,
-            GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(3U,
+            GetRegistryLengthFromHostIncludingPrivate(
+                key3, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(2U, GetCanonicalHostRegistryLengthIncludingPrivate(key1));
-  EXPECT_EQ(3U,
-            GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key4, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key3, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLengthIncludingPrivate(key3));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key4));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key5));
-  EXPECT_EQ(5U,
-            GetCanonicalHostRegistryLength(key6, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(5U,
-            GetCanonicalHostRegistryLength(key7, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key5, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedSuffixes) {
   UseDomainData(test6::kDafsa);
 
   // Testing to lookup keys in a DAFSA with compressed suffixes.
   // This DAFSA is constructed from words with similar suffixes but distinct
   // prefixes. The DAFSA will then form a trie with the implicit sink node as
   // root.
 
   const char key0[] = "a.b.ia";
   const char key1[] = "a.b.jb";
   const char key2[] = "a.b.kaa";
   const char key3[] = "a.b.lbb";
   const char key4[] = "a.b.aaa";
   const char key5[] = "a.b.bbb";
   const char key6[] = "a.b.maaaa";
   const char key7[] = "a.b.nbbbb";
 
+  EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(2U,
-            GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(3U,
+            GetRegistryLengthFromHostIncludingPrivate(
+                key3, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(2U, GetCanonicalHostRegistryLengthIncludingPrivate(key1));
-  EXPECT_EQ(3U,
-            GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key4, EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U,
-            GetCanonicalHostRegistryLength(key3, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(3U, GetCanonicalHostRegistryLengthIncludingPrivate(key3));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key4));
-  EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key5));
-  EXPECT_EQ(5U,
-            GetCanonicalHostRegistryLength(key6, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(5U,
-            GetCanonicalHostRegistryLength(key7, EXCLUDE_UNKNOWN_REGISTRIES));
+            GetRegistryLengthFromHostIncludingPrivate(
+                key5, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
 }
-
-TEST_F(RegistryControlledDomainTest, Permissive) {
-  UseDomainData(test1::kDafsa);
-
-  EXPECT_EQ(std::string::npos, PermissiveGetHostRegistryLength(""));
-
-  // Regular non-canonical host name.
-  EXPECT_EQ(2U, PermissiveGetHostRegistryLength("Www.Google.Jp"));
-  EXPECT_EQ(3U, PermissiveGetHostRegistryLength("Www.Google.Jp."));
-
-  // Empty returns npos.
-  EXPECT_EQ(std::string::npos, PermissiveGetHostRegistryLength(""));
-
-  // Trailing spaces are counted as part of the hostname, meaning this will
-  // not match a known registry.
-  EXPECT_EQ(0U, PermissiveGetHostRegistryLength("Www.Google.Jp "));
-
-  // Invalid characters at the beginning are OK if the suffix still matches.
-  EXPECT_EQ(2U, PermissiveGetHostRegistryLength("*%00#?.Jp"));
-
-  // Escaped period, this will add new components.
-  EXPECT_EQ(4U, PermissiveGetHostRegistryLength("Www.Googl%45%2e%4Ap"));
-
-// IDN cases (not supported when not linking ICU).
-#if !BUILDFLAG(USE_PLATFORM_ICU_ALTERNATIVES)
-  EXPECT_EQ(10U, PermissiveGetHostRegistryLength("foo.xn--fiqs8s"));
-  EXPECT_EQ(11U, PermissiveGetHostRegistryLength("foo.xn--fiqs8s."));
-  EXPECT_EQ(18U, PermissiveGetHostRegistryLength("foo.%E4%B8%AD%E5%9B%BD"));
-  EXPECT_EQ(19U, PermissiveGetHostRegistryLength("foo.%E4%B8%AD%E5%9B%BD."));
-  EXPECT_EQ(6U,
-            PermissiveGetHostRegistryLength("foo.\xE4\xB8\xAD\xE5\x9B\xBD"));
-  EXPECT_EQ(7U,
-            PermissiveGetHostRegistryLength("foo.\xE4\xB8\xAD\xE5\x9B\xBD."));
-  // UTF-16 IDN.
-  EXPECT_EQ(2U, PermissiveGetHostRegistryLength(
-                    base::WideToUTF16(L"foo.\x4e2d\x56fd")));
-
-  // Fullwidth dot (u+FF0E) that will get canonicalized to a dot.
-  EXPECT_EQ(2U, PermissiveGetHostRegistryLength("Www.Google\xEF\xBC\x8Ejp"));
-  // Same but also ending in a fullwidth dot.
-  EXPECT_EQ(5U, PermissiveGetHostRegistryLength(
-                    "Www.Google\xEF\xBC\x8Ejp\xEF\xBC\x8E"));
-  // Escaped UTF-8, also with an escaped fullwidth "Jp".
-  // "Jp" = U+FF2A, U+FF50, UTF-8 = EF BC AA EF BD 90
-  EXPECT_EQ(27U, PermissiveGetHostRegistryLength(
-                     "Www.Google%EF%BC%8E%EF%BC%AA%EF%BD%90%EF%BC%8E"));
-  // UTF-16 (ending in a dot).
-  EXPECT_EQ(3U, PermissiveGetHostRegistryLength(
-                    base::WideToUTF16(L"Www.Google\xFF0E\xFF2A\xFF50\xFF0E")));
-#endif
-}
-
 }  // namespace registry_controlled_domains
 }  // namespace net