Partially componentize //chrome/browser/search/search.{h,cc}

chrome/browser/search/search_unittest.cc

 // Copyright (c) 2013 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/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 20 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/renderer_preferences.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #endif
 
-namespace chrome {
+namespace search {
 
 class SearchTest : public BrowserWithTestWindowTest {
  protected:
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
     field_trial_list_.reset(new base::FieldTrialList(
         new metrics::SHA1EntropyProvider("42")));
     TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
         profile(), &TemplateURLServiceFactory::BuildInstanceFor);
     TemplateURLService* template_url_service =
@@ skipping 330 matching lines @@
   content::NavigationController& controller = contents->GetController();
   // Local NTP.
   NavigateAndCommitActiveTab(GURL(chrome::kChromeSearchLocalNtpUrl));
   EXPECT_TRUE(NavEntryIsInstantNTP(contents,
                                    controller.GetLastCommittedEntry()));
   // Instant page is not cacheable NTP.
   NavigateAndCommitActiveTab(GetInstantURL(profile(), false));
   EXPECT_FALSE(NavEntryIsInstantNTP(contents,
                                     controller.GetLastCommittedEntry()));
   // Test Cacheable NTP
-  NavigateAndCommitActiveTab(chrome::GetNewTabPageURL(profile()));
+  NavigateAndCommitActiveTab(GetNewTabPageURL(profile()));
   EXPECT_TRUE(NavEntryIsInstantNTP(contents,
                                    controller.GetLastCommittedEntry()));
 }
 
 TEST_F(SearchTest, InstantCacheableNTPNavigationEntryNewProfile) {
   SetSearchProvider(false, false);
   AddTab(browser(), GURL(chrome::kChromeUINewTabURL));
   content::WebContents* contents =
         browser()->tab_strip_model()->GetWebContentsAt(0);
   content::NavigationController& controller = contents->GetController();
   // Test virtual url chrome://newtab  for first NTP of a new profile
   EXPECT_TRUE(NavEntryIsInstantNTP(contents,
                                    controller.GetLastCommittedEntry()));
   // The new_tab_url gets set after the first NTP is visible.
   SetSearchProvider(true, false);
   EXPECT_TRUE(NavEntryIsInstantNTP(contents,
                                    controller.GetLastCommittedEntry()));
 }
 
 TEST_F(SearchTest, NoRewriteInIncognito) {
   profile()->ForceIncognito(true);
-  EXPECT_EQ(GURL(), chrome::GetNewTabPageURL(profile()));
+  EXPECT_EQ(GURL(), GetNewTabPageURL(profile()));
   GURL new_tab_url(chrome::kChromeUINewTabURL);
   EXPECT_FALSE(HandleNewTabURLRewrite(&new_tab_url, profile()));
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), new_tab_url);
 }
 
 TEST_F(SearchTest, UseLocalNTPIfNTPURLIsInsecure) {
   // Set an insecure new tab page URL and verify that it's ignored.
   SetSearchProvider(true, true);
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl),
-            chrome::GetNewTabPageURL(profile()));
+            GetNewTabPageURL(profile()));
   GURL new_tab_url(chrome::kChromeUINewTabURL);
   EXPECT_TRUE(HandleNewTabURLRewrite(&new_tab_url, profile()));
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl), new_tab_url);
 }
 
 TEST_F(SearchTest, UseLocalNTPIfNTPURLIsNotSet) {
   // Set an insecure new tab page URL and verify that it's ignored.
   SetSearchProvider(false, true);
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl),
-            chrome::GetNewTabPageURL(profile()));
+            GetNewTabPageURL(profile()));
   GURL new_tab_url(chrome::kChromeUINewTabURL);
   EXPECT_TRUE(HandleNewTabURLRewrite(&new_tab_url, profile()));
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl), new_tab_url);
 }
 
 #if defined(ENABLE_SUPERVISED_USERS)
 TEST_F(SearchTest, UseLocalNTPIfNTPURLIsBlockedForSupervisedUser) {
   // Block access to foo.com in the URL filter.
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile());
   SupervisedUserURLFilter* url_filter =
       supervised_user_service->GetURLFilterForUIThread();
   std::map<std::string, bool> hosts;
   hosts["foo.com"] = false;
   url_filter->SetManualHosts(&hosts);
 
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl),
-            chrome::GetNewTabPageURL(profile()));
+            GetNewTabPageURL(profile()));
   GURL new_tab_url(chrome::kChromeUINewTabURL);
   EXPECT_TRUE(HandleNewTabURLRewrite(&new_tab_url, profile()));
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl), new_tab_url);
   EXPECT_EQ(GURL(), GetInstantURL(profile(), false));
 }
 #endif
 
 TEST_F(SearchTest, GetInstantURL) {
   // No Instant URL because "strk" is missing.
   SetDefaultInstantTemplateUrl(false);
@@ skipping 84 matching lines @@
 
   // If we specify extra search query params, they should be inserted into the
   // query portion of the instant URL.
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kExtraSearchQueryParams, "a=b");
   instant_url = GetInstantURL(profile(), false);
   ASSERT_TRUE(instant_url.is_valid());
   EXPECT_EQ("http://www.bar.com/webhp?a=b&strk", instant_url.spec());
 }
 
