Remove ScoreHistoryMatch::Builder

chrome/browser/autocomplete/url_index_private_data.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/url_index_private_data.h"
 
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_util.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/in_memory_url_index.h"
+#include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service.h"
 #include "net/base/net_util.h"
 
 #if defined(USE_SYSTEM_PROTOBUF)
 #include <google/protobuf/repeated_field.h>
 #else
 #include "third_party/protobuf/src/google/protobuf/repeated_field.h"
 #endif
 
 using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 using in_memory_url_index::InMemoryURLIndexCacheItem;
 
 namespace {
 static const size_t kMaxVisitsToStoreInCache = 10u;
-}  // anonymous namespace
+}
 
 typedef in_memory_url_index::InMemoryURLIndexCacheItem_WordListItem
     WordListItem;
 typedef in_memory_url_index::InMemoryURLIndexCacheItem_WordMapItem_WordMapEntry
     WordMapEntry;
 typedef in_memory_url_index::InMemoryURLIndexCacheItem_WordMapItem WordMapItem;
 typedef in_memory_url_index::InMemoryURLIndexCacheItem_CharWordMapItem
     CharWordMapItem;
 typedef in_memory_url_index::
     InMemoryURLIndexCacheItem_CharWordMapItem_CharWordMapEntry CharWordMapEntry;
@@ skipping 93 matching lines @@
       pre_filter_item_count_(0),
       post_filter_item_count_(0),
       post_scoring_item_count_(0) {
 }
 
 ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
     base::string16 search_string,
     size_t cursor_position,
     size_t max_matches,
     const std::string& languages,
-    const ScoredHistoryMatch::Builder& builder) {
+    bookmarks::BookmarkModel* bookmark_model) {
   // If cursor position is set and useful (not at either end of the
   // string), allow the search string to be broken at cursor position.
   // We do this by pretending there's a space where the cursor is.
   if ((cursor_position != base::string16::npos) &&
       (cursor_position < search_string.length()) &&
       (cursor_position > 0)) {
     search_string.insert(cursor_position, base::ASCIIToUTF16(" "));
   }
   pre_filter_item_count_ = 0;
   post_filter_item_count_ = 0;
@@ skipping 73 matching lines @@
     // for in the database allows some whitespace "words" whereas Tokenize
     // excludes a long list of whitespace.)  One could write a scoring
     // function that gives a reasonable order to matches when there
     // are no terms (i.e., all the words are some form of whitespace),
     // but this is such a rare edge case that it's not worth the time.
     return scored_items;
   }
   scored_items =
       std::for_each(
           history_id_set.begin(), history_id_set.end(),
-          AddHistoryMatch(*this, languages, lower_raw_string, lower_raw_terms,
-                          base::Time::Now(), builder)).ScoredMatches();
+          AddHistoryMatch(bookmark_model, *this, languages, lower_raw_string,
+                          lower_raw_terms, base::Time::Now())).ScoredMatches();
 
   // Select and sort only the top |max_matches| results.
   if (scored_items.size() > max_matches) {
     std::partial_sort(scored_items.begin(),
                       scored_items.begin() +
                           max_matches,
                       scored_items.end(),
                       ScoredHistoryMatch::MatchScoreGreater);
       scored_items.resize(max_matches);
   } else {
@@ skipping 986 matching lines @@
     const std::set<std::string>& whitelist) {
   return whitelist.find(gurl.scheme()) != whitelist.end();
 }
 
 
 // SearchTermCacheItem ---------------------------------------------------------
 
 URLIndexPrivateData::SearchTermCacheItem::SearchTermCacheItem(
     const WordIDSet& word_id_set,
     const HistoryIDSet& history_id_set)
-    : word_id_set_(word_id_set),
-      history_id_set_(history_id_set),
-      used_(true) {}
+    : word_id_set_(word_id_set), history_id_set_(history_id_set), used_(true) {
+}
 
-URLIndexPrivateData::SearchTermCacheItem::SearchTermCacheItem()
-    : used_(true) {}
+URLIndexPrivateData::SearchTermCacheItem::SearchTermCacheItem() : used_(true) {
+}
 
