Port HistoryService::ScheduleDBTask to 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 49 matching lines @@
       URLDatabase (stores a list of URLs)
       DownloadDatabase (stores a list of downloads)
       VisitDatabase (stores a list of visits for the URLs)
       VisitSegmentDatabase (stores groups of URLs for the most visited view).
 
     ExpireHistoryBackend (manages deleting things older than 3 months)
 */
 
 namespace history {
 
+namespace {
+void RunUnlessCanceled(
+    const base::Closure& closure,
+    const base::CancelableTaskTracker::IsCanceledCallback& is_canceled) {
+  if (!is_canceled.Run())
+    closure.Run();
+}
+}  // namespace
+
 #if defined(OS_ANDROID)
 // How long we keep segment data for in days. Currently 3 months.
 // This value needs to be greater or equal to
 // MostVisitedModel::kMostVisitedScope but we don't want to introduce a direct
 // dependency between MostVisitedModel and the history backend.
 const int kSegmentDataRetention = 90;
 #endif
 
 // How long we'll wait to do a commit, so that things are batched together.
 const int kCommitIntervalSeconds = 10;
@@ skipping 68 matching lines @@
   }
 
  private:
   friend class base::RefCounted<CommitLaterTask>;
 
   ~CommitLaterTask() {}
 
   scoped_refptr<HistoryBackend> history_backend_;
 };
 