-TEST_F(SearchTest, ShouldPrefetchSearchResults_InstantExtendedAPIEnabled) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:2"));
-#if defined(OS_IOS)
-  EXPECT_EQ(1ul, EmbeddedSearchPageVersion());
-  EXPECT_TRUE(ShouldPrefetchSearchResults());
-#else
-  EXPECT_EQ(2ul, EmbeddedSearchPageVersion());
-  EXPECT_TRUE(ShouldPrefetchSearchResults());
-#endif
-}
-
-TEST_F(SearchTest, ShouldPrefetchSearchResults_Default) {
-#if defined(OS_IOS)
-  EXPECT_FALSE(ShouldPrefetchSearchResults());
-#else
-  EXPECT_TRUE(ShouldPrefetchSearchResults());
-#endif
-}
-
-TEST_F(SearchTest, ShouldReuseInstantSearchBasePage_Default) {
-#if defined(OS_IOS)
-  EXPECT_FALSE(ShouldReuseInstantSearchBasePage());
-#else
-  EXPECT_TRUE(ShouldReuseInstantSearchBasePage());
-#endif
-}
-
-TEST_F(SearchTest, ShouldAllowPrefetchNonDefaultMatch_DisabledViaFieldTrial) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:89 allow_prefetch_non_default_match:0"));
-  EXPECT_FALSE(ShouldAllowPrefetchNonDefaultMatch());
-  EXPECT_EQ(89ul, EmbeddedSearchPageVersion());
-}
-
-TEST_F(SearchTest, ShouldAllowPrefetchNonDefaultMatch_EnabledViaFieldTrial) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:80 allow_prefetch_non_default_match:1"));
-  EXPECT_TRUE(ShouldAllowPrefetchNonDefaultMatch());
-  EXPECT_EQ(80ul, EmbeddedSearchPageVersion());
-}
-
 TEST_F(SearchTest, ShouldUseAltInstantURL_DisabledViaFieldTrial) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch", "Group1 espv:8 use_alternate_instant_url:0"));
   EXPECT_FALSE(ShouldUseAltInstantURL());
 }
 
 TEST_F(SearchTest, ShouldUseAltInstantURL_EnabledViaFieldTrial) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch", "Group1 espv:8 use_alternate_instant_url:1"));
   EXPECT_TRUE(ShouldUseAltInstantURL());
@@ skipping 48 matching lines @@
       "EmbeddedSearch", "Group1 espv:2 google_local_ntp:0"));
   EXPECT_FALSE(ShouldShowGoogleLocalNTP());
 }
 
 
 TEST_F(SearchTest, IsNTPURL) {
   GURL invalid_url;
   GURL ntp_url(chrome::kChromeUINewTabURL);
   GURL local_ntp_url(GetLocalInstantURL(profile()));
 
-  EXPECT_FALSE(chrome::IsNTPURL(invalid_url, profile()));
+  EXPECT_FALSE(IsNTPURL(invalid_url, profile()));
   // No margin.
   EnableQueryExtractionForTesting();
   profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, true);
   GURL remote_ntp_url(GetInstantURL(profile(), false));
   GURL search_url_with_search_terms("https://foo.com/url?strk&bar=abc");
   GURL search_url_without_search_terms("https://foo.com/url?strk&bar");
 
-  EXPECT_FALSE(chrome::IsNTPURL(ntp_url, profile()));
-  EXPECT_TRUE(chrome::IsNTPURL(local_ntp_url, profile()));
-  EXPECT_TRUE(chrome::IsNTPURL(remote_ntp_url, profile()));
-  EXPECT_FALSE(chrome::IsNTPURL(search_url_with_search_terms, profile()));
-  EXPECT_TRUE(chrome::IsNTPURL(search_url_without_search_terms, profile()));
+  EXPECT_FALSE(IsNTPURL(ntp_url, profile()));
+  EXPECT_TRUE(IsNTPURL(local_ntp_url, profile()));
+  EXPECT_TRUE(IsNTPURL(remote_ntp_url, profile()));
+  EXPECT_FALSE(IsNTPURL(search_url_with_search_terms, profile()));
+  EXPECT_TRUE(IsNTPURL(search_url_without_search_terms, profile()));
 
