Move ScoredHistoryMatch into Its Own Set of Files

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/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 87 matching lines @@
   InMemoryURLIndexTest();
 
  protected:
   // Test setup.
   virtual void SetUp();
 
   // Allows the database containing the test data to be customized by
   // subclasses.
   virtual FilePath::StringType TestDBName() const;
 
+#if 0
   // Convenience function to create a URLRow with basic data for |url|, |title|,
   // |visit_count|, and |typed_count|. |last_visit_ago| gives the number of
   // days from now to set the URL's last_visit.
   URLRow MakeURLRow(const char* url,
                     const char* title,
                     int visit_count,
                     int last_visit_ago,
                     int typed_count);
 
   // Convenience functions for easily creating vectors of search terms.
   String16Vector Make1Term(const char* term) const;
   String16Vector Make2Terms(const char* term_1, const char* term_2) const;
 
   // Convenience function for GetTopicalityScore() that builds the
   // term match and word break information automatically that are needed
   // to call GetTopicalityScore().  It only works for scoring a single term,
   // not multiple terms.
   float GetTopicalityScoreOfTermAgainstURLAndTitle(const string16& term,
                                                    const string16& url,
                                                    const string16& title);
+#endif
 
   // Validates that the given |term| is contained in |cache| and that it is
   // marked as in-use.
   void CheckTerm(const URLIndexPrivateData::SearchTermCacheMap& cache,
                  string16 term) const;
 
   // Pass-through function to simplify our friendship with HistoryService.
   sql::Connection& GetDB();
 
   // Pass-through functions to simplify our friendship with InMemoryURLIndex.
@@ skipping 153 matching lines @@
   url_index_.reset(
       new InMemoryURLIndex(&profile_, FilePath(), "en,ja,hi,zh"));
   url_index_->Init();
   url_index_->RebuildFromHistory(history_database_);
 }
 
 FilePath::StringType InMemoryURLIndexTest::TestDBName() const {
     return FILE_PATH_LITERAL("url_history_provider_test.db.txt");
 }
 
