TaskScheduler: migrate appcache database over to use it.

content/browser/appcache/appcache_storage_impl.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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
 #include <limits>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "net/base/cache_type.h"
@@ skipping 102 matching lines @@
 }  // namespace
 
 // DatabaseTask -----------------------------------------
 
 class AppCacheStorageImpl::DatabaseTask
     : public base::RefCountedThreadSafe<DatabaseTask> {
  public:
   explicit DatabaseTask(AppCacheStorageImpl* storage)
       : storage_(storage),
         database_(storage->database_),
-        io_thread_(base::ThreadTaskRunnerHandle::Get()) {
+        io_thread_(base::SequencedTaskRunnerHandle::Get()) {
     DCHECK(io_thread_.get());
   }
 
   void AddDelegate(DelegateReference* delegate_reference) {
     delegates_.push_back(make_scoped_refptr(delegate_reference));
   }
 
   // Schedules a task to be Run() on the DB thread. Tasks
   // are run in the order in which they are scheduled.
   void Schedule();
@@ skipping 20 matching lines @@
 
   AppCacheStorageImpl* storage_;
   AppCacheDatabase* database_;
   DelegateReferenceVector delegates_;
 
  private:
   void CallRun(base::TimeTicks schedule_time);
   void CallRunCompleted(base::TimeTicks schedule_time);
   void OnFatalError();
 
-  scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
+  scoped_refptr<base::SequencedTaskRunner> io_thread_;
 };
 
 void AppCacheStorageImpl::DatabaseTask::Schedule() {
   DCHECK(storage_);
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
   if (!storage_->database_)
     return;
 
-  if (storage_->db_thread_->PostTask(
+  if (storage_->db_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&DatabaseTask::CallRun, this, base::TimeTicks::Now()))) {
     storage_->scheduled_database_tasks_.push_back(this);
   } else {
     NOTREACHED() << "Thread for database tasks is not running.";
   }
 }
 
 void AppCacheStorageImpl::DatabaseTask::CancelCompletion() {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
   delegates_.clear();
   storage_ = NULL;
 }
 
 void AppCacheStorageImpl::DatabaseTask::CallRun(
     base::TimeTicks schedule_time) {
   AppCacheHistograms::AddTaskQueueTimeSample(
       base::TimeTicks::Now() - schedule_time);
   if (!database_->is_disabled()) {
     base::TimeTicks run_time = base::TimeTicks::Now();
@@ skipping 15 matching lines @@
       FROM_HERE,
       base::Bind(&DatabaseTask::CallRunCompleted, this,
                  base::TimeTicks::Now()));
 }
 
 void AppCacheStorageImpl::DatabaseTask::CallRunCompleted(
     base::TimeTicks schedule_time) {
   AppCacheHistograms::AddCompletionQueueTimeSample(
       base::TimeTicks::Now() - schedule_time);
   if (storage_) {
-    DCHECK(io_thread_->BelongsToCurrentThread());
+    DCHECK(io_thread_->RunsTasksInCurrentSequence());
     DCHECK(storage_->scheduled_database_tasks_.front() == this);
     storage_->scheduled_database_tasks_.pop_front();
     base::TimeTicks run_time = base::TimeTicks::Now();
     RunCompleted();
     AppCacheHistograms::AddCompletionRunTimeSample(
         base::TimeTicks::Now() - run_time);
     delegates_.clear();
   }
 }
 
 void AppCacheStorageImpl::DatabaseTask::OnFatalError() {
   if (storage_) {
-    DCHECK(io_thread_->BelongsToCurrentThread());
+    DCHECK(io_thread_->RunsTasksInCurrentSequence());
     storage_->Disable();
     storage_->DeleteAndStartOver();
   }
 }
 
 // InitTask -------
 
 class AppCacheStorageImpl::InitTask : public DatabaseTask {
  public:
   explicit InitTask(AppCacheStorageImpl* storage)
@@ skipping 47 matching lines @@
 
 void AppCacheStorageImpl::InitTask::RunCompleted() {
   storage_->last_group_id_ = last_group_id_;
   storage_->last_cache_id_ = last_cache_id_;
   storage_->last_response_id_ = last_response_id_;
   storage_->last_deletable_response_rowid_ = last_deletable_response_rowid_;
 
   if (!storage_->is_disabled()) {
     storage_->usage_map_.swap(usage_map_);
     const base::TimeDelta kDelay = base::TimeDelta::FromMinutes(5);
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+    base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AppCacheStorageImpl::DelayedStartDeletingUnusedResponses,
                    storage_->weak_factory_.GetWeakPtr()),
         kDelay);
   }
 
   if (storage_->service()->quota_client())
     storage_->service()->quota_client()->NotifyAppCacheReady();
 }
 