-  EXPECT_FALSE(chrome::IsNTPURL(ntp_url, NULL));
-  EXPECT_FALSE(chrome::IsNTPURL(local_ntp_url, NULL));
-  EXPECT_FALSE(chrome::IsNTPURL(remote_ntp_url, NULL));
-  EXPECT_FALSE(chrome::IsNTPURL(search_url_with_search_terms, NULL));
-  EXPECT_FALSE(chrome::IsNTPURL(search_url_without_search_terms, NULL));
+  EXPECT_FALSE(IsNTPURL(ntp_url, NULL));
+  EXPECT_FALSE(IsNTPURL(local_ntp_url, NULL));
+  EXPECT_FALSE(IsNTPURL(remote_ntp_url, NULL));
+  EXPECT_FALSE(IsNTPURL(search_url_with_search_terms, NULL));
+  EXPECT_FALSE(IsNTPURL(search_url_without_search_terms, NULL));
 }
 
 TEST_F(SearchTest, GetSearchURLs) {
   std::vector<GURL> search_urls = GetSearchURLs(profile());
   EXPECT_EQ(2U, search_urls.size());
   EXPECT_EQ("http://foo.com/alt#quux=", search_urls[0].spec());
   EXPECT_EQ("http://foo.com/url?bar=", search_urls[1].spec());
 }
 
 TEST_F(SearchTest, GetSearchResultPrefetchBaseURL) {
 #if defined(OS_IOS)
   EXPECT_FALSE(ShouldPrefetchSearchResults());
   EXPECT_EQ(GURL(), GetSearchResultPrefetchBaseURL(profile()));
 #else
   EXPECT_TRUE(ShouldPrefetchSearchResults());
   EXPECT_EQ(GURL("https://foo.com/instant?ion=1&foo=foo#foo=foo&strk"),
             GetSearchResultPrefetchBaseURL(profile()));
 #endif
 }
 
