HQP Refactoring (in Preparation for SQLite Cache)

chrome/browser/history/in_memory_url_index_unittest.cc

 // Copyright (c) 2011 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 <fstream>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string16.h"
@@ skipping 121 matching lines @@
   URLRow row(GURL(url), 0);
   row.set_title(UTF8ToUTF16(title));
   row.set_visit_count(visit_count);
   row.set_typed_count(typed_count);
   row.set_last_visit(base::Time::NowFromSystemTime() -
                      base::TimeDelta::FromDays(last_visit_ago));
   return row;
 }
 
 String16Vector InMemoryURLIndexTest::Make1Term(const char* term) const {
-  String16Vector original_terms;
-  original_terms.push_back(UTF8ToUTF16(term));
-  return original_terms;
+  String16Vector terms;
+  terms.push_back(UTF8ToUTF16(term));
+  return terms;
 }
 
 String16Vector InMemoryURLIndexTest::Make2Terms(const char* term_1,
                                                 const char* term_2) const {
-  String16Vector original_terms;
-  original_terms.push_back(UTF8ToUTF16(term_1));
-  original_terms.push_back(UTF8ToUTF16(term_2));
-  return original_terms;
+  String16Vector terms;
+  terms.push_back(UTF8ToUTF16(term_1));
+  terms.push_back(UTF8ToUTF16(term_2));
+  return terms;
 }
 
 void InMemoryURLIndexTest::CheckTerm(
     const InMemoryURLIndex::SearchTermCacheMap& cache,
     string16 term) const {
   InMemoryURLIndex::SearchTermCacheMap::const_iterator cache_iter(
       cache.find(term));
   ASSERT_NE(cache.end(), cache_iter)
       << "Cache does not contain '" << term << "' but should.";
   InMemoryURLIndex::SearchTermCacheItem cache_item = cache_iter->second;
@@ skipping 45 matching lines @@
   const size_t kMaxLen = arraysize(url_format) + 5;
   char url_string[kMaxLen + 1];
   for (int i = 0; i < 600; ++i) {
     base::snprintf(url_string, kMaxLen, url_format, i);
     URLRow row(MakeURLRow(url_string, "Google Search", 20, 0, 20));
     AddURL(row);
   }
 }
 
 TEST_F(InMemoryURLIndexTest, Construction) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   EXPECT_TRUE(url_index_.get());
 }
 
 TEST_F(LimitedInMemoryURLIndexTest, Initialization) {
   // Verify that the database contains the expected number of items, which
   // is the pre-filtered count, i.e. all of the items.
   sql::Statement statement(GetDB().GetUniqueStatement("SELECT * FROM urls;"));
   EXPECT_TRUE(statement);
   uint64 row_count = 0;
   while (statement.Step()) ++row_count;
   EXPECT_EQ(1U, row_count);
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
   URLIndexPrivateData& private_data(*(url_index_->private_data_));
 
   // 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) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
   // The term will be lowercased by the search.
 
   // See if a very specific term gives a single result.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(Make1Term("DrudgeReport"));
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   EXPECT_EQ(5, matches[0].url_info.id());
@@ skipping 12 matching lines @@
   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());
 
   // Search which should result in very poor result.
-  String16Vector original_terms;
-  original_terms.push_back(ASCIIToUTF16("z"));
-  original_terms.push_back(ASCIIToUTF16("y"));
-  original_terms.push_back(ASCIIToUTF16("x"));
-  matches = url_index_->HistoryItemsForTerms(original_terms);
+  String16Vector terms;
+  terms.push_back(ASCIIToUTF16("z"));
+  terms.push_back(ASCIIToUTF16("y"));
+  terms.push_back(ASCIIToUTF16("x"));
+  matches = url_index_->HistoryItemsForTerms(terms);
   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());
 
   // Search which will match at the end of an URL with encoded characters.
   matches = url_index_->HistoryItemsForTerms(Make1Term("ice"));
   ASSERT_EQ(1U, matches.size());
 }
 
 TEST_F(ExpandedInMemoryURLIndexTest, ShortCircuit) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
 
   // A search for 'w' should short-circuit and not return any matches.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(Make1Term("w"));
   EXPECT_TRUE(matches.empty());
 
   // A search for 'working' should not short-circuit.
   matches = url_index_->HistoryItemsForTerms(Make1Term("working"));
   EXPECT_EQ(1U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, TitleSearch) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
   // Signal if someone has changed the test DB.
   EXPECT_EQ(27U, url_index_->private_data_->history_info_map_.size());
