Reload Local NTP on default search provider change.

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 160 matching lines @@
  protected:
   virtual 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 =
         TemplateURLServiceFactory::GetForProfile(profile());
     ui_test_utils::WaitForTemplateURLServiceToLoad(template_url_service);
-    SetSearchProvider(false);
+    SetSearchProvider();
   }
 
-  void SetSearchProvider(bool is_google) {
+  void SetSearchProvider() {
     TemplateURLService* template_url_service =
         TemplateURLServiceFactory::GetForProfile(profile());
     TemplateURLData data;
-    if (is_google) {
-      data.SetURL("http://www.google.com/");
-      data.instant_url = "http://www.google.com/";
-    } else {
-      data.SetURL("http://foo.com/url?bar={searchTerms}");
-      data.instant_url = "http://foo.com/instant?"
-          "{google:omniboxStartMarginParameter}foo=foo#foo=foo&strk";
-      data.alternate_urls.push_back("http://foo.com/alt#quux={searchTerms}");
-      data.search_terms_replacement_key = "strk";
-    }
+    data.SetURL("http://foo.com/url?bar={searchTerms}");
+    data.instant_url = "http://foo.com/instant?"
+        "{google:omniboxStartMarginParameter}foo=foo#foo=foo&strk";
+    data.alternate_urls.push_back("http://foo.com/alt#quux={searchTerms}");
+    data.search_terms_replacement_key = "strk";
+
     TemplateURL* template_url = new TemplateURL(profile(), data);
     // Takes ownership of |template_url|.
     template_url_service->Add(template_url);
     template_url_service->SetDefaultSearchProvider(template_url);
   }
 
   // Build an Instant URL with or without a valid search terms replacement key
   // as per |has_search_term_replacement_key|. Set that URL as the instant URL
   // for the default search provider.
   void SetDefaultInstantTemplateUrl(bool has_search_term_replacement_key) {
@@ skipping 56 matching lines @@
               ShouldAssignURLToInstantRenderer(GURL(test.url), profile()))
         << test.url << " " << test.comment;
   }
 }
 
 TEST_F(SearchTest, ShouldAssignURLToInstantRendererExtendedEnabled) {
   EnableInstantExtendedAPIForTesting();
 
   const SearchTestCase kTestCases[] = {
     {chrome::kChromeSearchLocalNtpUrl, true,  ""},
-    {chrome::kChromeSearchLocalGoogleNtpUrl, true,  ""},
     {"https://foo.com/instant?strk",   true,  ""},
     {"https://foo.com/instant#strk",   true,  ""},
     {"https://foo.com/instant?strk=0", true,  ""},
     {"https://foo.com/url?strk",       true,  ""},
     {"https://foo.com/alt?strk",       true,  ""},
     {"http://foo.com/instant",         false, "Non-HTTPS"},
     {"http://foo.com/instant?strk",    false, "Non-HTTPS"},
     {"http://foo.com/instant?strk=1",  false, "Non-HTTPS"},
     {"https://foo.com/instant",        false, "No search terms replacement"},
     {"https://foo.com/?strk",          false, "Non-exact path"},
@@ skipping 16 matching lines @@
   {"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/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"},
   {chrome::kChromeSearchLocalNtpUrl,       true,  "Local new tab page"},
-  {chrome::kChromeSearchLocalGoogleNtpUrl, true,  "Local new tab page"},
   {"https://bar.com/instant?strk=1",       false, "Random non-search page"},
 };
 
 TEST_F(SearchTest, InstantNTPExtendedEnabled) {
   EnableInstantExtendedAPIForTesting();
   AddTab(browser(), GURL("chrome://blank"));
   for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) {
     const SearchTestCase& test = kInstantNTPTestCases[i];
     NavigateAndCommitActiveTab(GURL(test.url));
-    SetSearchProvider(test.url == chrome::kChromeSearchLocalGoogleNtpUrl);
     const content::WebContents* contents =
         browser()->tab_strip_model()->GetWebContentsAt(0);
     EXPECT_EQ(test.expected_result, IsInstantNTP(contents))
         << test.url << " " << test.comment;
   }
 }
 
 TEST_F(SearchTest, InstantNTPExtendedDisabled) {
   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_FALSE(IsInstantNTP(contents)) << test.url << " " << test.comment;
   }
 }
 
 TEST_F(SearchTest, InstantNTPCustomNavigationEntry) {
   EnableInstantExtendedAPIForTesting();
   AddTab(browser(), GURL("chrome://blank"));
   for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) {
     const SearchTestCase& test = kInstantNTPTestCases[i];
     NavigateAndCommitActiveTab(GURL(test.url));
-    SetSearchProvider(test.url == chrome::kChromeSearchLocalGoogleNtpUrl);
     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()));
@@ skipping 44 matching lines @@
             GetInstantURL(profile(), kDisableStartMargin));
 
   // With start margin.
   EXPECT_EQ(GURL("https://foo.com/instant?es_sm=10&foo=foo#foo=foo&strk"),
             GetInstantURL(profile(), 10));
 }
 
 TEST_F(SearchTest, CommandLineOverrides) {
   EnableInstantExtendedAPIForTesting();
 
-  // GetLocalInstantURL() should default to the non-Google local NTP.
-  SetSearchProvider(false);
   GURL local_instant_url(GetLocalInstantURL(profile()));
   EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl), local_instant_url);
 
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile());
   TemplateURLData data;
   data.SetURL("{google:baseURL}search?q={searchTerms}");
   data.instant_url = "{google:baseURL}webhp?strk";
   data.search_terms_replacement_key = "strk";
   TemplateURL* template_url = new TemplateURL(profile(), data);
@@ skipping 14 matching lines @@
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(switches::kGoogleBaseURL,
                                                       "http://www.bar.com/");
   instant_url = GetInstantURL(profile(), kDisableStartMargin);
   ASSERT_TRUE(instant_url.is_valid());
   EXPECT_EQ("http://www.bar.com/webhp?strk", instant_url.spec());
 
   // Similarly, setting a Google base URL on the command line should allow you
   // to get the Google version of the local NTP, even though search provider's
   // URL doesn't contain "google".
   local_instant_url = GetLocalInstantURL(profile());
-  EXPECT_EQ(GURL(chrome::kChromeSearchLocalGoogleNtpUrl), local_instant_url);
+  EXPECT_EQ(GURL(chrome::kChromeSearchLocalNtpUrl), local_instant_url);
 
   // 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);
   ASSERT_TRUE(instant_url.is_valid());
   EXPECT_EQ("http://www.bar.com/webhp?a=b&strk", instant_url.spec());
 }
 
 }  // namespace chrome