Pass AutocompleteProvider::kMaxMatches to InMemoryURLIndex

chrome/browser/history/in_memory_url_index_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 <algorithm>
 #include <fstream>
 
 #include "base/auto_reset.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 429 matching lines @@
 
   // history_info_map_ should have the same number of items as were filtered.
   EXPECT_EQ(1U, private_data.history_info_map_.size());
   EXPECT_EQ(35U, private_data.char_word_map_.size());
   EXPECT_EQ(17U, private_data.word_map_.size());
 }
 
 TEST_F(InMemoryURLIndexTest, Retrieval) {
   // See if a very specific term gives a single result.
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("DrudgeReport"), base::string16::npos);
+      ASCIIToUTF16("DrudgeReport"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);

[sdefresne, 2014/05/22 15:41:13]

Most of the tests don't depends on the value of
AutocompleteProvider::kMaxMatches, except InMemoryURLIndexTest.HugeResultSet
that check that the returned list is bounded.

So I'd recommend using another constant in that in_memory_url_index_unittest.cc
(it does not have to be in sync with the value in AutocompleteProvider), and
remove the include chrome/browser/autocomplete/autocomplete_provider.h (and
remove it from DEPS).

[Jiang Jiang, 2014/05/23 16:12:52]

Done.

   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   EXPECT_EQ(5, matches[0].url_info.id());
   EXPECT_EQ("http://drudgereport.com/", matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16("DRUDGE REPORT 2010"), matches[0].url_info.title());
   EXPECT_TRUE(matches[0].can_inline());
 
   // Make sure a trailing space prevents inline-ability but still results
   // in the expected result.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudgeReport "),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(5, matches[0].url_info.id());
   EXPECT_EQ("http://drudgereport.com/", matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16("DRUDGE REPORT 2010"), matches[0].url_info.title());
   EXPECT_FALSE(matches[0].can_inline());
 
   // Search which should result in multiple results.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("drudge"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(2U, matches.size());
   // The results should be in descending score order.
   EXPECT_GE(matches[0].raw_score(), matches[1].raw_score());
 
   // Search which should result in nearly perfect result.
   matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("Nearly Perfect Result"), base::string16::npos);
