Omnibox: Fixes Allow-To-Be-Default-Match Code for HistoryQuick Provider

chrome/browser/autocomplete/history_quick_provider_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/autocomplete/history_quick_provider.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <string>
@@ skipping 116 matching lines @@
 
   virtual void GetTestData(size_t* data_count, TestURLInfo** test_data);
 
   // Fills test data into the history system.
   void FillData();
 
   // Runs an autocomplete query on |text| and checks to see that the returned
   // results' destination URLs match those provided. |expected_urls| does not
   // need to be in sorted order.
   void RunTest(const base::string16 text,
+               bool prevent_inline_autocomplete,
                std::vector<std::string> expected_urls,
                bool can_inline_top_result,
-               base::string16 expected_fill_into_edit);
+               base::string16 expected_fill_into_edit,
+               base::string16 autocompletion);
 
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   scoped_ptr<TestingProfile> profile_;
   HistoryService* history_service_;
 
   ACMatches ac_matches_;  // The resulting matches after running RunTest.
 
@@ skipping 82 matching lines @@
 }
 
 void HistoryQuickProviderTest::SetShouldContain::operator()(
     const std::string& expected) {
   EXPECT_EQ(1U, matches_.erase(expected))
       << "Results did not contain '" << expected << "' but should have.";
 }
 
 
 void HistoryQuickProviderTest::RunTest(const base::string16 text,
+                                       bool prevent_inline_autocomplete,
                                        std::vector<std::string> expected_urls,
                                        bool can_inline_top_result,
-                                       base::string16 expected_fill_into_edit) {
+                                       base::string16 expected_fill_into_edit,
+                                       base::string16 expected_autocompletion) {
   SCOPED_TRACE(text);  // Minimal hint to query being run.
   base::MessageLoop::current()->RunUntilIdle();
   AutocompleteInput input(text, base::string16::npos, base::string16(),
-                          GURL(), AutocompleteInput::INVALID_SPEC, false,
-                          false, true, AutocompleteInput::ALL_MATCHES);
+                          GURL(), AutocompleteInput::INVALID_SPEC,
+                          prevent_inline_autocomplete, false, true,
+                          AutocompleteInput::ALL_MATCHES);
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->done());
 
   ac_matches_ = provider_->matches();
 
   // We should have gotten back at most AutocompleteProvider::kMaxMatches.
   EXPECT_LE(ac_matches_.size(), AutocompleteProvider::kMaxMatches);
 
   // If the number of expected and actual matches aren't equal then we need
   // test no further, but let's do anyway so that we know which URLs failed.
@@ skipping 21 matching lines @@
     EXPECT_EQ(*expected, actual->destination_url.spec())
         << "For result #" << i << " we got '" << actual->destination_url.spec()
         << "' but expected '" << *expected << "'.";
     EXPECT_LT(actual->relevance, best_score)
       << "At result #" << i << " (url=" << actual->destination_url.spec()
       << "), we noticed scores are not monotonically decreasing.";
     best_score = actual->relevance;
   }
 
   EXPECT_EQ(can_inline_top_result, ac_matches_[0].allowed_to_be_default_match);
-  if (can_inline_top_result) {
-    // When the top scorer is inline-able make sure we get the expected
-    // fill_into_edit and autocomplete offset.
-    EXPECT_EQ(expected_fill_into_edit, ac_matches_[0].fill_into_edit)
-        << "fill_into_edit was: '" << ac_matches_[0].fill_into_edit
-        << "' but we expected '" << expected_fill_into_edit << "'.";
-    size_t text_pos = expected_fill_into_edit.find(text);
-    ASSERT_NE(base::string16::npos, text_pos);
-    EXPECT_EQ(ac_matches_[0].fill_into_edit.substr(text_pos + text.size()),
-              ac_matches_[0].inline_autocompletion);
-  } else {
-    // When the top scorer is not inline-able autocomplete offset must be npos.
-    EXPECT_TRUE(ac_matches_[0].inline_autocompletion.empty());
-  }
+  if (can_inline_top_result)

[Mark P, 2014/02/22 00:01:05]

I revised all the tests here so fill_into_edit is checked regardless of
inlineability.
In the process, I made the test for inline_autocompletion explicit rather than
calculated based off fill_into_edit (because sometimes with trailing slashes it
might not be part of fill_into_edit).
I also removed the check that inline_autocompletion is empty when you can't
inline the top result.  If the match isn't inlineable, it doesn't matter what
the inline_autocompletion is.

