chrome/browser/ui/toolbar/toolbar_model_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/toolbar/toolbar_model.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/metrics/field_trial.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
  11 #include "chrome/browser/search/search.h"
  12 #include "chrome/browser/search_engines/template_url_service_factory.h"
  13 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
  14 #include "chrome/browser/ssl/security_state_model.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/test/base/browser_with_test_window_test.h"
  19 #include "components/google/core/browser/google_switches.h"
  20 #include "components/search/search.h"
  21 #include "components/toolbar/toolbar_model.h"
  22 #include "components/variations/entropy_provider.h"
  23 #include "content/public/browser/navigation_entry.h"
  24 #include "content/public/common/ssl_status.h"
  25 #include "content/public/common/url_constants.h"
  26
  27
  28 // Test data ------------------------------------------------------------------
  29
  30 namespace {
  31
  32 struct TestItem {
  33   GURL url;
  34   // The expected text to display when both forms of URL replacement are
  35   // inactive.
  36   base::string16 expected_text_url_replacement_inactive;
  37   // The expected text to display when query extraction is active.
  38   base::string16 expected_text_query_extraction;
  39   // The expected text to display when both query extraction and URL removal are
  40   // active.
  41   base::string16 expected_text_both;
  42   bool would_perform_search_term_replacement;
  43   bool should_display_url;
  44 } test_items[] = {
  45   {
  46     GURL("view-source:http://www.google.com"),
  47     base::ASCIIToUTF16("view-source:www.google.com"),
  48     base::ASCIIToUTF16("view-source:www.google.com"),
  49     base::string16(),
  50     false,
  51     true
  52   },
  53   {
  54     GURL("view-source:chrome://newtab/"),
  55     base::ASCIIToUTF16("view-source:chrome://newtab"),
  56     base::ASCIIToUTF16("view-source:chrome://newtab"),
  57     base::string16(),
  58     false,
  59     true
  60   },
  61   {
  62     GURL("chrome-extension://monkey/balls.html"),
  63     base::ASCIIToUTF16("chrome-extension://monkey/balls.html"),
  64     base::ASCIIToUTF16("chrome-extension://monkey/balls.html"),
  65     base::string16(),
  66     false,
  67     true
  68   },
  69   {
  70     GURL(url::kAboutBlankURL),
  71     base::ASCIIToUTF16(url::kAboutBlankURL),
  72     base::ASCIIToUTF16(url::kAboutBlankURL),
  73     base::string16(),
  74     false,
  75     true
  76   },
  77   {
  78     GURL("http://searchurl/?q=tractor+supply"),
  79     base::ASCIIToUTF16("searchurl/?q=tractor+supply"),
  80     base::ASCIIToUTF16("searchurl/?q=tractor+supply"),
  81     base::string16(),
  82     false,
  83     true
  84   },
  85   {
  86     GURL("http://google.com/search?q=tractor+supply&espv=1"),
  87     base::ASCIIToUTF16("google.com/search?q=tractor+supply&espv=1"),
  88     base::ASCIIToUTF16("google.com/search?q=tractor+supply&espv=1"),
  89     base::string16(),
  90     false,
  91     true
  92   },
  93   {
  94     GURL("https://google.ca/search?q=tractor+supply"),
  95     base::ASCIIToUTF16("https://google.ca/search?q=tractor+supply"),
  96     base::ASCIIToUTF16("https://google.ca/search?q=tractor+supply"),
  97     base::string16(),
  98     false,
  99     true
 100   },
 101   {
 102     GURL("https://google.com/search?q=tractor+supply"),
 103     base::ASCIIToUTF16("https://google.com/search?q=tractor+supply"),
 104     base::ASCIIToUTF16("https://google.com/search?q=tractor+supply"),
 105     base::string16(),
 106     false,
 107     true
 108   },
 109   {
 110     GURL("https://google.com/search?q=tractor+supply&espv=1"),
 111     base::ASCIIToUTF16("https://google.com/search?q=tractor+supply&espv=1"),
 112     base::ASCIIToUTF16("tractor supply"),
 113     base::ASCIIToUTF16("tractor supply"),
 114     true,
 115     true
 116   },
 117   {
 118     GURL("https://google.com/search?q=tractorsupply.com&espv=1"),
 119     base::ASCIIToUTF16("https://google.com/search?q=tractorsupply.com&espv=1"),
 120     base::ASCIIToUTF16("tractorsupply.com"),
 121     base::ASCIIToUTF16("tractorsupply.com"),
 122     true,
 123     true
 124   },
 125   {
 126     GURL("https://google.com/search?q=ftp://tractorsupply.ie&espv=1"),
 127     base::ASCIIToUTF16(
 128         "https://google.com/search?q=ftp://tractorsupply.ie&espv=1"),
 129     base::ASCIIToUTF16("ftp://tractorsupply.ie"),
 130     base::ASCIIToUTF16("ftp://tractorsupply.ie"),
 131     true,
 132     true
 133   },
 134 };
 135
 136 void SetSecurityStyle(content::NavigationController* controller,
 137                       content::SecurityStyle new_style) {
 138   controller->GetVisibleEntry()->GetSSL().security_style = new_style;
 139   SecurityStateModel* model =
 140       SecurityStateModel::FromWebContents(controller->GetWebContents());
 141   ASSERT_TRUE(model);
 142   model->SecurityStateChanged();
 143 }
 144
 145 }  // namespace
 146
 147
 148 // ToolbarModelTest -----------------------------------------------------------
 149
 150 class ToolbarModelTest : public BrowserWithTestWindowTest {
 151  public:
 152   ToolbarModelTest();
 153   ToolbarModelTest(Browser::Type browser_type,
 154                    chrome::HostDesktopType host_desktop_type,
 155                    bool hosted_app);
 156   ~ToolbarModelTest() override;
 157
 158   // BrowserWithTestWindowTest:
 159   void SetUp() override;
 160
 161  protected:
 162   void NavigateAndCheckText(const GURL& url,
 163                             const base::string16& expected_text,
 164                             bool would_perform_search_term_replacement,
 165                             bool should_display_url);
 166
 167  private:
 168   scoped_ptr<base::FieldTrialList> field_trial_list_;
 169
 170   DISALLOW_COPY_AND_ASSIGN(ToolbarModelTest);
 171 };
 172
 173 ToolbarModelTest::ToolbarModelTest() {
 174 }
 175
 176 ToolbarModelTest::ToolbarModelTest(
 177     Browser::Type browser_type,
 178     chrome::HostDesktopType host_desktop_type,
 179     bool hosted_app)
 180     : BrowserWithTestWindowTest(browser_type,
 181                                 host_desktop_type,
 182                                 hosted_app) {
 183 }
 184
 185 ToolbarModelTest::~ToolbarModelTest() {
 186 }
 187
 188 void ToolbarModelTest::SetUp() {
 189   BrowserWithTestWindowTest::SetUp();
 190   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
 191       profile(), &TemplateURLServiceFactory::BuildInstanceFor);
 192   AutocompleteClassifierFactory::GetInstance()->SetTestingFactoryAndUse(
 193       profile(), &AutocompleteClassifierFactory::BuildInstanceFor);
 194   UIThreadSearchTermsData::SetGoogleBaseURL("http://google.com/");
 195 }
 196
 197 void ToolbarModelTest::NavigateAndCheckText(
 198     const GURL& url,
 199     const base::string16& expected_text,
 200     bool would_perform_search_term_replacement,
 201     bool should_display_url) {
 202   // Check while loading.
 203   content::NavigationController* controller =
 204       &browser()->tab_strip_model()->GetWebContentsAt(0)->GetController();
 205   controller->LoadURL(url, content::Referrer(), ui::PAGE_TRANSITION_LINK,
 206                       std::string());
 207   ToolbarModel* toolbar_model = browser()->toolbar_model();
 208   EXPECT_EQ(expected_text, toolbar_model->GetText());
 209   EXPECT_EQ(would_perform_search_term_replacement,
 210             toolbar_model->WouldPerformSearchTermReplacement(false));
 211   EXPECT_EQ(should_display_url, toolbar_model->ShouldDisplayURL());
 212
 213   // Check after commit.
 214   CommitPendingLoad(controller);
 215   // Fake a secure connection for HTTPS URLs, or the toolbar will refuse to
 216   // extract search terms.
 217   if (url.SchemeIsCryptographic()) {
 218     ASSERT_NO_FATAL_FAILURE(
 219         SetSecurityStyle(controller, content::SECURITY_STYLE_AUTHENTICATED));
 220   }
 221   EXPECT_EQ(expected_text, toolbar_model->GetText());
 222   EXPECT_EQ(would_perform_search_term_replacement,
 223             toolbar_model->WouldPerformSearchTermReplacement(false));
 224   EXPECT_EQ(should_display_url, toolbar_model->ShouldDisplayURL());
 225
 226   // Now pretend the user started modifying the omnibox.
 227   toolbar_model->set_input_in_progress(true);
 228   EXPECT_FALSE(toolbar_model->WouldPerformSearchTermReplacement(false));
 229   EXPECT_EQ(would_perform_search_term_replacement,
 230             toolbar_model->WouldPerformSearchTermReplacement(true));
 231
 232   // Tell the ToolbarModel that the user has stopped editing.  This prevents
 233   // this function from having side effects.
 234   toolbar_model->set_input_in_progress(false);
 235 }
 236
 237 class PopupToolbarModelTest : public ToolbarModelTest {
 238  public:
 239   PopupToolbarModelTest();
 240   ~PopupToolbarModelTest() override;
 241
 242   DISALLOW_COPY_AND_ASSIGN(PopupToolbarModelTest);
 243 };
 244
 245 PopupToolbarModelTest::PopupToolbarModelTest()
 246       : ToolbarModelTest(Browser::TYPE_POPUP,
 247                          chrome::HOST_DESKTOP_TYPE_NATIVE,
 248                          false) {
 249 }
 250
 251 PopupToolbarModelTest::~PopupToolbarModelTest() {
 252 }
 253
 254 // Actual tests ---------------------------------------------------------------
 255
 256 // Test that we only replace URLs when query extraction and URL replacement
 257 // are enabled.
 258 TEST_F(ToolbarModelTest, ShouldDisplayURL_QueryExtraction) {
 259   AddTab(browser(), GURL(url::kAboutBlankURL));
 260
 261   // Before we enable instant extended, query extraction is disabled.
 262   EXPECT_FALSE(search::IsQueryExtractionEnabled())
 263       << "This test expects query extraction to be disabled.";
 264   for (size_t i = 0; i < arraysize(test_items); ++i) {
 265     const TestItem& test_item = test_items[i];
 266     NavigateAndCheckText(test_item.url,
 267                          test_item.expected_text_url_replacement_inactive,
 268                          false, test_item.should_display_url);
 269   }
 270
 271   search::EnableQueryExtractionForTesting();
 272   EXPECT_TRUE(search::IsQueryExtractionEnabled());
 273   EXPECT_TRUE(browser()->toolbar_model()->url_replacement_enabled());
 274   for (size_t i = 0; i < arraysize(test_items); ++i) {
 275     const TestItem& test_item = test_items[i];
 276     NavigateAndCheckText(test_item.url,
 277                          test_item.expected_text_query_extraction,
 278                          test_item.would_perform_search_term_replacement,
 279                          test_item.should_display_url);
 280   }
 281
 282   // Disabling URL replacement should reset to only showing URLs.
 283   browser()->toolbar_model()->set_url_replacement_enabled(false);
 284   for (size_t i = 0; i < arraysize(test_items); ++i) {
 285     const TestItem& test_item = test_items[i];
 286     NavigateAndCheckText(test_item.url,
 287                          test_item.expected_text_url_replacement_inactive,
 288                          false, test_item.should_display_url);
 289   }
 290 }
 291
 292  // Verify that search terms are extracted while the page is loading.
 293 TEST_F(ToolbarModelTest, SearchTermsWhileLoading) {
 294   search::EnableQueryExtractionForTesting();
 295   AddTab(browser(), GURL(url::kAboutBlankURL));
 296
 297   // While loading, we should be willing to extract search terms.
 298   content::NavigationController* controller =
 299       &browser()->tab_strip_model()->GetWebContentsAt(0)->GetController();
 300   controller->LoadURL(GURL("https://google.com/search?q=tractor+supply&espv=1"),
 301                       content::Referrer(), ui::PAGE_TRANSITION_LINK,
 302                       std::string());
 303   ToolbarModel* toolbar_model = browser()->toolbar_model();
 304   ASSERT_NO_FATAL_FAILURE(
 305       SetSecurityStyle(controller, content::SECURITY_STYLE_UNKNOWN));
 306   EXPECT_TRUE(toolbar_model->WouldPerformSearchTermReplacement(false));
 307
 308   // When done loading, we shouldn't extract search terms if we didn't get an
 309   // authenticated connection.
 310   CommitPendingLoad(controller);
 311   ASSERT_NO_FATAL_FAILURE(
 312       SetSecurityStyle(controller, content::SECURITY_STYLE_UNKNOWN));
 313   EXPECT_FALSE(toolbar_model->WouldPerformSearchTermReplacement(false));
 314 }
 315
 316 // When the Google base URL is overridden on the command line, we should extract
 317 // search terms from URLs that start with that base URL even when they're not
 318 // secure.
 319 TEST_F(ToolbarModelTest, GoogleBaseURL) {
 320   search::EnableQueryExtractionForTesting();
 321   AddTab(browser(), GURL(url::kAboutBlankURL));
 322
 323   // If the Google base URL wasn't specified on the command line, then if it's
 324   // HTTP, we should not extract search terms.
 325   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.foo.com/");
 326   NavigateAndCheckText(
 327       GURL("http://www.foo.com/search?q=tractor+supply&espv=1"),
 328       base::ASCIIToUTF16("www.foo.com/search?q=tractor+supply&espv=1"), false,
 329       true);
 330
 331   // The same URL, when specified on the command line, should allow search term
 332   // extraction.
 333   UIThreadSearchTermsData::SetGoogleBaseURL(std::string());
 334   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 335       switches::kGoogleBaseURL, "http://www.foo.com/");
 336   NavigateAndCheckText(
 337       GURL("http://www.foo.com/search?q=tractor+supply&espv=1"),
 338       base::ASCIIToUTF16("tractor supply"), true, true);
 339 }
 340
 341 // Test that URL display in a popup respects the query extraction flag.
 342 TEST_F(PopupToolbarModelTest, ShouldDisplayURL) {
 343   AddTab(browser(), GURL(url::kAboutBlankURL));
 344
 345   // Check with query extraction disabled.
 346   EXPECT_FALSE(search::IsQueryExtractionEnabled());
 347   for (size_t i = 0; i < arraysize(test_items); ++i) {
 348     const TestItem& test_item = test_items[i];
 349     NavigateAndCheckText(test_item.url,
 350                          test_item.expected_text_url_replacement_inactive,
 351                          false, test_item.should_display_url);
 352   }
 353
 354   // With query extraction enabled, search term replacement should be performed.
 355   search::EnableQueryExtractionForTesting();
 356   EXPECT_TRUE(search::IsQueryExtractionEnabled());
 357   EXPECT_TRUE(browser()->toolbar_model()->url_replacement_enabled());
 358   for (size_t i = 0; i < arraysize(test_items); ++i) {
 359     const TestItem& test_item = test_items[i];
 360     NavigateAndCheckText(test_item.url,
 361                          test_item.expected_text_query_extraction,
 362                          test_item.would_perform_search_term_replacement,
 363                          test_item.should_display_url);
 364   }
 365
 366   // Disabling URL replacement should reset to only showing URLs.
 367   browser()->toolbar_model()->set_url_replacement_enabled(false);
 368   for (size_t i = 0; i < arraysize(test_items); ++i) {
 369     const TestItem& test_item = test_items[i];
 370     NavigateAndCheckText(test_item.url,
 371                          test_item.expected_text_url_replacement_inactive,
 372                          false, test_item.should_display_url);
 373   }
 374 }