+      ASCIIToUTF16("Nearly Perfect Result"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   // The results should have a very high score.
   EXPECT_GT(matches[0].raw_score(), 900);
   EXPECT_EQ(32, matches[0].url_info.id());
   EXPECT_EQ("https://nearlyperfectresult.com/",
             matches[0].url_info.url().spec());  // Note: URL gets lowercased.
   EXPECT_EQ(ASCIIToUTF16("Practically Perfect Search Result"),
             matches[0].url_info.title());
   EXPECT_FALSE(matches[0].can_inline());
 
   // Search which should result in very poor result.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("qui c"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   // The results should have a poor score.
   EXPECT_LT(matches[0].raw_score(), 500);
   EXPECT_EQ(33, matches[0].url_info.id());
   EXPECT_EQ("http://quiteuselesssearchresultxyz.com/",
             matches[0].url_info.url().spec());  // Note: URL gets lowercased.
   EXPECT_EQ(ASCIIToUTF16("Practically Useless Search Result"),
             matches[0].url_info.title());
   EXPECT_FALSE(matches[0].can_inline());
 
   // Search which will match at the end of an URL with encoded characters.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("Mice"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(30, matches[0].url_info.id());
   EXPECT_FALSE(matches[0].can_inline());
 
   // Check that URLs are not escaped an escape time.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("1% wikipedia"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(35, matches[0].url_info.id());
   EXPECT_EQ("http://en.wikipedia.org/wiki/1%25_rule_(Internet_culture)",
             matches[0].url_info.url().spec());
 
   // Verify that a single term can appear multiple times in the URL and as long
   // as one starts the URL it is still inlined.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("fubar"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(34, matches[0].url_info.id());
   EXPECT_EQ("http://fubarfubarandfubar.com/", matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16("Situation Normal -- FUBARED"),
             matches[0].url_info.title());
   EXPECT_TRUE(matches[0].can_inline());
 }
 
 TEST_F(InMemoryURLIndexTest, CursorPositionRetrieval) {
   // See if a very specific term with no cursor gives an empty result.
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("DrudReport"), base::string16::npos);
+      ASCIIToUTF16("DrudReport"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 
   // The same test with the cursor at the end should give an empty result.
-  matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudReport"), 10u);
+  matches = url_index_->HistoryItemsForTerms(
+      ASCIIToUTF16("DrudReport"), 10u, AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 
   // If the cursor is between Drud and Report, we should find the desired
   // result.
-  matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudReport"), 4u);
+  matches = url_index_->HistoryItemsForTerms(
+      ASCIIToUTF16("DrudReport"), 4u, AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ("http://drudgereport.com/", matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16("DRUDGE REPORT 2010"), matches[0].url_info.title());
 
   // Now check multi-word inputs.  No cursor should fail to find a
   // result on this input.
   matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("MORTGAGERATE DROPS"), base::string16::npos);
+      ASCIIToUTF16("MORTGAGERATE DROPS"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 
   // Ditto with cursor at end.
   matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("MORTGAGERATE DROPS"), 18u);
+      ASCIIToUTF16("MORTGAGERATE DROPS"),
+      18u,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 
   // If the cursor is between MORTAGE And RATE, we should find the
   // desired result.
   matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("MORTGAGERATE DROPS"), 8u);
+      ASCIIToUTF16("MORTGAGERATE DROPS"),
+      8u,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ("http://www.reuters.com/article/idUSN0839880620100708",
             matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16(
       "UPDATE 1-US 30-yr mortgage rate drops to new record low | Reuters"),
             matches[0].url_info.title());
 }
 
 TEST_F(InMemoryURLIndexTest, URLPrefixMatching) {
   // "drudgere" - found, can inline
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("drudgere"), base::string16::npos);
+      ASCIIToUTF16("drudgere"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_TRUE(matches[0].can_inline());
 
   // "drudgere" - found, can inline
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("drudgere"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_TRUE(matches[0].can_inline());
 
   // "www.atdmt" - not found
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("www.atdmt"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   EXPECT_EQ(0U, matches.size());
 
   // "atdmt" - found, cannot inline
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("atdmt"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_FALSE(matches[0].can_inline());
 
   // "view.atdmt" - found, can inline
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("view.atdmt"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_TRUE(matches[0].can_inline());
 
   // "view.atdmt" - found, can inline
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("view.atdmt"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_TRUE(matches[0].can_inline());
 
   // "cnn.com" - found, can inline
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("cnn.com"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(2U, matches.size());
   // One match should be inline-able, the other not.
   EXPECT_TRUE(matches[0].can_inline() != matches[1].can_inline());
 
   // "www.cnn.com" - found, can inline
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("www.cnn.com"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_TRUE(matches[0].can_inline());
 
   // "ww.cnn.com" - found because we allow mid-term matches in hostnames
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("ww.cnn.com"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
 
   // "www.cnn.com" - found, can inline
   matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("www.cnn.com"),
-                                       base::string16::npos);
+                                       base::string16::npos,
+                                       AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_TRUE(matches[0].can_inline());
 
   // "tp://www.cnn.com" - not found because we don't allow tp as a mid-term
   // match
   matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("tp://www.cnn.com"),
-                                       base::string16::npos);
+                                       base::string16::npos,
+                                       AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, ProperStringMatching) {
   // Search for the following with the expected results:
   // "atdmt view" - found
   // "atdmt.view" - not found
   // "view.atdmt" - found
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("atdmt view"), base::string16::npos);
+      ASCIIToUTF16("atdmt view"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("atdmt.view"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("view.atdmt"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, HugeResultSet) {
   // Create a huge set of qualifying history items.
   for (URLID row_id = 5000; row_id < 6000; ++row_id) {
     URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), row_id);
     new_row.set_last_visit(base::Time::Now());
     EXPECT_TRUE(UpdateURL(new_row));
   }
 
-  ScoredHistoryMatches matches =
-      url_index_->HistoryItemsForTerms(ASCIIToUTF16("b"), base::string16::npos);
+  ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
+      ASCIIToUTF16("b"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   URLIndexPrivateData& private_data(*GetPrivateData());
   ASSERT_EQ(AutocompleteProvider::kMaxMatches, matches.size());
   // There are 7 matches already in the database.
   ASSERT_EQ(1008U, private_data.pre_filter_item_count_);
   ASSERT_EQ(500U, private_data.post_filter_item_count_);
   ASSERT_EQ(AutocompleteProvider::kMaxMatches,
             private_data.post_scoring_item_count_);
 }
 
 TEST_F(InMemoryURLIndexTest, TitleSearch) {
   // Signal if someone has changed the test DB.
   EXPECT_EQ(29U, GetPrivateData()->history_info_map_.size());
 
   // Ensure title is being searched.
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("MORTGAGE RATE DROPS"), base::string16::npos);
+      ASCIIToUTF16("MORTGAGE RATE DROPS"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   EXPECT_EQ(1, matches[0].url_info.id());
   EXPECT_EQ("http://www.reuters.com/article/idUSN0839880620100708",
             matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16(
       "UPDATE 1-US 30-yr mortgage rate drops to new record low | Reuters"),
       matches[0].url_info.title());
 }
 
 TEST_F(InMemoryURLIndexTest, TitleChange) {
   // Verify current title terms retrieves desired item.
   base::string16 original_terms =
       ASCIIToUTF16("lebronomics could high taxes influence");
   ScoredHistoryMatches matches =
-      url_index_->HistoryItemsForTerms(original_terms, base::string16::npos);
+      url_index_->HistoryItemsForTerms(original_terms,
+                                       base::string16::npos,
+                                       AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   const URLID expected_id = 3;
   EXPECT_EQ(expected_id, matches[0].url_info.id());
   EXPECT_EQ("http://www.businessandmedia.org/articles/2010/20100708120415.aspx",
             matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16(
       "LeBronomics: Could High Taxes Influence James' Team Decision?"),
       matches[0].url_info.title());
   URLRow old_row(matches[0].url_info);
 
   // Verify new title terms retrieves nothing.
   base::string16 new_terms = ASCIIToUTF16("does eat oats little lambs ivy");
-  matches = url_index_->HistoryItemsForTerms(new_terms, base::string16::npos);
+  matches = url_index_->HistoryItemsForTerms(
+      new_terms, base::string16::npos, AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 
   // Update the row.
   old_row.set_title(ASCIIToUTF16("Does eat oats and little lambs eat ivy"));
   EXPECT_TRUE(UpdateURL(old_row));
 
   // Verify we get the row using the new terms but not the original terms.
-  matches = url_index_->HistoryItemsForTerms(new_terms, base::string16::npos);
+  matches = url_index_->HistoryItemsForTerms(
+      new_terms, base::string16::npos, AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(expected_id, matches[0].url_info.id());
-  matches =
-      url_index_->HistoryItemsForTerms(original_terms, base::string16::npos);
+  matches = url_index_->HistoryItemsForTerms(
+      original_terms, base::string16::npos, AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(0U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, NonUniqueTermCharacterSets) {
   // The presence of duplicate characters should succeed. Exercise by cycling
   // through a string with several duplicate characters.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("ABRA"),
-                                       base::string16::npos);
+                                       base::string16::npos,
+                                       AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(28, matches[0].url_info.id());
   EXPECT_EQ("http://www.ddj.com/windows/184416623",
             matches[0].url_info.url().spec());
 
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("ABRACAD"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(28, matches[0].url_info.id());
 
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("ABRACADABRA"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(28, matches[0].url_info.id());
 
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("ABRACADABR"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(28, matches[0].url_info.id());
 
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("ABRACA"),
-                                             base::string16::npos);
+                                             base::string16::npos,
+                                             AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(28, matches[0].url_info.id());
 }
 
 TEST_F(InMemoryURLIndexTest, TypedCharacterCaching) {
   // Verify that match results for previously typed characters are retained
   // (in the term_char_word_set_cache_) and reused, if possible, in future
   // autocompletes.
 
   URLIndexPrivateData::SearchTermCacheMap& cache(
       GetPrivateData()->search_term_cache_);
 
   // The cache should be empty at this point.
   EXPECT_EQ(0U, cache.size());
 
   // Now simulate typing search terms into the omnibox and check the state of
   // the cache as each item is 'typed'.
 
   // Simulate typing "r" giving "r" in the simulated omnibox. The results for
   // 'r' will be not cached because it is only 1 character long.
-  url_index_->HistoryItemsForTerms(ASCIIToUTF16("r"), base::string16::npos);
+  url_index_->HistoryItemsForTerms(ASCIIToUTF16("r"),
+                                   base::string16::npos,
+                                   AutocompleteProvider::kMaxMatches);
   EXPECT_EQ(0U, cache.size());
 
   // Simulate typing "re" giving "r re" in the simulated omnibox.
   // 're' should be cached at this point but not 'r' as it is a single
   // character.
-  url_index_->HistoryItemsForTerms(ASCIIToUTF16("r re"), base::string16::npos);
+  url_index_->HistoryItemsForTerms(ASCIIToUTF16("r re"),
+                                   base::string16::npos,
+                                   AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("re"));
 
   // Simulate typing "reco" giving "r re reco" in the simulated omnibox.
   // 're' and 'reco' should be cached at this point but not 'r' as it is a
   // single character.
   url_index_->HistoryItemsForTerms(ASCIIToUTF16("r re reco"),
-                                   base::string16::npos);
+                                   base::string16::npos,
+                                   AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("re"));
   CheckTerm(cache, ASCIIToUTF16("reco"));
 
   // Simulate typing "mort".
   // Since we now have only one search term, the cached results for 're' and
   // 'reco' should be purged, giving us only 1 item in the cache (for 'mort').
-  url_index_->HistoryItemsForTerms(ASCIIToUTF16("mort"), base::string16::npos);
+  url_index_->HistoryItemsForTerms(ASCIIToUTF16("mort"),
+                                   base::string16::npos,
+                                   AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("mort"));
 
   // Simulate typing "reco" giving "mort reco" in the simulated omnibox.
   url_index_->HistoryItemsForTerms(ASCIIToUTF16("mort reco"),
-                                   base::string16::npos);
+                                   base::string16::npos,
+                                   AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("mort"));
   CheckTerm(cache, ASCIIToUTF16("reco"));
 
   // Simulate a <DELETE> by removing the 'reco' and adding back the 'rec'.
   url_index_->HistoryItemsForTerms(ASCIIToUTF16("mort rec"),
-                                   base::string16::npos);
+                                   base::string16::npos,
+                                   AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("mort"));
   CheckTerm(cache, ASCIIToUTF16("rec"));
 }
 
 TEST_F(InMemoryURLIndexTest, AddNewRows) {
   // Verify that the row we're going to add does not already exist.
   URLID new_row_id = 87654321;
   // Newly created URLRows get a last_visit time of 'right now' so it should
   // qualify as a quick result candidate.
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("brokeandalone"), base::string16::npos).empty());
+      ASCIIToUTF16("brokeandalone"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches).empty());
 
   // Add a new row.
   URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), new_row_id++);
   new_row.set_last_visit(base::Time::Now());
   EXPECT_TRUE(UpdateURL(new_row));
 
   // Verify that we can retrieve it.
   EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("brokeandalone"), base::string16::npos).size());
+      ASCIIToUTF16("brokeandalone"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches).size());
 
   // Add it again just to be sure that is harmless and that it does not update
   // the index.
   EXPECT_FALSE(UpdateURL(new_row));
   EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("brokeandalone"), base::string16::npos).size());
+      ASCIIToUTF16("brokeandalone"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches).size());
 
   // Make up an URL that does not qualify and try to add it.
   URLRow unqualified_row(GURL("http://www.brokeandaloneinmanitoba.com/"),
                          new_row_id++);
   EXPECT_FALSE(UpdateURL(new_row));
 }
 
 TEST_F(InMemoryURLIndexTest, DeleteRows) {
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("DrudgeReport"), base::string16::npos);
+      ASCIIToUTF16("DrudgeReport"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
 
   // Delete the URL then search again.
   EXPECT_TRUE(DeleteURL(matches[0].url_info.url()));
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("DrudgeReport"), base::string16::npos).empty());
+      ASCIIToUTF16("DrudgeReport"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches).empty());
 
   // Make up an URL that does not exist in the database and delete it.
   GURL url("http://www.hokeypokey.com/putyourrightfootin.html");
   EXPECT_FALSE(DeleteURL(url));
 }
 
 TEST_F(InMemoryURLIndexTest, ExpireRow) {
   ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("DrudgeReport"), base::string16::npos);
