Move CancelableTaskTracker to //base/task/CancelableTaskTracker.

chrome/browser/history/history_service.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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 566 matching lines @@
          ++i)
       urls.push_back(i->url());
 
     visitedlink_master_->AddURLs(urls);
   }
 
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::AddPagesWithDetails, info, visit_source);
 }
 
-CancelableTaskTracker::TaskId HistoryService::GetFavicons(
+base::CancelableTaskTracker::TaskId HistoryService::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFavicons,
                  history_backend_.get(),
                  icon_urls,
                  icon_types,
                  desired_size_in_dip,
                  desired_scale_factors,
                  results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
-CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
+base::CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconsForURL,
                  history_backend_.get(),
                  page_url,
                  icon_types,
                  desired_size_in_dip,
                  desired_scale_factors,
                  results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
-CancelableTaskTracker::TaskId HistoryService::GetLargestFaviconForURL(
+base::CancelableTaskTracker::TaskId HistoryService::GetLargestFaviconForURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     const FaviconService::FaviconRawCallback& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   chrome::FaviconBitmapResult* result = new chrome::FaviconBitmapResult();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetLargestFaviconForURL,
                  history_backend_.get(),
                  page_url,
                  icon_types,
                  minimum_size_in_pixels,
                  result),
       base::Bind(&RunWithFaviconResult, callback, base::Owned(result)));
 }
 
-CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
+base::CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
     chrome::FaviconID favicon_id,
     int desired_size_in_dip,
     ui::ScaleFactor desired_scale_factor,
     const FaviconService::FaviconResultsCallback& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconForID,
                  history_backend_.get(),
                  favicon_id,
                  desired_size_in_dip,
                  desired_scale_factor,
                  results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
-CancelableTaskTracker::TaskId HistoryService::UpdateFaviconMappingsAndFetch(
+base::CancelableTaskTracker::TaskId
+HistoryService::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
   std::vector<chrome::FaviconBitmapResult>* results =
       new std::vector<chrome::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
                  history_backend_.get(),
@@ skipping 407 matching lines @@
   // We will update the visited links when we observe the delete
   // notifications.
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::DeleteURLs, urls);
 }
 
 void HistoryService::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(history_backend_.get());
   tracker->PostTaskAndReply(thread_->message_loop_proxy().get(),
                             FROM_HERE,
                             base::Bind(&HistoryBackend::ExpireHistoryBetween,
                                        history_backend_,
                                        restrict_urls,
                                        begin_time,
                                        end_time),
                             callback);
 }
 
 void HistoryService::ExpireHistory(
     const std::vector<history::ExpireHistoryArgs>& expire_list,
     const base::Closure& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   DCHECK(thread_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(history_backend_.get());
   tracker->PostTaskAndReply(
       thread_->message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&HistoryBackend::ExpireHistory, history_backend_, expire_list),
       callback);
 }
 
 void HistoryService::ExpireLocalAndRemoteHistoryBetween(
     const std::set<GURL>& restrict_urls,
     Time begin_time,
     Time end_time,
     const base::Closure& callback,
-    CancelableTaskTracker* tracker) {
+    base::CancelableTaskTracker* tracker) {
   // TODO(dubroy): This should be factored out into a separate class that
   // dispatches deletions to the proper places.
 
   history::WebHistoryService* web_history =
       WebHistoryServiceFactory::GetForProfile(profile_);
   if (web_history) {
     // TODO(dubroy): This API does not yet support deletion of specific URLs.
     DCHECK(restrict_urls.empty());
 
     delete_directive_handler_.CreateDeleteDirectives(
@@ skipping 93 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   visit_database_observers_.RemoveObserver(observer);
 }
 
 void HistoryService::NotifyVisitDBObserversOnAddVisit(
     const history::BriefVisitInfo& info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::VisitDatabaseObserver, visit_database_observers_,
                     OnAddVisit(info));
 }