-  String16Vector original_terms;
+  String16Vector terms;
 
   // Ensure title is being searched.
-  original_terms.push_back(ASCIIToUTF16("MORTGAGE"));
-  original_terms.push_back(ASCIIToUTF16("RATE"));
-  original_terms.push_back(ASCIIToUTF16("DROPS"));
-  ScoredHistoryMatches matches =
-      url_index_->HistoryItemsForTerms(original_terms);
+  terms.push_back(ASCIIToUTF16("MORTGAGE"));
+  terms.push_back(ASCIIToUTF16("RATE"));
+  terms.push_back(ASCIIToUTF16("DROPS"));
+  ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(terms);
   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) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
 
   // Verify current title terms retrieves desired item.
   String16Vector original_terms;
   original_terms.push_back(ASCIIToUTF16("lebronomics"));
   original_terms.push_back(ASCIIToUTF16("could"));
   original_terms.push_back(ASCIIToUTF16("high"));
   original_terms.push_back(ASCIIToUTF16("taxes"));
   original_terms.push_back(ASCIIToUTF16("influence"));
   ScoredHistoryMatches matches =
@@ skipping 16 matching lines @@
   new_terms.push_back(ASCIIToUTF16("eat"));
   new_terms.push_back(ASCIIToUTF16("oats"));
   new_terms.push_back(ASCIIToUTF16("little"));
   new_terms.push_back(ASCIIToUTF16("lambs"));
   new_terms.push_back(ASCIIToUTF16("ivy"));
   matches = url_index_->HistoryItemsForTerms(new_terms);
   ASSERT_EQ(0U, matches.size());
 
   // Update the row.
   old_row.set_title(ASCIIToUTF16("Does eat oats and little lambs eat ivy"));
-  url_index_->UpdateURL(expected_id, old_row);
+  url_index_->UpdateURL(old_row);
 
   // Verify we get the row using the new terms but not the original terms.
   matches = url_index_->HistoryItemsForTerms(new_terms);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(expected_id, matches[0].url_info.id());
   matches = url_index_->HistoryItemsForTerms(original_terms);
   ASSERT_EQ(0U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, NonUniqueTermCharacterSets) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
 
   // The presence of duplicate characters should succeed. Exercise by cycling
   // through a string with several duplicate characters.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(Make1Term("ABRA"));
   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());
@@ skipping 15 matching lines @@
   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.
   typedef InMemoryURLIndex::SearchTermCacheMap::iterator CacheIter;
   typedef InMemoryURLIndex::SearchTermCacheItem CacheItem;
 
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
 
   InMemoryURLIndex::SearchTermCacheMap& cache(url_index_->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.
-  String16Vector original_terms;
+  String16Vector terms;
   string16 term_r = ASCIIToUTF16("r");
-  original_terms.push_back(term_r);
-  url_index_->HistoryItemsForTerms(original_terms);
+  terms.push_back(term_r);
+  url_index_->HistoryItemsForTerms(terms);
   EXPECT_EQ(0U, cache.size());
 
   // Simulate typing "re" giving "r re" in the simulated omnibox.
   string16 term_re = ASCIIToUTF16("re");
-  original_terms.push_back(term_re);
+  terms.push_back(term_re);
   // 're' should be cached at this point but not 'r' as it is a single
   // character.
-  ASSERT_EQ(2U, original_terms.size());
-  url_index_->HistoryItemsForTerms(original_terms);
+  ASSERT_EQ(2U, terms.size());
+  url_index_->HistoryItemsForTerms(terms);
   ASSERT_EQ(1U, cache.size());
   CheckTerm(cache, term_re);
 
   // Simulate typing "reco" giving "r re reco" in the simulated omnibox.
   string16 term_reco = ASCIIToUTF16("reco");
-  original_terms.push_back(term_reco);
+  terms.push_back(term_reco);
   // 're' and 'reco' should be cached at this point but not 'r' as it is a
   // single character.
-  url_index_->HistoryItemsForTerms(original_terms);
+  url_index_->HistoryItemsForTerms(terms);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, term_re);
   CheckTerm(cache, term_reco);
 