+// QueuedHistoryDBTask ---------------------------------------------------------
+
+QueuedHistoryDBTask::QueuedHistoryDBTask(
+    scoped_refptr<HistoryDBTask> task,
+    scoped_refptr<base::SingleThreadTaskRunner> origin_loop,
+    const base::CancelableTaskTracker::IsCanceledCallback& is_canceled)
+    : task_(task), origin_loop_(origin_loop), is_canceled_(is_canceled) {
+  DCHECK(task_);
+  DCHECK(origin_loop_);
+  DCHECK(!is_canceled_.is_null());
+}
+
+QueuedHistoryDBTask::~QueuedHistoryDBTask() {
+}
+
+bool QueuedHistoryDBTask::is_canceled() {
+  return is_canceled_.Run();
+}
+
+bool QueuedHistoryDBTask::RunOnDBThread(HistoryBackend* backend,
+                                        HistoryDatabase* db) {
+  return task_->RunOnDBThread(backend, db);
+}
+
+void QueuedHistoryDBTask::DoneRunOnMainThread() {
+  origin_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&RunUnlessCanceled,
+                 base::Bind(&HistoryDBTask::DoneRunOnMainThread, task_),
+                 is_canceled_));
+}
+
 // HistoryBackend --------------------------------------------------------------
 
 HistoryBackend::HistoryBackend(const base::FilePath& history_dir,
                                Delegate* delegate,
                                HistoryClient* history_client)
     : delegate_(delegate),
       history_dir_(history_dir),
       scheduled_kill_db_(false),
       expirer_(this, history_client),
       recent_redirects_(kMaxRedirectCount),
       backend_destroy_message_loop_(NULL),
       segment_queried_(false),
       history_client_(history_client) {
 }
 
 HistoryBackend::~HistoryBackend() {
   DCHECK(!scheduled_commit_.get()) << "Deleting without cleanup";
-  ReleaseDBTasks();
+  queued_history_db_tasks_.clear();
 
 #if defined(OS_ANDROID)
   // Release AndroidProviderBackend before other objects.
   android_provider_backend_.reset();
 #endif
 
   // First close the databases before optionally running the "destroy" task.
   CloseAllDatabases();
 
   if (!backend_destroy_task_.is_null()) {
@@ skipping 2095 matching lines @@
 void HistoryBackend::CancelScheduledCommit() {
   if (scheduled_commit_.get()) {
     scheduled_commit_->Cancel();
     scheduled_commit_ = NULL;
   }
 }
 
 void HistoryBackend::ProcessDBTaskImpl() {
   if (!db_) {
     // db went away, release all the refs.
-    ReleaseDBTasks();
+    queued_history_db_tasks_.clear();
     return;
   }
 
   // Remove any canceled tasks.
-  while (!db_task_requests_.empty() && db_task_requests_.front()->canceled()) {
-    db_task_requests_.front()->Release();
-    db_task_requests_.pop_front();
+  while (!queued_history_db_tasks_.empty()) {
+    QueuedHistoryDBTask& task = queued_history_db_tasks_.front();
+    if (!task.is_canceled()) {
+      break;
+    }
+    queued_history_db_tasks_.pop_front();
   }
-  if (db_task_requests_.empty())
+  if (queued_history_db_tasks_.empty())
     return;
 
   // Run the first task.
-  HistoryDBTaskRequest* request = db_task_requests_.front();
-  db_task_requests_.pop_front();
-  if (request->value->RunOnDBThread(this, db_.get())) {
-    // The task is done. Notify the callback.
-    request->ForwardResult();
-    // We AddRef'd the request before adding, need to release it now.
-    request->Release();
+  QueuedHistoryDBTask task = queued_history_db_tasks_.front();
+  queued_history_db_tasks_.pop_front();
+  if (task.RunOnDBThread(this, db_.get())) {
+    // The task is done, notify the callback.
+    task.DoneRunOnMainThread();
   } else {
-    // Tasks wants to run some more. Schedule it at the end of current tasks.
-    db_task_requests_.push_back(request);
-    // And process it after an invoke later.
+    // The task wants to run some more. Schedule it at the end of the current
+    // tasks, and process it after an invoke later.
+    queued_history_db_tasks_.insert(queued_history_db_tasks_.end(), task);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&HistoryBackend::ProcessDBTaskImpl, this));
   }
 }
 
-void HistoryBackend::ReleaseDBTasks() {
-  for (std::list<HistoryDBTaskRequest*>::iterator i =
-       db_task_requests_.begin(); i != db_task_requests_.end(); ++i) {
-    (*i)->Release();
-  }
-  db_task_requests_.clear();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Generic operations
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void HistoryBackend::DeleteURLs(const std::vector<GURL>& urls) {
   expirer_.DeleteURLs(urls);
 
   db_->GetStartDate(&first_recorded_time_);
@@ skipping 160 matching lines @@
   // The expirer keeps tabs on the active databases. Tell it about the
   // databases which will be closed.
   expirer_.SetDatabases(NULL, NULL);
 
   // Reopen a new transaction for |db_| for the sake of CloseAllDatabases().
   db_->BeginTransaction();
   CloseAllDatabases();
 }
 
 void HistoryBackend::ProcessDBTask(
-    scoped_refptr<HistoryDBTaskRequest> request) {
-  DCHECK(request.get());
-  if (request->canceled())
-    return;
-
-  bool task_scheduled = !db_task_requests_.empty();
-  // Make sure we up the refcount of the request. ProcessDBTaskImpl will
-  // release when done with the task.
-  request->AddRef();
-  db_task_requests_.push_back(request.get());
-  if (!task_scheduled) {
-    // No other tasks are scheduled. Process request now.
+    scoped_refptr<HistoryDBTask> task,
+    scoped_refptr<base::SingleThreadTaskRunner> origin_loop,
+    const base::CancelableTaskTracker::IsCanceledCallback& is_canceled) {
+  bool scheduled = !queued_history_db_tasks_.empty();
+  queued_history_db_tasks_.insert(
+      queued_history_db_tasks_.end(),
+      QueuedHistoryDBTask(task, origin_loop, is_canceled));
+  if (!scheduled)
     ProcessDBTaskImpl();
-  }
 }
 
 void HistoryBackend::BroadcastNotifications(
     int type,
     scoped_ptr<HistoryDetails> details) {
   // |delegate_| may be NULL if |this| is in the process of closing (closed by
   // HistoryService -> HistoryBackend::Closing().
   if (delegate_)
     delegate_->BroadcastNotifications(type, details.Pass());
 }
@@ skipping 182 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