Port HistoryService::QueryFilteredURLs to CancelableRequestTracker

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 1330 matching lines @@
 
   for (size_t i = 0; i < data.size(); ++i) {
     PageUsageData* current_data = data[i];
     RedirectList redirects;
     QueryRedirectsFrom(current_data->GetURL(), &redirects);
     MostVisitedURL url = MakeMostVisitedURL(*current_data, redirects);
     result->push_back(url);
   }
 }
 
-void HistoryBackend::QueryFilteredURLs(
-      scoped_refptr<QueryFilteredURLsRequest> request,
-      int result_count,
-      const history::VisitFilter& filter,
-      bool extended_info)  {
-  if (request->canceled())
-    return;
-
+void HistoryBackend::QueryFilteredURLs(int result_count,
+                                       const history::VisitFilter& filter,
+                                       bool extended_info,
+                                       history::FilteredURLList* result) {
+  DCHECK(result);
   base::Time request_start = base::Time::Now();
 
+  result->clear();
   if (!db_) {
     // No History Database - return an empty list.
-    request->ForwardResult(request->handle(), FilteredURLList());
     return;
   }
 
   VisitVector visits;
   db_->GetDirectVisitsDuringTimes(filter, 0, &visits);
 
   std::map<URLID, double> score_map;
   for (size_t i = 0; i < visits.size(); ++i) {
     score_map[visits[i].url_id] += filter.GetVisitScore(visits[i]);
   }
@@ skipping 16 matching lines @@
     data.resize(result_count);
 
   for (size_t i = 0; i < data.size(); ++i) {
     URLRow info;
     if (db_->GetURLRow(data[i]->GetID(), &info)) {
       data[i]->SetURL(info.url());
       data[i]->SetTitle(info.title());
     }
   }
 
-  FilteredURLList& result = request->value;
   for (size_t i = 0; i < data.size(); ++i) {
     PageUsageData* current_data = data[i];
     FilteredURL url(*current_data);
 
     if (extended_info) {
       VisitVector visits;
       db_->GetVisitsForURL(current_data->GetID(), &visits);
       if (visits.size() > 0) {
         url.extended_info.total_visits = visits.size();
         for (size_t i = 0; i < visits.size(); ++i) {
           url.extended_info.duration_opened +=
               visits[i].visit_duration.InSeconds();
           if (visits[i].visit_time > url.extended_info.last_visit_time) {
             url.extended_info.last_visit_time = visits[i].visit_time;
           }
         }
         // TODO(macourteau): implement the url.extended_info.visits stat.
       }
     }
-    result.push_back(url);
+    result->push_back(url);
   }
 
   int delta_time = std::max(1, std::min(999,
       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::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);
@@ skipping 1321 matching lines @@
   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