+    EXPECT_EQ(expected_autocompletion, ac_matches_[0].inline_autocompletion);
+  EXPECT_EQ(expected_fill_into_edit, ac_matches_[0].fill_into_edit);
 }
 
 TEST_F(HistoryQuickProviderTest, SimpleSingleMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://slashdot.org/favorite_page.html");
-  RunTest(ASCIIToUTF16("slashdot"), expected_urls, true,
-          ASCIIToUTF16("slashdot.org/favorite_page.html"));
+  RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
+          ASCIIToUTF16("slashdot.org/favorite_page.html"),
+                  ASCIIToUTF16(".org/favorite_page.html"));
 }
 
 TEST_F(HistoryQuickProviderTest, MultiTermTitleMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back(
       "http://cda.com/Dogs%20Cats%20Gorillas%20Sea%20Slugs%20and%20Mice");
-  RunTest(ASCIIToUTF16("mice other animals"), expected_urls, false,
-          ASCIIToUTF16("cda.com/Dogs Cats Gorillas Sea Slugs and Mice"));
+  RunTest(ASCIIToUTF16("mice other animals"), false, expected_urls, false,
+          ASCIIToUTF16("cda.com/Dogs Cats Gorillas Sea Slugs and Mice"),
+          base::string16());
 }
 
 TEST_F(HistoryQuickProviderTest, NonWordLastCharacterMatch) {
   std::string expected_url("http://slashdot.org/favorite_page.html");
   std::vector<std::string> expected_urls;
   expected_urls.push_back(expected_url);
-  RunTest(ASCIIToUTF16("slashdot.org/"), expected_urls, true,
-          ASCIIToUTF16("slashdot.org/favorite_page.html"));
+  RunTest(ASCIIToUTF16("slashdot.org/"), false, expected_urls, true,
+          ASCIIToUTF16("slashdot.org/favorite_page.html"),
+                       ASCIIToUTF16("favorite_page.html"));
 }
 
 TEST_F(HistoryQuickProviderTest, MultiMatch) {
   std::vector<std::string> expected_urls;
   // Scores high because of typed_count.
   expected_urls.push_back("http://foo.com/");
   // Scores high because of visit count.
   expected_urls.push_back("http://foo.com/dir/another/");
   // Scores high because of high visit count.
   expected_urls.push_back("http://foo.com/dir/another/again/");
-  RunTest(ASCIIToUTF16("foo"), expected_urls, true, ASCIIToUTF16("foo.com"));
+  RunTest(ASCIIToUTF16("foo"), false, expected_urls, true,
+          ASCIIToUTF16("foo.com"), ASCIIToUTF16(".com"));
 }
 
 TEST_F(HistoryQuickProviderTest, StartRelativeMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://xyzabcdefghijklmnopqrstuvw.com/a");
-  RunTest(ASCIIToUTF16("xyza"), expected_urls, true,
-          ASCIIToUTF16("xyzabcdefghijklmnopqrstuvw.com/a"));
+  RunTest(ASCIIToUTF16("xyza"), false, expected_urls, true,
+          ASCIIToUTF16("xyzabcdefghijklmnopqrstuvw.com/a"),
+              ASCIIToUTF16("bcdefghijklmnopqrstuvw.com/a"));
 }
 
 TEST_F(HistoryQuickProviderTest, EncodingMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://spaces.com/path%20with%20spaces/foo.html");
-  RunTest(ASCIIToUTF16("path with spaces"), expected_urls, false,
-          ASCIIToUTF16("CANNOT AUTOCOMPLETE"));
+  RunTest(ASCIIToUTF16("path with spaces"), false, expected_urls, false,
+          ASCIIToUTF16("spaces.com/path with spaces/foo.html"),
+          base::string16());
 }
 
 TEST_F(HistoryQuickProviderTest, VisitCountMatches) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://visitedest.com/y/a");
   expected_urls.push_back("http://visitedest.com/y/b");
   expected_urls.push_back("http://visitedest.com/x/c");
-  RunTest(ASCIIToUTF16("visitedest"), expected_urls, true,
-          ASCIIToUTF16("visitedest.com/y/a"));
+  RunTest(ASCIIToUTF16("visitedest"), false, expected_urls, true,
+          ASCIIToUTF16("visitedest.com/y/a"),
+                    ASCIIToUTF16(".com/y/a"));
 }
 
 TEST_F(HistoryQuickProviderTest, TypedCountMatches) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://typeredest.com/y/a");
   expected_urls.push_back("http://typeredest.com/y/b");
   expected_urls.push_back("http://typeredest.com/x/c");
