Port HistoryService::ScheduleDBTask to CancelableTaskTracker

chrome/browser/history/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/history/url_index_private_data.h"
 
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <numeric>
@@ skipping 262 matching lines @@
     }
   }
 
   return scored_items;
 }
 
 bool URLIndexPrivateData::UpdateURL(
     HistoryService* history_service,
     const URLRow& row,
     const std::string& languages,
-    const std::set<std::string>& scheme_whitelist) {
+    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();
   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);
     new_row.set_id(row_id);
     row_was_updated = RowQualifiesAsSignificant(new_row, base::Time()) &&
-        IndexRow(NULL, history_service, new_row, languages, scheme_whitelist);
+        IndexRow(NULL, history_service, new_row, languages, scheme_whitelist, tracker);

[blundell, 2014/06/26 09:55:39]

nit: 80 chars?

[sdefresne, 2014/06/28 08:14:26]

Done.

   } 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;
     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);
+      ScheduleUpdateRecentVisits(history_service, row_id, tracker);
       // While the URL is guaranteed to remain stable, the title may have
       // changed. If so, then update the index with the changed words.
       if (title_updated) {
         // Clear all words associated with this row and re-index both the
         // URL and title.
         RemoveRowWordsFromIndex(row_to_update);
         row_to_update.set_title(row.title());
         RowWordStarts word_starts;
         AddRowWordsToIndex(row_to_update, &word_starts, languages);
         word_starts_map_[row_id] = word_starts;
@@ skipping 28 matching lines @@
     }
   }
   // 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) {
+    URLID url_id,
+    base::CancelableTaskTracker* tracker) {
   history_service->ScheduleDBTask(
-      new UpdateRecentVisitsFromHistoryDBTask(this, url_id),
-      &recent_visits_consumer_);
+      new UpdateRecentVisitsFromHistoryDBTask(this, url_id), tracker);
 }
 
 // Helper functor for DeleteURL.
 class HistoryInfoMapItemHasURL {
  public:
   explicit HistoryInfoMapItemHasURL(const GURL& url): url_(url) {}
 
   bool operator()(const std::pair<const HistoryID, HistoryInfoMapValue>& item) {
     return item.second.url_row.url() == url_;
   }
@@ skipping 64 matching lines @@
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
   scoped_refptr<URLIndexPrivateData>
       rebuilt_data(new URLIndexPrivateData);
   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); ) {
     rebuilt_data->IndexRow(history_db, NULL, row, languages,
-                           scheme_whitelist);
+                           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());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLChars",
                              rebuilt_data->char_word_map_.size());
   return rebuilt_data;
 }
 
 // static
 bool URLIndexPrivateData::WritePrivateDataToCacheFileTask(
     scoped_refptr<URLIndexPrivateData> private_data,
     const base::FilePath& file_path) {
   DCHECK(private_data.get());
   DCHECK(!file_path.empty());
   return private_data->SaveToFile(file_path);
 }
 
-void URLIndexPrivateData::CancelPendingUpdates() {
-  recent_visits_consumer_.CancelAllRequests();
-}
-
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::Duplicate() const {
   scoped_refptr<URLIndexPrivateData> data_copy = new URLIndexPrivateData;
   data_copy->last_time_rebuilt_from_history_ = last_time_rebuilt_from_history_;
   data_copy->word_list_ = word_list_;
   data_copy->available_words_ = available_words_;
   data_copy->word_map_ = word_map_;
   data_copy->char_word_map_ = char_word_map_;
   data_copy->word_id_history_map_ = word_id_history_map_;
   data_copy->history_id_word_map_ = history_id_word_map_;
   data_copy->history_info_map_ = history_info_map_;
@@ skipping 193 matching lines @@
     }
   }
   return word_id_set;
 }
 
 bool URLIndexPrivateData::IndexRow(
     HistoryDatabase* history_db,
     HistoryService* history_service,
     const URLRow& row,
     const std::string& languages,
-    const std::set<std::string>& scheme_whitelist) {
+    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();
   // Strip out username and password before saving and indexing.
   base::string16 url(net::FormatUrl(gurl, languages,
       net::kFormatUrlOmitUsernamePassword,
@@ skipping 24 matching lines @@
     // So we don't do any thread checks.
     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);
+    ScheduleUpdateRecentVisits(history_service, row_id, tracker);
   }
 
   return true;
 }
 
 void URLIndexPrivateData::AddRowWordsToIndex(const 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.
@@ skipping 592 matching lines @@
   // 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