-  original_terms.clear();  // Simulate pressing <ESC>.
+  terms.clear();  // Simulate pressing <ESC>.
 
   // Simulate typing "mort".
   string16 term_mort = ASCIIToUTF16("mort");
-  original_terms.push_back(term_mort);
+  terms.push_back(term_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(original_terms);
+  url_index_->HistoryItemsForTerms(terms);
   ASSERT_EQ(1U, cache.size());
   CheckTerm(cache, term_mort);
 
   // Simulate typing "reco" giving "mort reco" in the simulated omnibox.
-  original_terms.push_back(term_reco);
-  url_index_->HistoryItemsForTerms(original_terms);
+  terms.push_back(term_reco);
+  url_index_->HistoryItemsForTerms(terms);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, term_mort);
   CheckTerm(cache, term_reco);
 
   // Simulate a <DELETE> by removing the 'reco' and adding back the 'rec'.
-  original_terms.resize(original_terms.size() - 1);
+  terms.resize(terms.size() - 1);
   string16 term_rec = ASCIIToUTF16("rec");
-  original_terms.push_back(term_rec);
-  url_index_->HistoryItemsForTerms(original_terms);
+  terms.push_back(term_rec);
+  url_index_->HistoryItemsForTerms(terms);
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, term_mort);
   CheckTerm(cache, term_rec);
 }
 
 TEST_F(InMemoryURLIndexTest, Scoring) {
   URLRow row_a(MakeURLRow("http://abcdef", "fedcba", 3, 30, 1));
   // Test scores based on position.
   ScoredHistoryMatch scored_a(
       InMemoryURLIndex::ScoredMatchForURL(row_a, Make1Term("abc")));
@@ skipping 21 matching lines @@
       InMemoryURLIndex::ScoredMatchForURL(row_c, Make1Term("abc")));
   EXPECT_GT(scored_g.raw_score, scored_a.raw_score);
   // Test scores based on typed_count.
   URLRow row_d(MakeURLRow("http://abcdef", "fedcba", 3, 30, 10));
   ScoredHistoryMatch scored_h(
       InMemoryURLIndex::ScoredMatchForURL(row_d, Make1Term("abc")));
   EXPECT_GT(scored_h.raw_score, scored_a.raw_score);
 }
 
 TEST_F(InMemoryURLIndexTest, AddNewRows) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
-  String16Vector original_terms;
+  String16Vector terms;
 
   // 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.
-  original_terms.push_back(ASCIIToUTF16("brokeandalone"));
-  EXPECT_TRUE(url_index_->HistoryItemsForTerms(original_terms).empty());
+  terms.push_back(ASCIIToUTF16("brokeandalone"));
+  EXPECT_TRUE(url_index_->HistoryItemsForTerms(terms).empty());
 
   // Add a new row.
   URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), new_row_id);
   new_row.set_last_visit(base::Time::Now());
-  url_index_->UpdateURL(new_row_id, new_row);
+  url_index_->UpdateURL(new_row);
 
   // Verify that we can retrieve it.
-  EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(original_terms).size());
+  EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(terms).size());
 
   // Add it again just to be sure that is harmless.