@@ skipping 1083 matching lines @@
       weak_factory_(this) {
 }
 
 AppCacheStorageImpl::~AppCacheStorageImpl() {
   for (auto* task : pending_quota_queries_)
     task->CancelCompletion();
   for (auto* task : scheduled_database_tasks_)
     task->CancelCompletion();
 
   if (database_ &&
-      !db_thread_->PostTask(
+      !db_task_runner_->PostTask(
           FROM_HERE,
-          base::Bind(&ClearSessionOnlyOrigins,
-                     database_,
+          base::Bind(&ClearSessionOnlyOrigins, database_,
                      make_scoped_refptr(service_->special_storage_policy()),
                      service()->force_keep_session_state()))) {
     delete database_;
   }
   database_ = NULL;  // So no further database tasks can be scheduled.
 }
 
 void AppCacheStorageImpl::Initialize(
     const base::FilePath& cache_directory,
-    const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
+    const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread) {
-  DCHECK(db_thread.get());
-
   cache_directory_ = cache_directory;
   is_incognito_ = cache_directory_.empty();
 
   base::FilePath db_file_path;
   if (!is_incognito_)
     db_file_path = cache_directory_.Append(kAppCacheDatabaseName);
   database_ = new AppCacheDatabase(db_file_path);
 
-  db_thread_ = db_thread;
+  db_task_runner_ = db_task_runner;

[gab, 2017/06/20 21:29:54]

std::move

[michaeln, 2017/07/11 00:33:54]

i don't think its meaningful since db_task_runner is a const ref?

   cache_thread_ = cache_thread;
 
   scoped_refptr<InitTask> task(new InitTask(this));
   task->Schedule();
 }
 
 void AppCacheStorageImpl::Disable() {
   if (is_disabled_)
     return;
   VLOG(1) << "Disabling appcache storage.";
@@ skipping 335 matching lines @@
   deletable_response_ids_.insert(
       deletable_response_ids_.end(),
       response_ids.begin(), response_ids.end());
   if (!is_response_deletion_scheduled_)
     ScheduleDeleteOneResponse();
 }
 
 void AppCacheStorageImpl::ScheduleDeleteOneResponse() {
   DCHECK(!is_response_deletion_scheduled_);
   const base::TimeDelta kBriefDelay = base::TimeDelta::FromMilliseconds(10);
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
-                            weak_factory_.GetWeakPtr()),
+  base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
+                 weak_factory_.GetWeakPtr()),
       kBriefDelay);
   is_response_deletion_scheduled_ = true;
 }
 
 void AppCacheStorageImpl::DeleteOneResponse() {
   DCHECK(is_response_deletion_scheduled_);
   DCHECK(!deletable_response_ids_.empty());
 
   if (is_disabled_) {
     deletable_response_ids_.clear();
@@ skipping 62 matching lines @@
   PendingForeignMarkings::iterator iter = pending_foreign_markings_.begin();
   while (iter != pending_foreign_markings_.end()) {
     if (iter->second == cache_id)
       urls->push_back(iter->first);
     ++iter;
   }
 }
 
 void AppCacheStorageImpl::ScheduleSimpleTask(const base::Closure& task) {
   pending_simple_tasks_.push_back(task);
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
+  base::SequencedTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&AppCacheStorageImpl::RunOnePendingSimpleTask,
                             weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::RunOnePendingSimpleTask() {
   DCHECK(!pending_simple_tasks_.empty());
   base::Closure task = pending_simple_tasks_.front();
   pending_simple_tasks_.pop_front();
   task.Run();
 }
@@ skipping 49 matching lines @@
     // prior to deleting the files and calling reinit.
     cache_thread_->PostTaskAndReply(
         FROM_HERE,
         base::Bind(&base::DoNothing),
         base::Bind(&AppCacheStorageImpl::DeleteAndStartOverPart2,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void AppCacheStorageImpl::DeleteAndStartOverPart2() {
-  db_thread_->PostTaskAndReply(
+  db_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&base::DeleteFile), cache_directory_, true),
       base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::CallScheduleReinitialize() {
   service_->ScheduleReinitialize();
   // note: 'this' may be deleted at this point.
 }
@@ skipping 10 matching lines @@
 
 void AppCacheStorageImpl::OnLazyCommitTimer() {
   lazy_commit_timer_.Stop();
   if (is_disabled())
     return;
   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
   task->Schedule();
 }
 
 }  // namespace content