Let IndexedDBContextImpl create its own task runner

content/browser/indexed_db/indexed_db_dispatcher_host.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/indexed_db/indexed_db_dispatcher_host.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 114 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(IDBSequenceHelper);
 };
 
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     int ipc_process_id,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<IndexedDBContextImpl> indexed_db_context,
     scoped_refptr<ChromeBlobStorageContext> blob_storage_context)
     : indexed_db_context_(std::move(indexed_db_context)),
       blob_storage_context_(std::move(blob_storage_context)),
-      idb_runner_(indexed_db_context_->TaskRunner()),
       ipc_process_id_(ipc_process_id),
+      idb_helper_(new IDBSequenceHelper(ipc_process_id_,
+                                        std::move(request_context_getter),
+                                        indexed_db_context_)),
       weak_factory_(this) {
-  // Can be null in unittests.
-  idb_helper_ = idb_runner_
-                    ? new IDBSequenceHelper(ipc_process_id_,
-                                            std::move(request_context_getter),
-                                            indexed_db_context_)
-                    : nullptr;
   DCHECK(indexed_db_context_.get());
 }
 
 IndexedDBDispatcherHost::~IndexedDBDispatcherHost() {
-  if (idb_helper_)
-    idb_runner_->DeleteSoon(FROM_HERE, idb_helper_);
+  IDBTaskRunner()->DeleteSoon(FROM_HERE, idb_helper_);
 }
 
 void IndexedDBDispatcherHost::AddBinding(
     ::indexed_db::mojom::FactoryAssociatedRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 void IndexedDBDispatcherHost::AddDatabaseBinding(
     std::unique_ptr<::indexed_db::mojom::Database> database,
     ::indexed_db::mojom::DatabaseAssociatedRequest request) {
@@ skipping 63 matching lines @@
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info,
     const url::Origin& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidOrigin(origin)) {
     mojo::ReportBadMessage(kInvalidOrigin);
     return;
   }
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
-      this->AsWeakPtr(), origin, std::move(callbacks_info), idb_runner_));
-  idb_runner_->PostTask(
+      this->AsWeakPtr(), origin, std::move(callbacks_info), IDBTaskRunner()));
+  IDBTaskRunner()->PostTask(
       FROM_HERE, base::BindOnce(&IDBSequenceHelper::GetDatabaseNamesOnIDBThread,
                                 base::Unretained(idb_helper_),
                                 base::Passed(&callbacks), origin));
 }
 
 void IndexedDBDispatcherHost::Open(
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info,
     ::indexed_db::mojom::DatabaseCallbacksAssociatedPtrInfo
         database_callbacks_info,
     const url::Origin& origin,
     const base::string16& name,
     int64_t version,
     int64_t transaction_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidOrigin(origin)) {
     mojo::ReportBadMessage(kInvalidOrigin);
     return;
   }
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
-      this->AsWeakPtr(), origin, std::move(callbacks_info), idb_runner_));
+      this->AsWeakPtr(), origin, std::move(callbacks_info), IDBTaskRunner()));
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks(
       new IndexedDBDatabaseCallbacks(indexed_db_context_,
                                      std::move(database_callbacks_info)));
-  idb_runner_->PostTask(
+  IDBTaskRunner()->PostTask(
       FROM_HERE,
       base::BindOnce(&IDBSequenceHelper::OpenOnIDBThread,
                      base::Unretained(idb_helper_), base::Passed(&callbacks),
                      base::Passed(&database_callbacks), origin, name, version,
                      transaction_id));
 }
 
 void IndexedDBDispatcherHost::DeleteDatabase(
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info,
     const url::Origin& origin,
     const base::string16& name,
     bool force_close) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidOrigin(origin)) {
     mojo::ReportBadMessage(kInvalidOrigin);
     return;
   }
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
-      this->AsWeakPtr(), origin, std::move(callbacks_info), idb_runner_));
-  idb_runner_->PostTask(
+      this->AsWeakPtr(), origin, std::move(callbacks_info), IDBTaskRunner()));
+  IDBTaskRunner()->PostTask(
       FROM_HERE,
       base::BindOnce(&IDBSequenceHelper::DeleteDatabaseOnIDBThread,
                      base::Unretained(idb_helper_), base::Passed(&callbacks),
                      origin, name, force_close));
 }
 
 void IndexedDBDispatcherHost::AbortTransactionsAndCompactDatabase(
     const url::Origin& origin,
     AbortTransactionsAndCompactDatabaseCallback mojo_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidOrigin(origin)) {
     mojo::ReportBadMessage(kInvalidOrigin);
     return;
   }
 
   base::OnceCallback<void(leveldb::Status)> callback_on_io = base::BindOnce(
       &CallCompactionStatusCallbackOnIOThread,
       base::ThreadTaskRunnerHandle::Get(), std::move(mojo_callback));
-  idb_runner_->PostTask(
+  IDBTaskRunner()->PostTask(
       FROM_HERE,
       base::BindOnce(
           &IDBSequenceHelper::AbortTransactionsAndCompactDatabaseOnIDBThread,
           base::Unretained(idb_helper_), base::Passed(&callback_on_io),
           origin));
 }
 
 void IndexedDBDispatcherHost::AbortTransactionsForDatabase(
     const url::Origin& origin,
     AbortTransactionsForDatabaseCallback mojo_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!IsValidOrigin(origin)) {
     mojo::ReportBadMessage(kInvalidOrigin);
     return;
   }
 
   base::OnceCallback<void(leveldb::Status)> callback_on_io = base::BindOnce(
       &CallAbortStatusCallbackOnIOThread, base::ThreadTaskRunnerHandle::Get(),
       std::move(mojo_callback));
-  idb_runner_->PostTask(
+  IDBTaskRunner()->PostTask(
       FROM_HERE,
       base::BindOnce(
           &IDBSequenceHelper::AbortTransactionsForDatabaseOnIDBThread,
           base::Unretained(idb_helper_), base::Passed(&callback_on_io),
           origin));
 }
 
 void IndexedDBDispatcherHost::InvalidateWeakPtrsAndClearBindings() {
   weak_factory_.InvalidateWeakPtrs();
   cursor_bindings_.CloseAllBindings();
   database_bindings_.CloseAllBindings();
 }
 
+base::SequencedTaskRunner* IndexedDBDispatcherHost::IDBTaskRunner() const {
+  return indexed_db_context_->TaskRunner();
+}
+
 void IndexedDBDispatcherHost::IDBSequenceHelper::GetDatabaseNamesOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const url::Origin& origin) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksInCurrentSequence());
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
   indexed_db_context_->GetIDBFactory()->GetDatabaseNames(
       callbacks, origin, indexed_db_path, request_context_getter_);
 }
 
@@ skipping 50 matching lines @@
     AbortTransactionsForDatabaseOnIDBThread(
         base::OnceCallback<void(leveldb::Status)> callback,
         const url::Origin& origin) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksInCurrentSequence());
 
   indexed_db_context_->GetIDBFactory()->AbortTransactionsForDatabase(
       std::move(callback), origin);
 }
 
 }  // namespace content