+#if 0
 URLRow InMemoryURLIndexTest::MakeURLRow(const char* url,
                   const char* title,
                   int visit_count,
                   int last_visit_ago,
                   int typed_count) {
   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() -
@@ skipping 17 matching lines @@
 
 float InMemoryURLIndexTest::GetTopicalityScoreOfTermAgainstURLAndTitle(
     const string16& term,
     const string16& url,
     const string16& title) {
   TermMatches url_matches = MatchTermInString(term, url, 0);
   TermMatches title_matches = MatchTermInString(term, title, 0);
   RowWordStarts word_starts;
   String16SetFromString16(url, &word_starts.url_word_starts_);
   String16SetFromString16(title, &word_starts.title_word_starts_);
-  return GetPrivateData()->GetTopicalityScore(
+  return ScoredHistoryMatch::GetTopicalityScore(
       1, url, url_matches, title_matches, word_starts);
 }
+#endif
 
 void InMemoryURLIndexTest::CheckTerm(
     const URLIndexPrivateData::SearchTermCacheMap& cache,
     string16 term) const {
   URLIndexPrivateData::SearchTermCacheMap::const_iterator cache_iter(
       cache.find(term));
   ASSERT_TRUE(cache.end() != cache_iter)
       << "Cache does not contain '" << term << "' but should.";
   URLIndexPrivateData::SearchTermCacheItem cache_item = cache_iter->second;
   EXPECT_TRUE(cache_item.used_)
@@ skipping 431 matching lines @@
   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"));
   ASSERT_EQ(2U, cache.size());
   CheckTerm(cache, ASCIIToUTF16("mort"));
   CheckTerm(cache, ASCIIToUTF16("rec"));
 }
 
+#if 0
 TEST_F(InMemoryURLIndexTest, Scoring) {
   URLRow row_a(MakeURLRow("http://abcdef", "fedcba", 3, 30, 1));
-  URLIndexPrivateData& private_data(*GetPrivateData());
   // We use NowFromSystemTime() because MakeURLRow uses the same function
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
   RowWordStarts word_starts;
   // Test scores based on position.
   // TODO(mpearson): Test new_scoring if we're actually going to turn it
   // on by default.  This requires setting word_starts, which isn't done
   // right now.
-  ScoredHistoryMatch scored_a(private_data.ScoredMatchForURL(
-      row_a, ASCIIToUTF16("abc"), Make1Term("abc"), word_starts, now));
-  ScoredHistoryMatch scored_b(private_data.ScoredMatchForURL(
-      row_a, ASCIIToUTF16("bcd"), Make1Term("bcd"), word_starts, now));
+  ScoredHistoryMatch scored_a(row_a, ASCIIToUTF16("abc"), Make1Term("abc"),
+                              word_starts, now);
+  ScoredHistoryMatch scored_b(row_a, ASCIIToUTF16("bcd"), Make1Term("bcd"),
+                              word_starts, now);
   EXPECT_GT(scored_a.raw_score, scored_b.raw_score);
   // Test scores based on length.
-  ScoredHistoryMatch scored_c(private_data.ScoredMatchForURL(
-      row_a, ASCIIToUTF16("abcd"), Make1Term("abcd"), word_starts, now));
+  ScoredHistoryMatch scored_c(row_a, ASCIIToUTF16("abcd"), Make1Term("abcd"),
+                              word_starts, now);
   EXPECT_LT(scored_a.raw_score, scored_c.raw_score);
   // Test scores based on order.
-  ScoredHistoryMatch scored_d(private_data.ScoredMatchForURL(
-      row_a, ASCIIToUTF16("abcdef"), Make2Terms("abc", "def"), word_starts,
-      now));
-  ScoredHistoryMatch scored_e(private_data.ScoredMatchForURL(
-      row_a, ASCIIToUTF16("def abc"), Make2Terms("def", "abc"), word_starts,
-      now));
+  ScoredHistoryMatch scored_d(row_a, ASCIIToUTF16("abcdef"),
+                              Make2Terms("abc", "def"), word_starts, now);
+  ScoredHistoryMatch scored_e(row_a, ASCIIToUTF16("def abc"),
+                              Make2Terms("def", "abc"), word_starts, now);
   EXPECT_GT(scored_d.raw_score, scored_e.raw_score);
   // Test scores based on visit_count.
   URLRow row_b(MakeURLRow("http://abcdef", "fedcba", 10, 30, 1));
-  ScoredHistoryMatch scored_f(private_data.ScoredMatchForURL(
-      row_b, ASCIIToUTF16("abc"), Make1Term("abc"), word_starts, now));
+  ScoredHistoryMatch scored_f(row_b, ASCIIToUTF16("abc"), Make1Term("abc"),
+                              word_starts, now);
   EXPECT_GT(scored_f.raw_score, scored_a.raw_score);
   // Test scores based on last_visit.
   URLRow row_c(MakeURLRow("http://abcdef", "fedcba", 3, 10, 1));
-  ScoredHistoryMatch scored_g(private_data.ScoredMatchForURL(
-      row_c, ASCIIToUTF16("abc"), Make1Term("abc"), word_starts, now));
+  ScoredHistoryMatch scored_g(row_c, ASCIIToUTF16("abc"), Make1Term("abc"),
+                              word_starts, now);
   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(private_data.ScoredMatchForURL(
-      row_d, ASCIIToUTF16("abc"), Make1Term("abc"), word_starts, now));
+  ScoredHistoryMatch scored_h(row_d, ASCIIToUTF16("abc"), Make1Term("abc"),
+                              word_starts, now);
   EXPECT_GT(scored_h.raw_score, scored_a.raw_score);
   // Test scores based on a terms appearing multiple times.
   URLRow row_i(MakeURLRow("http://csi.csi.csi/csi_csi",
       "CSI Guide to CSI Las Vegas, CSI New York, CSI Provo", 3, 30, 10));
-  ScoredHistoryMatch scored_i(private_data.ScoredMatchForURL(
-      row_i, ASCIIToUTF16("csi"), Make1Term("csi"), word_starts, now));
+  ScoredHistoryMatch scored_i(row_i, ASCIIToUTF16("csi"), Make1Term("csi"),
+                              word_starts, now);
   EXPECT_LT(scored_i.raw_score, 1400);
 }
 
 TEST_F(InMemoryURLIndexTest, GetTopicalityScoreTrailingSlash) {
   const float hostname = GetTopicalityScoreOfTermAgainstURLAndTitle(
       ASCIIToUTF16("def"),
       ASCIIToUTF16("http://abc.def.com/"),
       ASCIIToUTF16("Non-Matching Title"));
   const float hostname_no_slash = GetTopicalityScoreOfTermAgainstURLAndTitle(
       ASCIIToUTF16("def"),
@@ skipping 54 matching lines @@
   EXPECT_GT(arg_score, hostname_mid_word_score);
   EXPECT_GT(title_mid_word_score, arg_mid_word_score);
   // Finally, verify that protocol matches score worse than everything
   // (except possibly mid-word matches in the ?arg section of the URL--I
   // can imagine scoring those pretty harshly as well).
   EXPECT_GT(path_mid_word_score, protocol_score);
   EXPECT_GT(path_mid_word_score, protocol_mid_word_score);
   EXPECT_GT(title_mid_word_score, protocol_score);
   EXPECT_GT(title_mid_word_score, protocol_mid_word_score);
 }
+#endif
 
 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")).empty());
 
   // Add a new row.
@@ skipping 226 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(FilePath());
 }
 
 }  // namespace history