-TEST_F(SearchTest, ForceInstantResultsParam) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch",
-                                                     "Group1 espv:2"));
-  EXPECT_TRUE(IsInstantExtendedAPIEnabled());
-  EXPECT_EQ("ion=1&", ForceInstantResultsParam(true));
-  EXPECT_EQ(std::string(), ForceInstantResultsParam(false));
-}
-
 struct ExtractSearchTermsTestCase {
   const char* url;
   const char* expected_result;
   const char* comment;
 };
 
 TEST_F(SearchTest, ExtractSearchTermsFromURL) {
   const ExtractSearchTermsTestCase kTestCases[] = {
     {chrome::kChromeSearchLocalNtpUrl,           "",    "NTP url"},
     {"https://foo.com/instant?strk",             "",    "Invalid search url"},
     {"https://foo.com/instant#strk",             "",    "Invalid search url"},
     {"https://foo.com/alt#quux=foo",             "foo", "Valid search url"},
     {"https://foo.com/alt#quux=foo&strk",        "foo", "Valid search url"}
   };
 
   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     const ExtractSearchTermsTestCase& test = kTestCases[i];
-    EXPECT_EQ(
-        test.expected_result,
-        base::UTF16ToASCII(chrome::ExtractSearchTermsFromURL(profile(),
-                                                             GURL(test.url))))
-            << test.url << " " << test.comment;
+    EXPECT_EQ(test.expected_result,
+              base::UTF16ToASCII(
+                  ExtractSearchTermsFromURL(profile(), GURL(test.url))))
+        << test.url << " " << test.comment;
   }
 }
 
 struct QueryExtractionAllowedTestCase {
   const char* url;
   bool expected_result;
   const char* comment;
 };
 
 TEST_F(SearchTest, IsQueryExtractionAllowedForURL) {
   const QueryExtractionAllowedTestCase kTestCases[] = {
     {"http://foo.com/instant?strk",       false, "HTTP URL"},
     {"https://foo.com/instant?strk",      true,  "Valid URL"},
     {"https://foo.com/instant?",          false,
      "No search terms replacement key"},
     {"https://foo.com/alt#quux=foo",      false,
      "No search terms replacement key"},
     {"https://foo.com/alt#quux=foo&strk", true,  "Valid search url"}
   };
 
   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     const QueryExtractionAllowedTestCase& test = kTestCases[i];
     EXPECT_EQ(test.expected_result,
-              chrome::IsQueryExtractionAllowedForURL(profile(), GURL(test.url)))
+              IsQueryExtractionAllowedForURL(profile(), GURL(test.url)))
         << test.url << " " << test.comment;
   }
 }
 
 class SearchURLTest : public SearchTest {
  protected:
   void SetSearchProvider(bool set_ntp_url, bool insecure_ntp_url) override {
     TemplateURLService* template_url_service =
         TemplateURLServiceFactory::GetForProfile(profile());
     TemplateURLData data;
@@ skipping 28 matching lines @@
   EXPECT_FALSE(IsQueryExtractionEnabled());
   TemplateURLRef::SearchTermsArgs search_terms_args(base::ASCIIToUTF16("foo"));
   GURL result(template_url_->url_ref().ReplaceSearchTerms(
       search_terms_args, UIThreadSearchTermsData(profile())));
   ASSERT_TRUE(result.is_valid());
   // Query extraction is disabled. Make sure
   // {google:instantExtendedEnabledParameter} is not set in the search URL.
   EXPECT_EQ("http://www.google.com/search?q=foo", result.spec());
 }
 
-typedef SearchTest InstantExtendedEnabledParamTest;
-
-TEST_F(InstantExtendedEnabledParamTest, QueryExtractionDisabled) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch",
-                                                     "Group1 espv:12"));
-  // Make sure InstantExtendedEnabledParam() returns an empty string for search
-  // requests.
-#if defined(OS_IOS)
-  // Query extraction is always enabled on mobile.
-  EXPECT_TRUE(IsQueryExtractionEnabled());
-  EXPECT_EQ("espv=12&", InstantExtendedEnabledParam(true));
-#else
-  EXPECT_FALSE(IsQueryExtractionEnabled());
-  EXPECT_EQ("", InstantExtendedEnabledParam(true));
-#endif
-  EXPECT_EQ("espv=12&", InstantExtendedEnabledParam(false));
-}
-
-TEST_F(InstantExtendedEnabledParamTest, QueryExtractionEnabled) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:10 query_extraction:1"));
-  EXPECT_TRUE(IsQueryExtractionEnabled());
-  // Make sure InstantExtendedEnabledParam() returns a non-empty param string
-  // for search requests.
-  EXPECT_EQ("espv=10&", InstantExtendedEnabledParam(true));
-  EXPECT_EQ("espv=10&", InstantExtendedEnabledParam(false));
-}
-
-TEST_F(InstantExtendedEnabledParamTest, UseDefaultEmbeddedSearchPageVersion) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:-1 query_extraction:1"));
-  EXPECT_TRUE(IsQueryExtractionEnabled());
-#if defined(OS_IOS)
-  EXPECT_EQ("espv=1&", InstantExtendedEnabledParam(true));
-  EXPECT_EQ("espv=1&", InstantExtendedEnabledParam(false));
-#else
-  EXPECT_EQ("espv=2&", InstantExtendedEnabledParam(true));
-  EXPECT_EQ("espv=2&", InstantExtendedEnabledParam(false));
-#endif
-}
-
-typedef SearchTest IsQueryExtractionEnabledTest;
-
-TEST_F(IsQueryExtractionEnabledTest, NotSet) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:2"));
-  EXPECT_TRUE(IsInstantExtendedAPIEnabled());
-  EXPECT_FALSE(IsQueryExtractionEnabled());
-  EXPECT_EQ(2ul, EmbeddedSearchPageVersion());
-}
-
-TEST_F(IsQueryExtractionEnabledTest, EnabledViaFieldTrial) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:2 query_extraction:1"));
-  EXPECT_TRUE(IsInstantExtendedAPIEnabled());
-  EXPECT_TRUE(IsQueryExtractionEnabled());
-  EXPECT_EQ(2ul, EmbeddedSearchPageVersion());
-}
-
-TEST_F(IsQueryExtractionEnabledTest, DisabledViaFieldTrial) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:2 query_extraction:0"));
-  EXPECT_TRUE(IsInstantExtendedAPIEnabled());
-  EXPECT_FALSE(IsQueryExtractionEnabled());
-  EXPECT_EQ(2ul, EmbeddedSearchPageVersion());
-}
-
-TEST_F(IsQueryExtractionEnabledTest, EnabledViaCommandLine) {
-  EnableQueryExtractionForTesting();
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 espv:2 query_extraction:0"));
-  EXPECT_TRUE(IsInstantExtendedAPIEnabled());
-  EXPECT_TRUE(IsQueryExtractionEnabled());
-  EXPECT_EQ(2ul, EmbeddedSearchPageVersion());
-}
-
-}  // namespace chrome
+}  // namespace search