+      ASCIIToUTF16("DrudgeReport"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches);
   ASSERT_EQ(1U, matches.size());
 
   // Determine the row id for the result, remember that id, broadcast a
   // delete notification, then ensure that the row has been deleted.
   URLsDeletedDetails deleted_details;
   deleted_details.all_history = false;
   deleted_details.rows.push_back(matches[0].url_info);
   Observe(chrome::NOTIFICATION_HISTORY_URLS_DELETED,
           content::Source<InMemoryURLIndexTest>(this),
           content::Details<history::HistoryDetails>(&deleted_details));
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(
-      ASCIIToUTF16("DrudgeReport"), base::string16::npos).empty());
+      ASCIIToUTF16("DrudgeReport"),
+      base::string16::npos,
+      AutocompleteProvider::kMaxMatches).empty());
 }
 
 TEST_F(InMemoryURLIndexTest, WhitelistedURLs) {
   struct TestData {
     const std::string url_spec;
     const bool expected_is_whitelisted;
   } data[] = {
     // URLs with whitelisted schemes.
     { "about:histograms", true },
     { "chrome://settings", true },
@@ skipping 292 matching lines @@
   full_file_path.GetComponents(&actual_parts);
   ASSERT_EQ(expected_parts.size(), actual_parts.size());
   size_t count = expected_parts.size();
   for (size_t i = 0; i < count; ++i)
     EXPECT_EQ(expected_parts[i], actual_parts[i]);
   // Must clear the history_dir_ to satisfy the dtor's DCHECK.
   set_history_dir(base::FilePath());
 }
 
 }  // namespace history