-URLIndexPrivateData::SearchTermCacheItem::~SearchTermCacheItem() {}
-
+URLIndexPrivateData::SearchTermCacheItem::~SearchTermCacheItem() {
+}
 
 // URLIndexPrivateData::AddHistoryMatch ----------------------------------------
 
 URLIndexPrivateData::AddHistoryMatch::AddHistoryMatch(
+    bookmarks::BookmarkModel* bookmark_model,
     const URLIndexPrivateData& private_data,
     const std::string& languages,
     const base::string16& lower_string,
     const String16Vector& lower_terms,
-    const base::Time now,
-    const ScoredHistoryMatch::Builder& builder)
-    : private_data_(private_data),
+    const base::Time now)
+    : bookmark_model_(bookmark_model),
+      private_data_(private_data),
       languages_(languages),
-      builder_(builder),
       lower_string_(lower_string),
       lower_terms_(lower_terms),
       now_(now) {
   // Calculate offsets for each term.  For instance, the offset for
   // ".net" should be 1, indicating that the actual word-part of the term
   // starts at offset 1.
   lower_terms_to_word_starts_offsets_.resize(lower_terms_.size(), 0u);
   for (size_t i = 0; i < lower_terms_.size(); ++i) {
     base::i18n::BreakIterator iter(lower_terms_[i],
                                    base::i18n::BreakIterator::BREAK_WORD);
     // If the iterator doesn't work, assume an offset of 0.
     if (!iter.Init())
       continue;
     // Find the first word start.
     while (iter.Advance() && !iter.IsWord()) {}
     if (iter.IsWord())
       lower_terms_to_word_starts_offsets_[i] = iter.prev();
     // Else: the iterator didn't find a word break.  Assume an offset of 0.
   }
 }
 
-URLIndexPrivateData::AddHistoryMatch::~AddHistoryMatch() {}
+URLIndexPrivateData::AddHistoryMatch::~AddHistoryMatch() {
+}
 
 void URLIndexPrivateData::AddHistoryMatch::operator()(
     const HistoryID history_id) {
   HistoryInfoMap::const_iterator hist_pos =
       private_data_.history_info_map_.find(history_id);
   if (hist_pos != private_data_.history_info_map_.end()) {
     const history::URLRow& hist_item = hist_pos->second.url_row;
     const VisitInfoVector& visits = hist_pos->second.visits;
     WordStartsMap::const_iterator starts_pos =
         private_data_.word_starts_map_.find(history_id);
     DCHECK(starts_pos != private_data_.word_starts_map_.end());
-    ScoredHistoryMatch match = builder_.Build(
+    ScoredHistoryMatch match(
         hist_item, visits, languages_, lower_string_, lower_terms_,
-        lower_terms_to_word_starts_offsets_, starts_pos->second, now_);
+        lower_terms_to_word_starts_offsets_, starts_pos->second,
+        bookmark_model_ && bookmark_model_->IsBookmarked(hist_item.url()),
+        now_);
     if (match.raw_score > 0)
       scored_matches_.push_back(match);
   }
 }
 
 
 // URLIndexPrivateData::HistoryItemFactorGreater -------------------------------
 
 URLIndexPrivateData::HistoryItemFactorGreater::HistoryItemFactorGreater(
     const HistoryInfoMap& history_info_map)
     : history_info_map_(history_info_map) {
 }
 
-URLIndexPrivateData::HistoryItemFactorGreater::~HistoryItemFactorGreater() {}
+URLIndexPrivateData::HistoryItemFactorGreater::~HistoryItemFactorGreater() {
+}
 
 bool URLIndexPrivateData::HistoryItemFactorGreater::operator()(
     const HistoryID h1,
     const HistoryID h2) {
   HistoryInfoMap::const_iterator entry1(history_info_map_.find(h1));
   if (entry1 == history_info_map_.end())
     return false;
   HistoryInfoMap::const_iterator entry2(history_info_map_.find(h2));
   if (entry2 == history_info_map_.end())
     return true;
   const history::URLRow& r1(entry1->second.url_row);
   const history::URLRow& r2(entry2->second.url_row);
   // First cut: typed count, visit count, recency.
   // TODO(mrossetti): This is too simplistic. Consider an approach which ranks
   // recently visited (within the last 12/24 hours) as highly important. Get
   // input from mpearson.
   if (r1.typed_count() != r2.typed_count())
     return (r1.typed_count() > r2.typed_count());
   if (r1.visit_count() != r2.visit_count())
     return (r1.visit_count() > r2.visit_count());
   return (r1.last_visit() > r2.last_visit());
 }