InstantExtended: remove dead code related to the non-cacheable NTP.

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/metrics/statistics_recorder.h"
 #include "base/prefs/pref_service.h"
@@ skipping 410 matching lines @@
     EXPECT_EQ(test.same_site_instance,
               start_rvh == contents->GetRenderViewHost())
         << test.description;
     EXPECT_EQ(test.same_site_instance,
               start_rph == contents->GetRenderProcessHost())
         << test.description;
   }
 }
 
 const SearchTestCase kInstantNTPTestCases[] = {
-  {"https://foo.com/instant?strk",         true,  "Valid Instant URL"},
-  {"https://foo.com/instant#strk",         true,  "Valid Instant URL"},
-  {"https://foo.com/url?strk",             true,  "Valid search URL"},
-  {"https://foo.com/url#strk",             true,  "Valid search URL"},
-  {"https://foo.com/alt?strk",             true,  "Valid alternative URL"},
-  {"https://foo.com/alt#strk",             true,  "Valid alternative URL"},
-  {"https://foo.com/url?strk&bar=",        true,  "No query terms"},
-  {"https://foo.com/url?strk&q=abc",       true,  "No query terms key"},
-  {"https://foo.com/url?strk#bar=abc",     true,  "Query terms key in ref"},
+  {"https://foo.com/instant?strk",         false, "Valid Instant URL"},
+  {"https://foo.com/instant#strk",         false, "Valid Instant URL"},
+  {"https://foo.com/url?strk",             false, "Valid search URL"},
+  {"https://foo.com/url#strk",             false, "Valid search URL"},
+  {"https://foo.com/alt?strk",             false, "Valid alternative URL"},
+  {"https://foo.com/alt#strk",             false, "Valid alternative URL"},
+  {"https://foo.com/url?strk&bar=",        false, "No query terms"},
+  {"https://foo.com/url?strk&q=abc",       false, "No query terms key"},
+  {"https://foo.com/url?strk#bar=abc",     false, "Query terms key in ref"},
   {"https://foo.com/url?strk&bar=abc",     false, "Has query terms"},
   {"http://foo.com/instant?strk=1",        false, "Insecure URL"},
   {"https://foo.com/instant",              false, "No search term replacement"},
   {"chrome://blank/",                      false, "Chrome scheme"},
   {"chrome-search://foo",                  false, "Chrome-search scheme"},
+  {"https://bar.com/instant?strk=1",       false, "Random non-search page"},
   {chrome::kChromeSearchLocalNtpUrl,       true,  "Local new tab page"},
-  {"https://bar.com/instant?strk=1",       false, "Random non-search page"},
+  {"https://foo.com/newtab?strk",          true,  "New tab URL"},
+  {"http://foo.com/newtab?strk",           false, "Insecure New tab URL"},
 };
 
 TEST_F(SearchTest, InstantNTPExtendedEnabled) {
   EnableQueryExtractionForTesting();
-  // TODO(samarth): update test cases to use cacheable NTP URLs and remove this.
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "InstantExtended", "Group1 use_cacheable_ntp:0"));
   AddTab(browser(), GURL("chrome://blank"));
   for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) {
     const SearchTestCase& test = kInstantNTPTestCases[i];
     NavigateAndCommitActiveTab(GURL(test.url));
     const content::WebContents* contents =
         browser()->tab_strip_model()->GetWebContentsAt(0);
     EXPECT_EQ(test.expected_result, IsInstantNTP(contents))
         << test.url << " " << test.comment;
   }
 }
 
 TEST_F(SearchTest, InstantNTPCustomNavigationEntry) {
   EnableQueryExtractionForTesting();
-  // TODO(samarth): update test cases to use cacheable NTP URLs and remove this.
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "InstantExtended", "Group1 use_cacheable_ntp:0"));
   AddTab(browser(), GURL("chrome://blank"));
   for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) {
     const SearchTestCase& test = kInstantNTPTestCases[i];
     NavigateAndCommitActiveTab(GURL(test.url));
     content::WebContents* contents =
         browser()->tab_strip_model()->GetWebContentsAt(0);
     content::NavigationController& controller = contents->GetController();
     controller.SetTransientEntry(
         controller.CreateNavigationEntry(GURL("chrome://blank"),
                                          content::Referrer(),
                                          content::PAGE_TRANSITION_LINK,
                                          false,
                                          std::string(),
                                          contents->GetBrowserContext()));
     // The active entry is chrome://blank and not an NTP.
     EXPECT_FALSE(IsInstantNTP(contents));
     EXPECT_EQ(test.expected_result,
               NavEntryIsInstantNTP(contents,
                                    controller.GetLastCommittedEntry()))
         << test.url << " " << test.comment;
   }
 }
 
 TEST_F(SearchTest, InstantCacheableNTPNavigationEntry) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