-  RunTest(ASCIIToUTF16("typeredest"), expected_urls, true,
-          ASCIIToUTF16("typeredest.com/y/a"));
+  RunTest(ASCIIToUTF16("typeredest"), false, expected_urls, true,
+          ASCIIToUTF16("typeredest.com/y/a"),
+                    ASCIIToUTF16(".com/y/a"));
 }
 
 TEST_F(HistoryQuickProviderTest, DaysAgoMatches) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://daysagoest.com/y/a");
   expected_urls.push_back("http://daysagoest.com/y/b");
   expected_urls.push_back("http://daysagoest.com/x/c");
-  RunTest(ASCIIToUTF16("daysagoest"), expected_urls, true,
-          ASCIIToUTF16("daysagoest.com/y/a"));
+  RunTest(ASCIIToUTF16("daysagoest"), false, expected_urls, true,
+          ASCIIToUTF16("daysagoest.com/y/a"),
+                    ASCIIToUTF16(".com/y/a"));
 }
 
 TEST_F(HistoryQuickProviderTest, EncodingLimitMatch) {
   std::vector<std::string> expected_urls;
   std::string url(
       "http://cda.com/Dogs%20Cats%20Gorillas%20Sea%20Slugs%20and%20Mice");
   // First check that a mid-word match yield no results.
-  RunTest(ASCIIToUTF16("ice"), expected_urls, false,
-          ASCIIToUTF16("cda.com/Dogs Cats Gorillas Sea Slugs and Mice"));
+  RunTest(ASCIIToUTF16("ice"), false, expected_urls, false,
+          ASCIIToUTF16("cda.com/Dogs Cats Gorillas Sea Slugs and Mice"),
+          base::string16());
   // Then check that we get results when the match is at a word start
   // that is present because of an encoded separate (%20 = space).
   expected_urls.push_back(url);
-  RunTest(ASCIIToUTF16("Mice"), expected_urls, false,
-          ASCIIToUTF16("cda.com/Dogs Cats Gorillas Sea Slugs and Mice"));
+  RunTest(ASCIIToUTF16("Mice"), false, expected_urls, false,
+          ASCIIToUTF16("cda.com/Dogs Cats Gorillas Sea Slugs and Mice"),
+          base::string16());
   // Verify that the matches' ACMatchClassifications offsets are in range.
   ACMatchClassifications content(ac_matches_[0].contents_class);
   // The max offset accounts for 6 occurrences of '%20' plus the 'http://'.
   const size_t max_offset = url.length() - ((6 * 2) + 7);
   for (ACMatchClassifications::const_iterator citer = content.begin();
        citer != content.end(); ++citer)
     EXPECT_LT(citer->offset, max_offset);
   ACMatchClassifications description(ac_matches_[0].description_class);
   std::string page_title("Dogs & Cats & Mice & Other Animals");
   for (ACMatchClassifications::const_iterator diter = description.begin();
@@ skipping 49 matching lines @@
   EXPECT_EQ(ACMatchClassification::URL, spans_b[1].style);
   EXPECT_EQ(3U, spans_b[2].offset);
   EXPECT_EQ(ACMatchClassification::MATCH | ACMatchClassification::URL,
             spans_b[2].style);
 }
 
 TEST_F(HistoryQuickProviderTest, DeleteMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://slashdot.org/favorite_page.html");
   // Fill up ac_matches_; we don't really care about the test yet.
-  RunTest(ASCIIToUTF16("slashdot"), expected_urls, true,
-          ASCIIToUTF16("slashdot.org/favorite_page.html"));
+  RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
+          ASCIIToUTF16("slashdot.org/favorite_page.html"),
+                  ASCIIToUTF16(".org/favorite_page.html"));
   EXPECT_EQ(1U, ac_matches_.size());
   provider_->DeleteMatch(ac_matches_[0]);
   // Verify it's no longer an indexed visit.
   expected_urls.clear();
-  RunTest(ASCIIToUTF16("slashdot"), expected_urls, true,
-          ASCIIToUTF16("NONE EXPECTED"));
+  RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
+          ASCIIToUTF16("NONE EXPECTED"), base::string16());
 }
 
 TEST_F(HistoryQuickProviderTest, PreventBeatingURLWhatYouTypedMatch) {
   std::vector<std::string> expected_urls;
 
   expected_urls.clear();
   expected_urls.push_back("http://popularsitewithroot.com/");
   // If the user enters a hostname (no path) that he/she has visited
   // before, we should make sure that all HistoryQuickProvider results
   // have scores less than what HistoryURLProvider will assign the
   // URL-what-you-typed match.
-  RunTest(ASCIIToUTF16("popularsitewithroot.com"), expected_urls, true,
-          ASCIIToUTF16("popularsitewithroot.com"));
+  RunTest(ASCIIToUTF16("popularsitewithroot.com"), false, expected_urls, true,
+          ASCIIToUTF16("popularsitewithroot.com"), base::string16());
   EXPECT_LT(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForBestInlineableResult);
 
   // Check that if the user didn't quite enter the full hostname, this
   // hostname would've normally scored above the URL-what-you-typed match.
-  RunTest(ASCIIToUTF16("popularsitewithroot.c"), expected_urls, true,
-          ASCIIToUTF16("popularsitewithroot.com"));
+  RunTest(ASCIIToUTF16("popularsitewithroot.c"), false, expected_urls, true,
+          ASCIIToUTF16("popularsitewithroot.com"),
+                               ASCIIToUTF16("om"));
   EXPECT_GE(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForWhatYouTypedResult);
 
   expected_urls.clear();
   expected_urls.push_back("http://popularsitewithpathonly.com/moo");
   // If the user enters a hostname of a host that he/she has visited
   // but never visited the root page of, we should make sure that all
   // HistoryQuickProvider results have scores less than what the
   // HistoryURLProvider will assign the URL-what-you-typed match.
-  RunTest(ASCIIToUTF16("popularsitewithpathonly.com"), expected_urls, true,
-          ASCIIToUTF16("popularsitewithpathonly.com/moo"));
+  RunTest(ASCIIToUTF16("popularsitewithpathonly.com"), false, expected_urls,
+          true,
+          ASCIIToUTF16("popularsitewithpathonly.com/moo"),
+                                     ASCIIToUTF16("/moo"));
   EXPECT_LT(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForUnvisitedIntranetResult);
 
   // Verify the same thing happens if the user adds a / to end of the
   // hostname.
-  RunTest(ASCIIToUTF16("popularsitewithpathonly.com/"), expected_urls, true,
-          ASCIIToUTF16("popularsitewithpathonly.com/moo"));
+  RunTest(ASCIIToUTF16("popularsitewithpathonly.com/"), false, expected_urls,
+          true, ASCIIToUTF16("popularsitewithpathonly.com/moo"),
+                                            ASCIIToUTF16("moo"));
   EXPECT_LT(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForUnvisitedIntranetResult);
 
   // Check that if the user didn't quite enter the full hostname, this
   // page would've normally scored above the URL-what-you-typed match.
-  RunTest(ASCIIToUTF16("popularsitewithpathonly.co"), expected_urls, true,
-          ASCIIToUTF16("popularsitewithpathonly.com/moo"));
+  RunTest(ASCIIToUTF16("popularsitewithpathonly.co"), false, expected_urls,
+          true, ASCIIToUTF16("popularsitewithpathonly.com/moo"),
+                                          ASCIIToUTF16("m/moo"));
   EXPECT_GE(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForWhatYouTypedResult);
 
   // If the user enters a hostname + path that he/she has not visited
   // before (but visited other things on the host), we can allow
   // inline autocompletions.
-  RunTest(ASCIIToUTF16("popularsitewithpathonly.com/mo"), expected_urls, true,
-          ASCIIToUTF16("popularsitewithpathonly.com/moo"));
+  RunTest(ASCIIToUTF16("popularsitewithpathonly.com/mo"), false, expected_urls,
+          true,
+          ASCIIToUTF16("popularsitewithpathonly.com/moo"),
+                                        ASCIIToUTF16("o"));
   EXPECT_GE(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForWhatYouTypedResult);
 
   // If the user enters a hostname + path that he/she has visited
   // before, we should make sure that all HistoryQuickProvider results
   // have scores less than what the HistoryURLProvider will assign
   // the URL-what-you-typed match.
-  RunTest(ASCIIToUTF16("popularsitewithpathonly.com/moo"),
+  RunTest(ASCIIToUTF16("popularsitewithpathonly.com/moo"), false,
           expected_urls, true,
-          ASCIIToUTF16("popularsitewithpathonly.com/moo"));
+          ASCIIToUTF16("popularsitewithpathonly.com/moo"), base::string16());
   EXPECT_LT(ac_matches_[0].relevance,
             HistoryURLProvider::kScoreForBestInlineableResult);
 }
 
