Move InMemoryURLIndex outside of history namespace

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>
@@ skipping 22 matching lines @@
 #endif
 
 using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 using in_memory_url_index::InMemoryURLIndexCacheItem;
 
 namespace {
 static const size_t kMaxVisitsToStoreInCache = 10u;
 }  // anonymous namespace
 
-namespace history {
-
-typedef imui::InMemoryURLIndexCacheItem_WordListItem WordListItem;
-typedef imui::InMemoryURLIndexCacheItem_WordMapItem_WordMapEntry WordMapEntry;
-typedef imui::InMemoryURLIndexCacheItem_WordMapItem WordMapItem;
-typedef imui::InMemoryURLIndexCacheItem_CharWordMapItem CharWordMapItem;
-typedef imui::InMemoryURLIndexCacheItem_CharWordMapItem_CharWordMapEntry
-    CharWordMapEntry;
-typedef imui::InMemoryURLIndexCacheItem_WordIDHistoryMapItem
+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;
+typedef in_memory_url_index::InMemoryURLIndexCacheItem_WordIDHistoryMapItem
     WordIDHistoryMapItem;
-typedef imui::
+typedef in_memory_url_index::
     InMemoryURLIndexCacheItem_WordIDHistoryMapItem_WordIDHistoryMapEntry
-    WordIDHistoryMapEntry;
-typedef imui::InMemoryURLIndexCacheItem_HistoryInfoMapItem HistoryInfoMapItem;
-typedef imui::InMemoryURLIndexCacheItem_HistoryInfoMapItem_HistoryInfoMapEntry
-    HistoryInfoMapEntry;
-typedef imui::
+        WordIDHistoryMapEntry;
+typedef in_memory_url_index::InMemoryURLIndexCacheItem_HistoryInfoMapItem
+    HistoryInfoMapItem;
+typedef in_memory_url_index::
+    InMemoryURLIndexCacheItem_HistoryInfoMapItem_HistoryInfoMapEntry
+        HistoryInfoMapEntry;
+typedef in_memory_url_index::
     InMemoryURLIndexCacheItem_HistoryInfoMapItem_HistoryInfoMapEntry_VisitInfo
-    HistoryInfoMapEntry_VisitInfo;
-typedef imui::InMemoryURLIndexCacheItem_WordStartsMapItem WordStartsMapItem;
-typedef imui::InMemoryURLIndexCacheItem_WordStartsMapItem_WordStartsMapEntry
-    WordStartsMapEntry;
-
+        HistoryInfoMapEntry_VisitInfo;
+typedef in_memory_url_index::InMemoryURLIndexCacheItem_WordStartsMapItem
+    WordStartsMapItem;
+typedef in_memory_url_index::
+    InMemoryURLIndexCacheItem_WordStartsMapItem_WordStartsMapEntry
+        WordStartsMapEntry;
 
 // Algorithm Functions ---------------------------------------------------------
 
 // Comparison function for sorting search terms by descending length.
 bool LengthGreater(const base::string16& string_a,
                    const base::string16& string_b) {
   return string_a.length() > string_b.length();
 }
 
 
 // UpdateRecentVisitsFromHistoryDBTask -----------------------------------------
 
 // HistoryDBTask used to update the recent visit data for a particular
 // row from the history database.
-class UpdateRecentVisitsFromHistoryDBTask : public HistoryDBTask {
+class UpdateRecentVisitsFromHistoryDBTask : public history::HistoryDBTask {
  public:
   explicit UpdateRecentVisitsFromHistoryDBTask(
       URLIndexPrivateData* private_data,
-      URLID url_id);
+      history::URLID url_id);
 
-  bool RunOnDBThread(HistoryBackend* backend,
+  bool RunOnDBThread(history::HistoryBackend* backend,
                      history::HistoryDatabase* db) override;
   void DoneRunOnMainThread() override;
 
  private:
   ~UpdateRecentVisitsFromHistoryDBTask() override;
 
   // The URLIndexPrivateData that gets updated after the historyDB
   // task returns.
   URLIndexPrivateData* private_data_;
   // The ID of the URL to get visits for and then update.
-  URLID url_id_;
+  history::URLID url_id_;
   // Whether fetching the recent visits for the URL succeeded.
   bool succeeded_;
   // The awaited data that's shown to private_data_ for it to copy and
   // store.
-  VisitVector recent_visits_;
+  history::VisitVector recent_visits_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateRecentVisitsFromHistoryDBTask);
 };
 
 UpdateRecentVisitsFromHistoryDBTask::UpdateRecentVisitsFromHistoryDBTask(
     URLIndexPrivateData* private_data,
-    URLID url_id)
-    : private_data_(private_data),
-      url_id_(url_id),
-      succeeded_(false) {
+    history::URLID url_id)
+    : private_data_(private_data), url_id_(url_id), succeeded_(false) {
 }
 
 bool UpdateRecentVisitsFromHistoryDBTask::RunOnDBThread(
-    HistoryBackend* backend,
-    HistoryDatabase* db) {
+    history::HistoryBackend* backend,
+    history::HistoryDatabase* db) {
   // Make sure the private data is going to get as many recent visits as
   // ScoredHistoryMatch::GetFrequency() hopes to use.
   DCHECK_GE(kMaxVisitsToStoreInCache, ScoredHistoryMatch::kMaxVisitsToScore);
   succeeded_ = db->GetMostRecentVisitsForURL(url_id_,
                                              kMaxVisitsToStoreInCache,
                                              &recent_visits_);
   if (!succeeded_)
     recent_visits_.clear();
   return true;  // Always claim to be done; do not retry failures.
 }
@@ skipping 15 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 history::ScoredHistoryMatch::Builder& builder) {
+    const ScoredHistoryMatch::Builder& builder) {
   // 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;
   post_scoring_item_count_ = 0;
   // The search string we receive may contain escaped characters. For reducing
   // the index we need individual, lower-cased words, ignoring escapings. For
   // the final filtering we need whitespace separated substrings possibly
   // containing escaped characters.
   base::string16 lower_raw_string(base::i18n::ToLower(search_string));
   base::string16 lower_unescaped_string =
       net::UnescapeURLComponent(lower_raw_string,
           net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
   // Extract individual 'words' (as opposed to 'terms'; see below) from the
   // search string. When the user types "colspec=ID%20Mstone Release" we get
   // four 'words': "colspec", "id", "mstone" and "release".
   String16Vector lower_words(
-      history::String16VectorFromString16(lower_unescaped_string, false, NULL));
+      String16VectorFromString16(lower_unescaped_string, false, NULL));
   ScoredHistoryMatches scored_items;
 
   // Do nothing if we have indexed no words (probably because we've not been
   // initialized yet) or the search string has no words.
   if (word_list_.empty() || lower_words.empty()) {
     search_term_cache_.clear();  // Invalidate the term cache.
     return scored_items;
   }
 
   // Reset used_ flags for search_term_cache_. We use a basic mark-and-sweep
@@ skipping 34 matching lines @@
   // substring match, inserting those which pass in order by score. Note that
   // in this step we are using the raw search string complete with escaped
   // URL elements. When the user has specifically typed something akin to
   // "sort=pri&colspec=ID%20Mstone%20Release" we want to make sure that that
   // specific substring appears in the URL or page title.
 
   // We call these 'terms' (as opposed to 'words'; see above) as in this case
   // we only want to break up the search string on 'true' whitespace rather than
   // escaped whitespace. When the user types "colspec=ID%20Mstone Release" we
   // get two 'terms': "colspec=id%20mstone" and "release".
-  history::String16Vector lower_raw_terms;
+  String16Vector lower_raw_terms;
   if (Tokenize(lower_raw_string, base::kWhitespaceUTF16,
                &lower_raw_terms) == 0) {
     // Don't score matches when there are no terms to score against.  (It's
     // possible that the word break iterater that extracts words to search
     // 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;
@@ skipping 29 matching lines @@
       else
         ++cache_iter;
     }
   }
 
   return scored_items;
 }
 
 bool URLIndexPrivateData::UpdateURL(
     HistoryService* history_service,
-    const URLRow& row,
+    const history::URLRow& row,
     const std::string& languages,
     const std::set<std::string>& scheme_whitelist,
     base::CancelableTaskTracker* tracker) {
   // The row may or may not already be in our index. If it is not already
   // indexed and it qualifies then it gets indexed. If it is already
   // indexed and still qualifies then it gets updated, otherwise it
   // is deleted from the index.
   bool row_was_updated = false;
-  URLID row_id = row.id();
+  history::URLID row_id = row.id();
   HistoryInfoMap::iterator row_pos = history_info_map_.find(row_id);
   if (row_pos == history_info_map_.end()) {
     // This new row should be indexed if it qualifies.
-    URLRow new_row(row);
+    history::URLRow new_row(row);
     new_row.set_id(row_id);
     row_was_updated = RowQualifiesAsSignificant(new_row, base::Time()) &&
                       IndexRow(NULL,
                                history_service,
                                new_row,
                                languages,
                                scheme_whitelist,
                                tracker);
   } else if (RowQualifiesAsSignificant(row, base::Time())) {
     // This indexed row still qualifies and will be re-indexed.
     // The url won't have changed but the title, visit count, etc.
     // might have changed.
-    URLRow& row_to_update = row_pos->second.url_row;
+    history::URLRow& row_to_update = row_pos->second.url_row;
     bool title_updated = row_to_update.title() != row.title();
     if (row_to_update.visit_count() != row.visit_count() ||
         row_to_update.typed_count() != row.typed_count() ||
         row_to_update.last_visit() != row.last_visit() || title_updated) {
       row_to_update.set_visit_count(row.visit_count());
       row_to_update.set_typed_count(row.typed_count());
       row_to_update.set_last_visit(row.last_visit());
       // If something appears to have changed, update the recent visits
       // information.
       ScheduleUpdateRecentVisits(history_service, row_id, tracker);
@@ skipping 15 matching lines @@
     // clearing all words associated with this row.
     RemoveRowFromIndex(row);
     row_was_updated = true;
   }
   if (row_was_updated)
     search_term_cache_.clear();  // This invalidates the cache.
   return row_was_updated;
 }
 
 void URLIndexPrivateData::UpdateRecentVisits(
-    URLID url_id,
-    const VisitVector& recent_visits) {
+    history::URLID url_id,
+    const history::VisitVector& recent_visits) {
   HistoryInfoMap::iterator row_pos = history_info_map_.find(url_id);
   if (row_pos != history_info_map_.end()) {
     VisitInfoVector* visits = &row_pos->second.visits;
     visits->clear();
     const size_t size =
         std::min(recent_visits.size(), kMaxVisitsToStoreInCache);
     visits->reserve(size);
     for (size_t i = 0; i < size; i++) {
-      // Copy from the VisitVector the only fields visits needs.
+      // Copy from the history::VisitVector the only fields visits needs.
       visits->push_back(std::make_pair(recent_visits[i].visit_time,
                                        recent_visits[i].transition));
     }
   }
   // Else: Oddly, the URL doesn't seem to exist in the private index.
   // Ignore this update.  This can happen if, for instance, the user
   // removes the URL from URLIndexPrivateData before the historyDB call
   // returns.
 }
 
 void URLIndexPrivateData::ScheduleUpdateRecentVisits(
     HistoryService* history_service,
-    URLID url_id,
+    history::URLID url_id,
     base::CancelableTaskTracker* tracker) {
   history_service->ScheduleDBTask(
       scoped_ptr<history::HistoryDBTask>(
           new UpdateRecentVisitsFromHistoryDBTask(this, url_id)), tracker);
 }
 
 // Helper functor for DeleteURL.
 class HistoryInfoMapItemHasURL {
  public:
   explicit HistoryInfoMapItemHasURL(const GURL& url): url_(url) {}
@@ skipping 52 matching lines @@
                              restored_data->word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLChars",
                              restored_data->char_word_map_.size());
   if (restored_data->Empty())
     return NULL;  // 'No data' is the same as a failed reload.
   return restored_data;
 }
 
 // static
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::RebuildFromHistory(
-    HistoryDatabase* history_db,
+    history::HistoryDatabase* history_db,
     const std::string& languages,
     const std::set<std::string>& scheme_whitelist) {
   if (!history_db)
     return NULL;
 
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
   scoped_refptr<URLIndexPrivateData>
       rebuilt_data(new URLIndexPrivateData);
-  URLDatabase::URLEnumerator history_enum;
+  history::URLDatabase::URLEnumerator history_enum;
   if (!history_db->InitURLEnumeratorForSignificant(&history_enum))
     return NULL;
   rebuilt_data->last_time_rebuilt_from_history_ = base::Time::Now();
-  for (URLRow row; history_enum.GetNextURL(&row); ) {
+  for (history::URLRow row; history_enum.GetNextURL(&row);) {
     rebuilt_data->IndexRow(
         history_db, NULL, row, languages, scheme_whitelist, NULL);
   }
 
   UMA_HISTOGRAM_TIMES("History.InMemoryURLIndexingTime",
                       base::TimeTicks::Now() - beginning_time);
   UMA_HISTOGRAM_COUNTS("History.InMemoryURLHistoryItems",
                        rebuilt_data->history_id_word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLWords",
                              rebuilt_data->word_map_.size());
@@ skipping 213 matching lines @@
       // Subsequent character results get intersected in.
       WordIDSet new_word_id_set = base::STLSetIntersection<WordIDSet>(
           word_id_set, char_word_id_set);
       word_id_set.swap(new_word_id_set);
     }
   }
   return word_id_set;
 }
 
 bool URLIndexPrivateData::IndexRow(
-    HistoryDatabase* history_db,
+    history::HistoryDatabase* history_db,
     HistoryService* history_service,
-    const URLRow& row,
+    const history::URLRow& row,
     const std::string& languages,
     const std::set<std::string>& scheme_whitelist,
     base::CancelableTaskTracker* tracker) {
   const GURL& gurl(row.url());
 
   // Index only URLs with a whitelisted scheme.
   if (!URLSchemeIsWhitelisted(gurl, scheme_whitelist))
     return false;
 
-  URLID row_id = row.id();
+  history::URLID row_id = row.id();
   // Strip out username and password before saving and indexing.
   base::string16 url(net::FormatUrl(gurl, languages,
       net::kFormatUrlOmitUsernamePassword,
       net::UnescapeRule::NONE,
       NULL, NULL, NULL));
 
   HistoryID history_id = static_cast<HistoryID>(row_id);
   DCHECK_LT(history_id, std::numeric_limits<HistoryID>::max());
 
   // Add the row for quick lookup in the history info store.
-  URLRow new_row(GURL(url), row_id);
+  history::URLRow new_row(GURL(url), row_id);
   new_row.set_visit_count(row.visit_count());
   new_row.set_typed_count(row.typed_count());
   new_row.set_last_visit(row.last_visit());
   new_row.set_title(row.title());
   history_info_map_[history_id].url_row = new_row;
 
   // Index the words contained in the URL and title of the row.
   RowWordStarts word_starts;
   AddRowWordsToIndex(new_row, &word_starts, languages);
   word_starts_map_[history_id] = word_starts;
 
   // Update the recent visits information or schedule the update
   // as appropriate.
   if (history_db) {
     // We'd like to check that we're on the history DB thread.
     // However, unittest code actually calls this on the UI thread.
     // So we don't do any thread checks.
-    VisitVector recent_visits;
+    history::VisitVector recent_visits;
     // Make sure the private data is going to get as many recent visits as
     // ScoredHistoryMatch::GetFrequency() hopes to use.
     DCHECK_GE(kMaxVisitsToStoreInCache, ScoredHistoryMatch::kMaxVisitsToScore);
     if (history_db->GetMostRecentVisitsForURL(row_id,
                                               kMaxVisitsToStoreInCache,
                                               &recent_visits))
       UpdateRecentVisits(row_id, recent_visits);
   } else {
     DCHECK(tracker);
     DCHECK(history_service);
     ScheduleUpdateRecentVisits(history_service, row_id, tracker);
   }
 
   return true;
 }
 
