Componentizes builtin_provider_unittest.cc.

components/omnibox/browser/builtin_provider_unittest.cc

Index: components/omnibox/browser/builtin_provider_unittest.cc
diff --git a/chrome/browser/autocomplete/builtin_provider_unittest.cc b/components/omnibox/browser/builtin_provider_unittest.cc
similarity index 47%
rename from chrome/browser/autocomplete/builtin_provider_unittest.cc
rename to components/omnibox/browser/builtin_provider_unittest.cc
index 988c2c6341286317f8418259bd00226cf62e5fae..9cd705d2e88be6d978b008bec2de6f5acb429598 100644
--- a/chrome/browser/autocomplete/builtin_provider_unittest.cc
+++ b/components/omnibox/browser/builtin_provider_unittest.cc
@@ -11,20 +11,73 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_provider_client.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
-#include "chrome/common/url_constants.h"
-#include "chrome/test/base/testing_profile.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/browser/autocomplete_input.h"
 #include "components/omnibox/browser/autocomplete_match.h"
 #include "components/omnibox/browser/autocomplete_provider.h"
-#include "content/public/test/test_browser_thread_bundle.h"
+#include "components/omnibox/browser/mock_autocomplete_provider_client.h"
+#include "components/omnibox/browser/test_scheme_classifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 
+namespace {
+
+const char kEmbedderAboutScheme[] = "chrome";
+const char kDefaultURL1[] = "chrome://default1/";
+const char kDefaultURL2[] = "chrome://default2/";
+const char kDefaultURL3[] = "chrome://foo/";
+const char kSubpageURL[] = "chrome://subpage/";
+
+// Arbitrary host constants, chosen to start with the letters "b" and "me".
+const char kHostBar[] = "bar";
+const char kHostMedia[] = "media";
+const char kHostMemory[] = "memory";
+const char kHostMemoryInternals[] = "memory-internals";
+const char kHostSubpage[] = "subpage";
+
+const char kSubpageOne[] = "one";
+const char kSubpageTwo[] = "two";
+const char kSubpageThree[] = "three";
+
+class FakeAutocompleteProviderClient : public MockAutocompleteProviderClient {
+ public:
+  FakeAutocompleteProviderClient() {}
+
+  std::string GetEmbedderRepresentationOfAboutScheme() override {
+    return kEmbedderAboutScheme;
+  }
+
+  std::vector<base::string16> GetBuiltinURLs() override {
+    std::vector<base::string16> urls;
+    urls.push_back(ASCIIToUTF16(kHostBar));
+    urls.push_back(ASCIIToUTF16(kHostMedia));
+    urls.push_back(ASCIIToUTF16(kHostMemory));
+    urls.push_back(ASCIIToUTF16(kHostMemoryInternals));
+    urls.push_back(ASCIIToUTF16(kHostSubpage));
+
+    base::string16 prefix = ASCIIToUTF16(kHostSubpage) + ASCIIToUTF16("/");
+    urls.push_back(prefix + ASCIIToUTF16(kSubpageOne));
+    urls.push_back(prefix + ASCIIToUTF16(kSubpageTwo));
+    urls.push_back(prefix + ASCIIToUTF16(kSubpageThree));
+    return urls;
+  }
+
+  std::vector<base::string16> GetBuiltinsToProvideAsUserTypes() override {
+    std::vector<base::string16> urls;
+    urls.push_back(ASCIIToUTF16(kDefaultURL1));
+    urls.push_back(ASCIIToUTF16(kDefaultURL2));
+    urls.push_back(ASCIIToUTF16(kDefaultURL3));
+    return urls;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeAutocompleteProviderClient);
+};
+
+}  // namespace
+
 class BuiltinProviderTest : public testing::Test {
  protected:
   struct TestData {
@@ -37,8 +90,7 @@ class BuiltinProviderTest : public testing::Test {
   ~BuiltinProviderTest() override {}
 
   void SetUp() override {
-    profile_.reset(new TestingProfile());
-    client_.reset(new ChromeAutocompleteProviderClient(profile_.get()));
+    client_.reset(new FakeAutocompleteProviderClient());
     provider_ = new BuiltinProvider(client_.get());
   }
   void TearDown() override { provider_ = NULL; }
@@ -51,7 +103,7 @@ class BuiltinProviderTest : public testing::Test {
       const AutocompleteInput input(
           cases[i].input, base::string16::npos, std::string(), GURL(),
           metrics::OmniboxEventProto::INVALID_SPEC, true, false, true, true,
-          false, ChromeAutocompleteSchemeClassifier(NULL));
+          false, TestSchemeClassifier());
       provider_->Start(input, false);
       EXPECT_TRUE(provider_->done());
       matches = provider_->matches();
@@ -65,29 +117,25 @@ class BuiltinProviderTest : public testing::Test {
     }
   }
 
-  content::TestBrowserThreadBundle thread_bundle_;
-
-  scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<ChromeAutocompleteProviderClient> client_;
+  scoped_ptr<FakeAutocompleteProviderClient> client_;
   scoped_refptr<BuiltinProvider> provider_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BuiltinProviderTest);
 };
 