+TEST_F(HistoryQuickProviderTest, PreventInlineAutocomplete) {
+  std::vector<std::string> expected_urls;
+  expected_urls.push_back("http://popularsitewithroot.com/");
+
+  // Check that the desired URL is normally allowed to be the default match
+  // against input that is a prefex of the URL.
+  RunTest(ASCIIToUTF16("popularsitewithr"), false, expected_urls, true,
+          ASCIIToUTF16("popularsitewithroot.com"),
+                          ASCIIToUTF16("oot.com"));
+
+  // Check that it's not allowed to be the default match if
+  // prevent_inline_autocomplete is true.
+  RunTest(ASCIIToUTF16("popularsitewithr"), true, expected_urls, false,
+          ASCIIToUTF16("popularsitewithroot.com"),
+                          ASCIIToUTF16("oot.com"));
+
+  // But the exact hostname can still match even if prevent inline autocomplete
+  // is true.  i.e., there's no autocompletion necessary; this is effectively
+  // URL-what-you-typed.
+  RunTest(ASCIIToUTF16("popularsitewithroot.com"), true, expected_urls, true,
+          ASCIIToUTF16("popularsitewithroot.com"), base::string16());
+
+  // The above still holds even with an extra trailing slash.
+  RunTest(ASCIIToUTF16("popularsitewithroot.com/"), true, expected_urls, true,
+          ASCIIToUTF16("popularsitewithroot.com"), base::string16());
+}
+
 TEST_F(HistoryQuickProviderTest, CullSearchResults) {
   // Set up a default search engine.
   TemplateURLData data;
   data.SetKeyword(ASCIIToUTF16("TestEngine"));
   data.SetURL("http://testsearch.com/?q={searchTerms}");
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_.get());
   TemplateURL* template_url = new TemplateURL(profile_.get(), data);
   template_url_service->Add(template_url);
   template_url_service->SetDefaultSearchProvider(template_url);
   template_url_service->Load();
 
   // A search results page should not be returned when typing a query.
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://anotherengine.com/?q=thequery");
-  RunTest(ASCIIToUTF16("thequery"), expected_urls, false, base::string16());
+  RunTest(ASCIIToUTF16("thequery"), false, expected_urls, false,
+          ASCIIToUTF16("anotherengine.com/?q=thequery"), base::string16());
 
   // A search results page should not be returned when typing the engine URL.
   expected_urls.clear();
   expected_urls.push_back("http://testsearch.com/");
