Port History::QueryMostVisitedURLs to use CancelableTaskTracker

chrome/browser/history/history_backend.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/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 1274 matching lines @@
 
 void HistoryBackend::GetVisibleVisitCountToHost(
     const GURL& url,
     VisibleVisitCountToHostResult* result) {
   result->count = 0;
   result->success = db_.get() &&
                     db_->GetVisibleVisitCountToHost(
                         url, &result->count, &result->first_visit);
 }
 
-void HistoryBackend::QueryMostVisitedURLs(
-    scoped_refptr<QueryMostVisitedURLsRequest> request,
-    int result_count,
-    int days_back) {
-  if (request->canceled())
+void HistoryBackend::QueryMostVisitedURLs(int result_count,
+                                          int days_back,
+                                          MostVisitedURLList* result) {
+  if (!db_)
     return;
 
-  if (!db_) {
-    // No History Database - return an empty list.
-    request->ForwardResult(request->handle(), MostVisitedURLList());
-    return;
+  ScopedVector<PageUsageData> data;
+  db_->QuerySegmentUsage(base::Time::Now() -
+                         base::TimeDelta::FromDays(days_back),
+                         result_count, &data.get());
+
+  for (size_t i = 0; i < data.size(); ++i) {
+    PageUsageData* current_data = data[i];
+    RedirectList redirects;
+    GetMostRecentRedirectsFrom(current_data->GetURL(), &redirects);
+    MostVisitedURL url = MakeMostVisitedURL(*current_data, redirects);
+    result->push_back(url);
   }
-
-  MostVisitedURLList* result = &request->value;
-  QueryMostVisitedURLsImpl(result_count, days_back, result);
-  request->ForwardResult(request->handle(), *result);
 }
 
 void HistoryBackend::QueryFilteredURLs(
       scoped_refptr<QueryFilteredURLsRequest> request,
       int result_count,
       const history::VisitFilter& filter,
       bool extended_info)  {
   if (request->canceled())
     return;
 
@@ skipping 65 matching lines @@
       static_cast<int>((base::Time::Now() - request_start).InMilliseconds())));
   STATIC_HISTOGRAM_POINTER_BLOCK(
       "NewTabPage.SuggestedSitesLoadTime",
       Add(delta_time),
       base::LinearHistogram::FactoryGet("NewTabPage.SuggestedSitesLoadTime",
           1, 1000, 100, base::Histogram::kUmaTargetedHistogramFlag));
 
   request->ForwardResult(request->handle(), result);
 }
 
-void HistoryBackend::QueryMostVisitedURLsImpl(int result_count,
-                                              int days_back,
-                                              MostVisitedURLList* result) {
-  if (!db_)
-    return;
-
-  ScopedVector<PageUsageData> data;
-  db_->QuerySegmentUsage(base::Time::Now() -
-                         base::TimeDelta::FromDays(days_back),
-                         result_count, &data.get());
-
-  for (size_t i = 0; i < data.size(); ++i) {
-    PageUsageData* current_data = data[i];
-    RedirectList redirects;
-    GetMostRecentRedirectsFrom(current_data->GetURL(), &redirects);
-    MostVisitedURL url = MakeMostVisitedURL(*current_data, redirects);
-    result->push_back(url);
-  }
-}
-
 void HistoryBackend::GetRedirectsFromSpecificVisit(
     VisitID cur_visit, history::RedirectList* redirects) {
   // Follow any redirects from the given visit and add them to the list.
   // It *should* be impossible to get a circular chain here, but we check
   // just in case to avoid infinite loops.
   GURL cur_url;
   std::set<VisitID> visit_set;
   visit_set.insert(cur_visit);
   while (db_->GetRedirectFromVisit(cur_visit, &cur_visit, &cur_url)) {
     if (visit_set.find(cur_visit) != visit_set.end()) {
@@ skipping 1328 matching lines @@
   info.transition = visit.transition;
   // If we don't have a delegate yet during setup or shutdown, we will drop
   // these notifications.
   if (delegate_)
     delegate_->NotifyVisitDBObserversOnAddVisit(info);
 }
 
 #if defined(OS_ANDROID)
 void HistoryBackend::PopulateMostVisitedURLMap() {
   MostVisitedURLList most_visited_urls;
-  QueryMostVisitedURLsImpl(kPageVisitStatsMaxTopSites, kSegmentDataRetention,
-                           &most_visited_urls);
+  QueryMostVisitedURLs(kPageVisitStatsMaxTopSites,
+                       kSegmentDataRetention,
+                       &most_visited_urls);
 
   DCHECK_LE(most_visited_urls.size(), kPageVisitStatsMaxTopSites);
   for (size_t i = 0; i < most_visited_urls.size(); ++i) {
     most_visited_urls_map_[most_visited_urls[i].url] = i;
     for (size_t j = 0; j < most_visited_urls[i].redirects.size(); ++j)
       most_visited_urls_map_[most_visited_urls[i].redirects[j]] = i;
   }
 }
 
 void HistoryBackend::RecordTopPageVisitStats(const GURL& url) {
   int rank = kPageVisitStatsMaxTopSites;
   std::map<GURL, int>::const_iterator it = most_visited_urls_map_.find(url);
   if (it != most_visited_urls_map_.end())
     rank = (*it).second;
   UMA_HISTOGRAM_ENUMERATION("History.TopSitesVisitsByRank",
                             rank, kPageVisitStatsMaxTopSites + 1);
 }
 #endif
 
 }  // namespace history