-#if !defined(OS_ANDROID)
 TEST_F(BuiltinProviderTest, TypingScheme) {
   const base::string16 kAbout = ASCIIToUTF16(url::kAboutScheme);
-  const base::string16 kChrome = ASCIIToUTF16(content::kChromeUIScheme);
+  const base::string16 kEmbedder = ASCIIToUTF16(kEmbedderAboutScheme);
   const base::string16 kSeparator1 = ASCIIToUTF16(":");
   const base::string16 kSeparator2 = ASCIIToUTF16(":/");
   const base::string16 kSeparator3 =
       ASCIIToUTF16(url::kStandardSchemeSeparator);
 
   // These default URLs should correspond with those in BuiltinProvider::Start.
-  const GURL kURL1 = GURL(chrome::kChromeUIChromeURLsURL);
-  const GURL kURL2 = GURL(chrome::kChromeUISettingsURL);
-  const GURL kURL3 = GURL(chrome::kChromeUIVersionURL);
+  const GURL kURL1(kDefaultURL1);
+  const GURL kURL2(kDefaultURL2);
+  const GURL kURL3(kDefaultURL3);
 
   TestData typing_scheme_cases[] = {
     // Typing an unrelated scheme should give nothing.
@@ -110,68 +158,21 @@ TEST_F(BuiltinProviderTest, TypingScheme) {
     {kAbout + kSeparator3,     3, {kURL1, kURL2, kURL3}},
     {ASCIIToUTF16("aBoUT://"), 3, {kURL1, kURL2, kURL3}},
 
-    // Typing a portion of chrome:// should give the default urls.
-    {kChrome.substr(0, 1),      3, {kURL1, kURL2, kURL3}},
+    // Typing a portion of the embedder scheme should give the default urls.
+    {kEmbedder.substr(0, 1),    3, {kURL1, kURL2, kURL3}},
     {ASCIIToUTF16("C"),         3, {kURL1, kURL2, kURL3}},
-    {kChrome,                   3, {kURL1, kURL2, kURL3}},
-    {kChrome + kSeparator1,     3, {kURL1, kURL2, kURL3}},
-    {kChrome + kSeparator2,     3, {kURL1, kURL2, kURL3}},
-    {kChrome + kSeparator3,     3, {kURL1, kURL2, kURL3}},
+    {kEmbedder,                 3, {kURL1, kURL2, kURL3}},
+    {kEmbedder + kSeparator1,   3, {kURL1, kURL2, kURL3}},
+    {kEmbedder + kSeparator2,   3, {kURL1, kURL2, kURL3}},
+    {kEmbedder + kSeparator3,   3, {kURL1, kURL2, kURL3}},
     {ASCIIToUTF16("ChRoMe://"), 3, {kURL1, kURL2, kURL3}},
   };
 
   RunTest(typing_scheme_cases, arraysize(typing_scheme_cases));
 }
-#else // Android uses a subset of the URLs
-TEST_F(BuiltinProviderTest, TypingScheme) {
-  const base::string16 kAbout = ASCIIToUTF16(url::kAboutScheme);
-  const base::string16 kChrome = ASCIIToUTF16(content::kChromeUIScheme);
-  const base::string16 kSeparator1 = ASCIIToUTF16(":");
-  const base::string16 kSeparator2 = ASCIIToUTF16(":/");
-  const base::string16 kSeparator3 =
-      ASCIIToUTF16(url::kStandardSchemeSeparator);
-
-  // These default URLs should correspond with those in BuiltinProvider::Start.
-  const GURL kURL1 = GURL(chrome::kChromeUIChromeURLsURL);
-  const GURL kURL2 = GURL(chrome::kChromeUIVersionURL);
-
-  TestData typing_scheme_cases[] = {
-    // Typing an unrelated scheme should give nothing.
-    {ASCIIToUTF16("h"),        0, {}},
-    {ASCIIToUTF16("http"),     0, {}},
-    {ASCIIToUTF16("file"),     0, {}},
-    {ASCIIToUTF16("abouz"),    0, {}},
-    {ASCIIToUTF16("aboutt"),   0, {}},
-    {ASCIIToUTF16("aboutt:"),  0, {}},
-    {ASCIIToUTF16("chroma"),   0, {}},
-    {ASCIIToUTF16("chromee"),  0, {}},
-    {ASCIIToUTF16("chromee:"), 0, {}},
-
-    // Typing a portion of about:// should give the default urls.
-    {kAbout.substr(0, 1),      2, {kURL1, kURL2}},
-    {ASCIIToUTF16("A"),        2, {kURL1, kURL2}},
-    {kAbout,                   2, {kURL1, kURL2}},
-    {kAbout + kSeparator1,     2, {kURL1, kURL2}},
-    {kAbout + kSeparator2,     2, {kURL1, kURL2}},
-    {kAbout + kSeparator3,     2, {kURL1, kURL2}},
-    {ASCIIToUTF16("aBoUT://"), 2, {kURL1, kURL2}},
-
-    // Typing a portion of chrome:// should give the default urls.
-    {kChrome.substr(0, 1),      2, {kURL1, kURL2}},
-    {ASCIIToUTF16("C"),         2, {kURL1, kURL2}},
-    {kChrome,                   2, {kURL1, kURL2}},
-    {kChrome + kSeparator1,     2, {kURL1, kURL2}},
-    {kChrome + kSeparator2,     2, {kURL1, kURL2}},
-    {kChrome + kSeparator3,     2, {kURL1, kURL2}},
-    {ASCIIToUTF16("ChRoMe://"), 2, {kURL1, kURL2}},
-  };
-
-  RunTest(typing_scheme_cases, arraysize(typing_scheme_cases));
-}
-#endif
 
-TEST_F(BuiltinProviderTest, NonChromeURLs) {
-  TestData non_chrome_url_cases[] = {
+TEST_F(BuiltinProviderTest, NonEmbedderURLs) {
+  TestData test_cases[] = {
     // Typing an unrelated scheme should give nothing.
     {ASCIIToUTF16("g@rb@g3"),                      0, {}},
     {ASCIIToUTF16("www.google.com"),               0, {}},
@@ -185,65 +186,62 @@ TEST_F(BuiltinProviderTest, NonChromeURLs) {
     {ASCIIToUTF16("scheme://host/path?query#ref"), 0, {}},
   };
 
-  RunTest(non_chrome_url_cases, arraysize(non_chrome_url_cases));
+  RunTest(test_cases, arraysize(test_cases));
 }
 
-TEST_F(BuiltinProviderTest, ChromeURLs) {
+TEST_F(BuiltinProviderTest, EmbedderProvidedURLs) {
   const base::string16 kAbout = ASCIIToUTF16(url::kAboutScheme);
-  const base::string16 kChrome = ASCIIToUTF16(content::kChromeUIScheme);
-  const base::string16 kSeparator1 = ASCIIToUTF16(":");
-  const base::string16 kSeparator2 = ASCIIToUTF16(":/");
-  const base::string16 kSeparator3 =
+  const base::string16 kEmbedder = ASCIIToUTF16(kEmbedderAboutScheme);
+  const base::string16 kSep1 = ASCIIToUTF16(":");
+  const base::string16 kSep2 = ASCIIToUTF16(":/");
+  const base::string16 kSep3 =
       ASCIIToUTF16(url::kStandardSchemeSeparator);
 
-  // This makes assumptions about the chrome URLs listed by the BuiltinProvider.
-  // Currently they are derived from chrome::kChromeHostURLs[].
-  const base::string16 kHostM1 =
-      ASCIIToUTF16(content::kChromeUIMediaInternalsHost);
-  const base::string16 kHostM2 =
-      ASCIIToUTF16(chrome::kChromeUIMemoryHost);
-  const base::string16 kHostM3 =
-      ASCIIToUTF16(chrome::kChromeUIMemoryInternalsHost);
-  const GURL kURLM1 = GURL(kChrome + kSeparator3 + kHostM1);
-  const GURL kURLM2 = GURL(kChrome + kSeparator3 + kHostM2);
-  const GURL kURLM3 = GURL(kChrome + kSeparator3 + kHostM3);
-
-  TestData chrome_url_cases[] = {
+  // The following hosts are arbitrary, chosen so that they all start with the
+  // letters "me".
+  const base::string16 kHostM1 = ASCIIToUTF16(kHostMedia);
+  const base::string16 kHostM2 = ASCIIToUTF16(kHostMemory);
+  const base::string16 kHostM3 = ASCIIToUTF16(kHostMemoryInternals);
+  const GURL kURLM1(kEmbedder + kSep3 + kHostM1);
+  const GURL kURLM2(kEmbedder + kSep3 + kHostM2);
+  const GURL kURLM3(kEmbedder + kSep3 + kHostM3);
+
+  TestData test_cases[] = {
     // Typing an about URL with an unknown host should give nothing.
-    {kAbout + kSeparator1 + ASCIIToUTF16("host"), 0, {}},
-    {kAbout + kSeparator2 + ASCIIToUTF16("host"), 0, {}},
-    {kAbout + kSeparator3 + ASCIIToUTF16("host"), 0, {}},
+    {kAbout + kSep1 + ASCIIToUTF16("host"), 0, {}},
+    {kAbout + kSep2 + ASCIIToUTF16("host"), 0, {}},
+    {kAbout + kSep3 + ASCIIToUTF16("host"), 0, {}},
 
-    // Typing a chrome URL with an unknown host should give nothing.
-    {kChrome + kSeparator1 + ASCIIToUTF16("host"), 0, {}},
-    {kChrome + kSeparator2 + ASCIIToUTF16("host"), 0, {}},
-    {kChrome + kSeparator3 + ASCIIToUTF16("host"), 0, {}},
+    // Typing an embedder URL with an unknown host should give nothing.
+    {kEmbedder + kSep1 + ASCIIToUTF16("host"), 0, {}},
+    {kEmbedder + kSep2 + ASCIIToUTF16("host"), 0, {}},
+    {kEmbedder + kSep3 + ASCIIToUTF16("host"), 0, {}},
 
     // Typing an about URL should provide matching URLs.
-    {kAbout + kSeparator1 + kHostM1.substr(0, 1), 3, {kURLM1, kURLM2, kURLM3}},
-    {kAbout + kSeparator2 + kHostM1.substr(0, 2), 3, {kURLM1, kURLM2, kURLM3}},
-    {kAbout + kSeparator3 + kHostM1.substr(0, 3), 1, {kURLM1}},
-    {kAbout + kSeparator3 + kHostM2.substr(0, 3), 2, {kURLM2, kURLM3}},
-    {kAbout + kSeparator3 + kHostM1,              1, {kURLM1}},
-    {kAbout + kSeparator2 + kHostM2,              2, {kURLM2, kURLM3}},
-    {kAbout + kSeparator2 + kHostM3,              1, {kURLM3}},
-
-    // Typing a chrome URL should provide matching URLs.
-    {kChrome + kSeparator1 + kHostM1.substr(0, 1), 3, {kURLM1, kURLM2, kURLM3}},
-    {kChrome + kSeparator2 + kHostM1.substr(0, 2), 3, {kURLM1, kURLM2, kURLM3}},
-    {kChrome + kSeparator3 + kHostM1.substr(0, 3), 1, {kURLM1}},
-    {kChrome + kSeparator3 + kHostM2.substr(0, 3), 2, {kURLM2, kURLM3}},
-    {kChrome + kSeparator3 + kHostM1,              1, {kURLM1}},
-    {kChrome + kSeparator2 + kHostM2,              2, {kURLM2, kURLM3}},
-    {kChrome + kSeparator2 + kHostM3,              1, {kURLM3}},
+    {kAbout + kSep1 + kHostM1.substr(0, 1),    3, {kURLM1, kURLM2, kURLM3}},
+    {kAbout + kSep2 + kHostM1.substr(0, 2),    3, {kURLM1, kURLM2, kURLM3}},
+    {kAbout + kSep3 + kHostM1.substr(0, 3),    1, {kURLM1}},
+    {kAbout + kSep3 + kHostM2.substr(0, 3),    2, {kURLM2, kURLM3}},
+    {kAbout + kSep3 + kHostM1,                 1, {kURLM1}},
+    {kAbout + kSep2 + kHostM2,                 2, {kURLM2, kURLM3}},
+    {kAbout + kSep2 + kHostM3,                 1, {kURLM3}},
+
+    // Typing an embedder URL should provide matching URLs.
+    {kEmbedder + kSep1 + kHostM1.substr(0, 1), 3, {kURLM1, kURLM2, kURLM3}},
+    {kEmbedder + kSep2 + kHostM1.substr(0, 2), 3, {kURLM1, kURLM2, kURLM3}},
+    {kEmbedder + kSep3 + kHostM1.substr(0, 3), 1, {kURLM1}},
+    {kEmbedder + kSep3 + kHostM2.substr(0, 3), 2, {kURLM2, kURLM3}},
+    {kEmbedder + kSep3 + kHostM1,              1, {kURLM1}},
+    {kEmbedder + kSep2 + kHostM2,              2, {kURLM2, kURLM3}},
+    {kEmbedder + kSep2 + kHostM3,              1, {kURLM3}},
   };
 
-  RunTest(chrome_url_cases, arraysize(chrome_url_cases));
+  RunTest(test_cases, arraysize(test_cases));
 }
 
 TEST_F(BuiltinProviderTest, AboutBlank) {
   const base::string16 kAbout = ASCIIToUTF16(url::kAboutScheme);
-  const base::string16 kChrome = ASCIIToUTF16(content::kChromeUIScheme);
+  const base::string16 kEmbedder = ASCIIToUTF16(kEmbedderAboutScheme);
   const base::string16 kAboutBlank = ASCIIToUTF16(url::kAboutBlankURL);
   const base::string16 kBlank = ASCIIToUTF16("blank");
   const base::string16 kSeparator1 =
@@ -251,14 +249,14 @@ TEST_F(BuiltinProviderTest, AboutBlank) {
   const base::string16 kSeparator2 = ASCIIToUTF16(":///");
   const base::string16 kSeparator3 = ASCIIToUTF16(";///");
 
-  const GURL kURLBlob = GURL(kChrome + kSeparator1 +
-                             ASCIIToUTF16(content::kChromeUIBlobInternalsHost));
-  const GURL kURLBlank = GURL(kAboutBlank);
+  const GURL kURLBar =
+      GURL(kEmbedder + kSeparator1 + ASCIIToUTF16(kHostBar));
+  const GURL kURLBlank(kAboutBlank);
 
   TestData about_blank_cases[] = {
     // Typing an about:blank prefix should yield about:blank, among other URLs.
-    {kAboutBlank.substr(0, 8), 2, {kURLBlank, kURLBlob}},
-    {kAboutBlank.substr(0, 9), 1, {kURLBlank}},
+    {kAboutBlank.substr(0, 7), 2, {kURLBlank, kURLBar}},
+    {kAboutBlank.substr(0, 8), 1, {kURLBlank}},
 
     // Using any separator that is supported by fixup should yield about:blank.
     // For now, BuiltinProvider does not suggest url-what-you-typed matches for
@@ -272,11 +270,11 @@ TEST_F(BuiltinProviderTest, AboutBlank) {
     {kAbout + kSeparator3.substr(0, 3) + kBlank,              1, {kURLBlank}},
     {kAbout + kSeparator3 + kBlank,                           1, {kURLBlank}},
 
-    // Using the chrome scheme should not yield about:blank.
-    {kChrome + kSeparator1.substr(0, 1) + kBlank, 0, {}},
-    {kChrome + kSeparator1.substr(0, 2) + kBlank, 0, {}},
-    {kChrome + kSeparator1.substr(0, 3) + kBlank, 0, {}},
-    {kChrome + kSeparator1 + kBlank,              0, {}},
+    // Using the embedder scheme should not yield about:blank.
+    {kEmbedder + kSeparator1.substr(0, 1) + kBlank, 0, {}},
+    {kEmbedder + kSeparator1.substr(0, 2) + kBlank, 0, {}},
+    {kEmbedder + kSeparator1.substr(0, 3) + kBlank, 0, {}},
+    {kEmbedder + kSeparator1 + kBlank,              0, {}},
 
     // Adding trailing text should not yield about:blank.
     {kAboutBlank + ASCIIToUTF16("/"),  0, {}},
@@ -298,41 +296,34 @@ TEST_F(BuiltinProviderTest, AboutBlank) {
 
 TEST_F(BuiltinProviderTest, DoesNotSupportMatchesOnFocus) {
   const AutocompleteInput input(
-      ASCIIToUTF16("chrome://s"), base::string16::npos, std::string(), GURL(),
+      ASCIIToUTF16("chrome://m"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, true, false, true, true, true,
-      ChromeAutocompleteSchemeClassifier(NULL));
+      TestSchemeClassifier());
   provider_->Start(input, false);
-   EXPECT_TRUE(provider_->matches().empty());
+  EXPECT_TRUE(provider_->matches().empty());
 }
 
-#if !defined(OS_ANDROID)
-// Disabled on Android where we use native UI instead of chrome://settings.
-TEST_F(BuiltinProviderTest, ChromeSettingsSubpages) {
-  // This makes assumptions about the chrome URLs listed by the BuiltinProvider.
-  // Currently they are derived from chrome::kChromeHostURLs[].
-  const base::string16 kSettings = ASCIIToUTF16(chrome::kChromeUISettingsURL);
-  const base::string16 kDefaultPage1 = ASCIIToUTF16(chrome::kAutofillSubPage);
-  const base::string16 kDefaultPage2 =
-      ASCIIToUTF16(chrome::kClearBrowserDataSubPage);
-  const GURL kDefaultURL1 = GURL(kSettings + kDefaultPage1);
-  const GURL kDefaultURL2 = GURL(kSettings + kDefaultPage2);
-  const base::string16 kPage1 = ASCIIToUTF16(chrome::kSearchEnginesSubPage);
-  const base::string16 kPage2 = ASCIIToUTF16(chrome::kSyncSetupSubPage);
-  const GURL kURL1 = GURL(kSettings + kPage1);
-  const GURL kURL2 = GURL(kSettings + kPage2);
+TEST_F(BuiltinProviderTest, Subpages) {
+  const base::string16 kSubpage = ASCIIToUTF16(kSubpageURL);
+  const base::string16 kPageOne = ASCIIToUTF16(kSubpageOne);
+  const base::string16 kPageTwo = ASCIIToUTF16(kSubpageTwo);
+  const base::string16 kPageThree = ASCIIToUTF16(kSubpageThree);
+  const GURL kURLOne(kSubpage + kPageOne);
+  const GURL kURLTwo(kSubpage + kPageTwo);
+  const GURL kURLThree(kSubpage + kPageThree);
 
   TestData settings_subpage_cases[] = {
     // Typing the settings path should show settings and the first two subpages.
-    {kSettings, 3, {GURL(kSettings), kDefaultURL1, kDefaultURL2}},
+    {kSubpage, 3, {GURL(kSubpage), kURLOne, kURLTwo}},
 
     // Typing a subpage path should return the appropriate results.
-    {kSettings + kPage1.substr(0, 1),                   2, {kURL1, kURL2}},
-    {kSettings + kPage1.substr(0, 2),                   1, {kURL1}},
-    {kSettings + kPage1.substr(0, kPage1.length() - 1), 1, {kURL1}},
-    {kSettings + kPage1,                                1, {kURL1}},
-    {kSettings + kPage2,                                1, {kURL2}},
+    {kSubpage + kPageTwo.substr(0, 1),                 2, {kURLTwo, kURLThree}},
+    {kSubpage + kPageTwo.substr(0, 2),                 1, {kURLTwo}},
+    {kSubpage + kPageThree.substr(0, kPageThree.length() - 1),
+                                                       1, {kURLThree}},
+    {kSubpage + kPageOne,                              1, {kURLOne}},
+    {kSubpage + kPageTwo,                              1, {kURLTwo}},
   };
 
   RunTest(settings_subpage_cases, arraysize(settings_subpage_cases));
 }
-#endif