-
   AddTab(browser(), GURL("chrome://blank"));
   content::WebContents* contents =
         browser()->tab_strip_model()->GetWebContentsAt(0);
   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(), kDisableStartMargin,
                                            false));
   EXPECT_FALSE(NavEntryIsInstantNTP(contents,
                                     controller.GetLastCommittedEntry()));
   // Test Cacheable NTP
   NavigateAndCommitActiveTab(chrome::GetNewTabPageURL(profile()));
   EXPECT_TRUE(NavEntryIsInstantNTP(contents,
                                    controller.GetLastCommittedEntry()));
 }
 
 TEST_F(SearchTest, InstantCacheableNTPNavigationEntryNewProfile) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
   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, UseLocalNTPInIncognito) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
   EXPECT_EQ(GURL(), chrome::GetNewTabPageURL(
       profile()->GetOffTheRecordProfile()));
 }
 
 TEST_F(SearchTest, UseLocalNTPIfNTPURLIsInsecure) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
   // Set an insecure new tab page URL and verify that it's ignored.
   SetSearchProvider(true, true);
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl),
             chrome::GetNewTabPageURL(profile()));
 }
 
 TEST_F(SearchTest, UseLocalNTPIfNTPURLIsNotSet) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
   // Set an insecure new tab page URL and verify that it's ignored.
   SetSearchProvider(false, true);
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl),
             chrome::GetNewTabPageURL(profile()));
 }
 
 TEST_F(SearchTest, UseLocalNTPIfNTPURLIsBlockedForSupervisedUser) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
-
   // Block access to foo.com in the URL filter.
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile());
   ManagedModeURLFilter* url_filter =
       managed_user_service->GetURLFilterForUIThread();
   std::map<std::string, bool> hosts;
   hosts["foo.com"] = false;
   url_filter->SetManualHosts(&hosts);
 
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl),
@@ skipping 86 matching lines @@
 
   // If we specify extra search query params, they should be inserted into the
   // query portion of the instant URL.
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kExtraSearchQueryParams, "a=b");
   instant_url = GetInstantURL(profile(), kDisableStartMargin, false);
   ASSERT_TRUE(instant_url.is_valid());
   EXPECT_EQ("http://www.bar.com/webhp?a=b&strk", instant_url.spec());
 }
 
-TEST_F(SearchTest, ShouldShowInstantNTP_Default) {
-  EXPECT_FALSE(ShouldShowInstantNTP());
-}
-
-TEST_F(SearchTest, ShouldShowInstantNTP_DisabledViaFinch) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 show_ntp:0"));
-  EXPECT_FALSE(ShouldShowInstantNTP());
-}
-
-TEST_F(SearchTest, ShouldShowInstantNTP_DisabledByUseCacheableNTPFinchFlag) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
-  EXPECT_FALSE(ShouldShowInstantNTP());
-}
-
-TEST_F(SearchTest, ShouldUseCacheableNTP_Default) {
-  EXPECT_TRUE(ShouldUseCacheableNTP());
-}
-
-TEST_F(SearchTest, ShouldUseCacheableNTP_EnabledViaFinch) {
-  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
-      "EmbeddedSearch", "Group1 use_cacheable_ntp:1"));
-  EXPECT_TRUE(ShouldUseCacheableNTP());
-}
-
-TEST_F(SearchTest, ShouldPrefetchSearchResults_Default) {
-  EXPECT_FALSE(ShouldPrefetchSearchResults());
-}
-
 TEST_F(SearchTest, ShouldPrefetchSearchResults_InstantExtendedAPIEnabled) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch",
-      "Group1 espv:2 use_cacheable_ntp:1 prefetch_results:1"));
+      "Group1 espv:2 prefetch_results:1"));
   EXPECT_TRUE(ShouldPrefetchSearchResults());
 #if defined(OS_IOS) || defined(OS_ANDROID)
   EXPECT_EQ(1ul, EmbeddedSearchPageVersion());
 #else
   EXPECT_EQ(2ul, EmbeddedSearchPageVersion());
 #endif
 }
 
 TEST_F(SearchTest, ShouldPrefetchSearchResults_DisabledViaFinch) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch",
-      "Group1 use_cacheable_ntp:1 espv:89 prefetch_results:0"));
+      "Group1 espv:89 prefetch_results:0"));
   EXPECT_FALSE(ShouldPrefetchSearchResults());
   EXPECT_EQ(89ul, EmbeddedSearchPageVersion());
 }
 
 TEST_F(SearchTest, ShouldPrefetchSearchResults_EnabledViaFinch) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch",
-      "Group1 espv:80 use_cacheable_ntp:1 prefetch_results:1"));
+      "Group1 espv:80 prefetch_results:1"));
   EXPECT_TRUE(ShouldPrefetchSearchResults());
   EXPECT_EQ(80ul, EmbeddedSearchPageVersion());
 }
 
 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()));
@@ skipping 24 matching lines @@
   EXPECT_EQ("http://foo.com/url?bar=", search_urls[1].spec());
 }
 
 TEST_F(SearchTest, GetSearchResultPrefetchBaseURL) {
   // "prefetch_results" flag is disabled.
   EXPECT_EQ(GURL(), GetSearchResultPrefetchBaseURL(profile()));
 
   // "prefetch_results" flag is enabled via field trials.
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch",
-      "Group1 espv:80 use_cacheable_ntp:1 prefetch_results:1"));
+      "Group1 espv:80 prefetch_results:1"));
   EXPECT_TRUE(ShouldPrefetchSearchResults());
 
   EXPECT_EQ(GURL("https://foo.com/instant?ion=1&foo=foo#foo=foo&strk"),
             GetSearchResultPrefetchBaseURL(profile()));
 }
 
 typedef SearchTest IsQueryExtractionEnabledTest;
 
 TEST_F(IsQueryExtractionEnabledTest, NotSet) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
@@ skipping 159 matching lines @@
       "EmbeddedSearch", "Group1 espv:2 origin_chip:1"));
   EXPECT_TRUE(ShouldDisplayOriginChip());
 }
 
 TEST_F(OriginChipTest, CommandLineOriginChip) {
   CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableOriginChip);
   EXPECT_TRUE(ShouldDisplayOriginChip());
 }
 
 }  // namespace chrome