-  RunTest(ASCIIToUTF16("testsearch"), expected_urls, true,
-          ASCIIToUTF16("testsearch.com"));
+  RunTest(ASCIIToUTF16("testsearch"), false, expected_urls, true,
+          ASCIIToUTF16("testsearch.com"),
+                    ASCIIToUTF16(".com"));
 }
 
 // HQPOrderingTest -------------------------------------------------------------
 
 TestURLInfo ordering_test_db[] = {
   {"http://www.teamliquid.net/tlpd/korean/games/21648_bisu_vs_iris", "", 6, 3,
       256},
   {"http://www.amazon.com/", "amazon.com: online shopping for electronics, "
       "apparel, computers, books, dvds & more", 20, 20, 10},
   {"http://www.teamliquid.net/forum/viewmessage.php?topic_id=52045&"
@@ skipping 37 matching lines @@
   DCHECK(test_data);
   *data_count = arraysize(ordering_test_db);
   *test_data = &ordering_test_db[0];
 }
 
 TEST_F(HQPOrderingTest, TEMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://techmeme.com/");
   expected_urls.push_back("http://www.teamliquid.net/");
   expected_urls.push_back("http://www.teamliquid.net/tlpd");
-  RunTest(ASCIIToUTF16("te"), expected_urls, true,
-          ASCIIToUTF16("techmeme.com"));
+  RunTest(ASCIIToUTF16("te"), false, expected_urls, true,
+          ASCIIToUTF16("techmeme.com"),
+            ASCIIToUTF16("chmeme.com"));
 }
 
 TEST_F(HQPOrderingTest, TEAMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://www.teamliquid.net/");
   expected_urls.push_back("http://www.teamliquid.net/tlpd");
   expected_urls.push_back("http://www.teamliquid.net/tlpd/korean/players");
-  RunTest(ASCIIToUTF16("tea"), expected_urls, true,
-          ASCIIToUTF16("www.teamliquid.net"));
+  RunTest(ASCIIToUTF16("tea"), false, expected_urls, true,
+          ASCIIToUTF16("www.teamliquid.net"),
+                 ASCIIToUTF16("mliquid.net"));
 }