-  url_index_->UpdateURL(new_row_id, new_row);
-  EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(original_terms).size());
+  url_index_->UpdateURL(new_row);
+  EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(terms).size());
 }
 
 TEST_F(InMemoryURLIndexTest, DeleteRows) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   url_index_->Init(this, "en,ja,hi,zh");
-  String16Vector original_terms;
+  String16Vector terms;
 
   // Make sure we actually get an existing result.
-  original_terms.push_back(ASCIIToUTF16("DrudgeReport"));
-  ScoredHistoryMatches matches =
-      url_index_->HistoryItemsForTerms(original_terms);
+  terms.push_back(ASCIIToUTF16("DrudgeReport"));
+  ScoredHistoryMatches matches = url_index_->HistoryItemsForTerms(terms);
   ASSERT_EQ(1U, matches.size());
 
   // Determine the row id for that result, delete that id, then search again.
-  url_index_->DeleteURL(matches[0].url_info.id());
-  EXPECT_TRUE(url_index_->HistoryItemsForTerms(original_terms).empty());
+  url_index_->DeleteURL(matches[0].url_info);
+  EXPECT_TRUE(url_index_->HistoryItemsForTerms(terms).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 55 matching lines @@
     { "telnet://mayor_margie:one2rule4All@www.mycity.com:6789/", false },
     { "tftp://example.com/mystartupfile", false },
     { "tip://123.123.123.123/?urn:xopen:xid", false },
     { "tv:nbc.com", false },
     { "urn:foo:A123,456", false },
     { "vemmi://zeus.mctel.fr/demo", false },
     { "wais://www.mydomain.net:8765/mydatabase", false },
     { "xmpp:node@example.com", false },
     { "xmpp://guest@example.com", false },
   };
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     GURL url(data[i].url_spec);
     EXPECT_EQ(data[i].expected_is_whitelisted,
               url_index_->URLSchemeIsWhitelisted(url));
   }
 }
 
 TEST_F(InMemoryURLIndexTest, CacheFilePath) {
-  url_index_.reset(new InMemoryURLIndex(FilePath(FILE_PATH_LITERAL(
-      "/flammmy/frammy/"))));
+  url_index_.reset(new InMemoryURLIndex(
+      NULL, FilePath(FILE_PATH_LITERAL("/flammmy/frammy/"))));
   FilePath full_file_path;
   url_index_->GetCacheFilePath(&full_file_path);
   std::vector<FilePath::StringType> expected_parts;
   FilePath(FILE_PATH_LITERAL("/flammmy/frammy/History Provider Cache")).
       GetComponents(&expected_parts);
   std::vector<FilePath::StringType> actual_parts;
   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.
   url_index_->history_dir_.clear();
 }
 
 TEST_F(InMemoryURLIndexTest, CacheSaveRestore) {
   // Save the cache to a protobuf, restore it, and compare the results.
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_.reset(new InMemoryURLIndex(NULL, FilePath()));
   InMemoryURLIndex& url_index(*(url_index_.get()));
   url_index.Init(this, "en,ja,hi,zh");
   in_memory_url_index::InMemoryURLIndexCacheItem index_cache;
   url_index.SavePrivateData(&index_cache);
 
   // Capture our private data so we can later compare for equality.
   URLIndexPrivateData& private_data(*(url_index_->private_data_));
   String16Vector word_list(private_data.word_list_);
   WordMap word_map(private_data.word_map_);
   CharWordIDMap char_word_map(private_data.char_word_map_);
@@ skipping 54 matching lines @@
     const URLRow& expected_row(expected->second);
     const URLRow& actual_row(actual->second);
     EXPECT_EQ(expected_row.visit_count(), actual_row.visit_count());
     EXPECT_EQ(expected_row.typed_count(), actual_row.typed_count());
     EXPECT_EQ(expected_row.last_visit(), actual_row.last_visit());
     EXPECT_EQ(expected_row.url(), actual_row.url());
   }
 }
 
 }  // namespace history