-void URLIndexPrivateData::AddRowWordsToIndex(const URLRow& row,
+void URLIndexPrivateData::AddRowWordsToIndex(const history::URLRow& row,
                                              RowWordStarts* word_starts,
                                              const std::string& languages) {
   HistoryID history_id = static_cast<HistoryID>(row.id());
   // Split URL into individual, unique words then add in the title words.
   const GURL& gurl(row.url());
   const base::string16& url =
       bookmarks::CleanUpUrlForMatching(gurl, languages, NULL);
   String16Set url_words = String16SetFromString16(url,
       word_starts ? &word_starts->url_word_starts_ : NULL);
   const base::string16& title = bookmarks::CleanUpTitleForMatching(row.title());
@@ skipping 68 matching lines @@
   if (iter != history_id_word_map_.end()) {
     WordIDSet& word_id_set(iter->second);
     word_id_set.insert(word_id);
   } else {
     WordIDSet word_id_set;
     word_id_set.insert(word_id);
     history_id_word_map_[history_id] = word_id_set;
   }
 }
 
-void URLIndexPrivateData::RemoveRowFromIndex(const URLRow& row) {
+void URLIndexPrivateData::RemoveRowFromIndex(const history::URLRow& row) {
   RemoveRowWordsFromIndex(row);
   HistoryID history_id = static_cast<HistoryID>(row.id());
   history_info_map_.erase(history_id);
   word_starts_map_.erase(history_id);
 }
 
-void URLIndexPrivateData::RemoveRowWordsFromIndex(const URLRow& row) {
+void URLIndexPrivateData::RemoveRowWordsFromIndex(const history::URLRow& row) {
   // Remove the entries in history_id_word_map_ and word_id_history_map_ for
   // this row.
   HistoryID history_id = static_cast<HistoryID>(row.id());
   WordIDSet word_id_set = history_id_word_map_[history_id];
   history_id_word_map_.erase(history_id);
 
   // Reconcile any changes to word usage.
   for (WordIDSet::iterator word_id_iter = word_id_set.begin();
        word_id_iter != word_id_set.end(); ++word_id_iter) {
     WordID word_id = *word_id_iter;
@@ skipping 126 matching lines @@
 void URLIndexPrivateData::SaveHistoryInfoMap(
     InMemoryURLIndexCacheItem* cache) const {
   if (history_info_map_.empty())
     return;
   HistoryInfoMapItem* map_item = cache->mutable_history_info_map();
   map_item->set_item_count(history_info_map_.size());
   for (HistoryInfoMap::const_iterator iter = history_info_map_.begin();
        iter != history_info_map_.end(); ++iter) {
     HistoryInfoMapEntry* map_entry = map_item->add_history_info_map_entry();
     map_entry->set_history_id(iter->first);
-    const URLRow& url_row(iter->second.url_row);
+    const history::URLRow& url_row(iter->second.url_row);
     // Note: We only save information that contributes to the index so there
     // is no need to save search_term_cache_ (not persistent).
     map_entry->set_visit_count(url_row.visit_count());
     map_entry->set_typed_count(url_row.typed_count());
     map_entry->set_last_visit(url_row.last_visit().ToInternalValue());
     map_entry->set_url(url_row.url().spec());
     map_entry->set_title(base::UTF16ToUTF8(url_row.title()));
     const VisitInfoVector& visits(iter->second.visits);
     for (VisitInfoVector::const_iterator visit_iter = visits.begin();
          visit_iter != visits.end(); ++visit_iter) {
@@ skipping 160 matching lines @@
   uint32 expected_item_count = list_item.item_count();
   uint32 actual_item_count = list_item.history_info_map_entry_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   const RepeatedPtrField<HistoryInfoMapEntry>&
       entries(list_item.history_info_map_entry());
   for (RepeatedPtrField<HistoryInfoMapEntry>::const_iterator iter =
        entries.begin(); iter != entries.end(); ++iter) {
     HistoryID history_id = iter->history_id();
     GURL url(iter->url());
-    URLRow url_row(url, history_id);
+    history::URLRow url_row(url, history_id);
     url_row.set_visit_count(iter->visit_count());
     url_row.set_typed_count(iter->typed_count());
     url_row.set_last_visit(base::Time::FromInternalValue(iter->last_visit()));
     if (iter->has_title()) {
       base::string16 title(base::UTF8ToUTF16(iter->title()));
       url_row.set_title(title);
     }
     history_info_map_[history_id].url_row = url_row;
 
     // Restore visits list.
@@ skipping 38 matching lines @@
            jiter != title_starts.end(); ++jiter)
         word_starts.title_word_starts_.push_back(*jiter);
       word_starts_map_[history_id] = word_starts;
     }
   } else {
     // Since the cache did not contain any word starts we must rebuild then from
     // the URL and page titles.
     for (HistoryInfoMap::const_iterator iter = history_info_map_.begin();
          iter != history_info_map_.end(); ++iter) {
       RowWordStarts word_starts;
-      const URLRow& row(iter->second.url_row);
+      const history::URLRow& row(iter->second.url_row);
       const base::string16& url =
           bookmarks::CleanUpUrlForMatching(row.url(), languages, NULL);
       String16VectorFromString16(url, false, &word_starts.url_word_starts_);
       const base::string16& title =
           bookmarks::CleanUpTitleForMatching(row.title());
       String16VectorFromString16(title, false, &word_starts.title_word_starts_);
       word_starts_map_[iter->first] = word_starts;
     }
   }
   return true;
@@ skipping 55 matching lines @@
   }
 }
 
 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 URLRow& hist_item = hist_pos->second.url_row;
+    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(
         hist_item, visits, languages_, lower_string_, lower_terms_,
         lower_terms_to_word_starts_offsets_, starts_pos->second, now_);
     if (match.raw_score > 0)
       scored_matches_.push_back(match);
   }
@@ skipping 11 matching lines @@
 
 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 URLRow& r1(entry1->second.url_row);
-  const URLRow& r2(entry2->second.url_row);
+  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());
 }
-
-}  // namespace history