Move Indexed DB from dedicated thread to task scheduler

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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
@@ skipping 17 matching lines @@
 namespace {
 
 const char kInvalidOrigin[] = "Origin is invalid";
 
 bool IsValidOrigin(const url::Origin& origin) {
   return !origin.unique();
 }
 
 }  // namespace
 
-class IndexedDBDispatcherHost::IDBThreadHelper {
+class IndexedDBDispatcherHost::IDBSequenceHelper {
  public:
-  IDBThreadHelper(
+  IDBSequenceHelper(
       int ipc_process_id,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<IndexedDBContextImpl> indexed_db_context)
       : ipc_process_id_(ipc_process_id),
         request_context_getter_(std::move(request_context_getter)),
         indexed_db_context_(std::move(indexed_db_context)) {}
-  ~IDBThreadHelper() {}
+  ~IDBSequenceHelper() {}
 
   void GetDatabaseNamesOnIDBThread(scoped_refptr<IndexedDBCallbacks> callbacks,
                                    const url::Origin& origin);
   void OpenOnIDBThread(
       scoped_refptr<IndexedDBCallbacks> callbacks,
       scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
       const url::Origin& origin,
       const base::string16& name,
       int64_t version,
       int64_t transaction_id);
   void DeleteDatabaseOnIDBThread(scoped_refptr<IndexedDBCallbacks> callbacks,
                                  const url::Origin& origin,
                                  const base::string16& name,
                                  bool force_close);
 
  private:
   const int ipc_process_id_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<IndexedDBContextImpl> indexed_db_context_;
 
-  DISALLOW_COPY_AND_ASSIGN(IDBThreadHelper);
+  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),
       weak_factory_(this) {
   // Can be null in unittests.
   idb_helper_ = idb_runner_
-                    ? new IDBThreadHelper(ipc_process_id_,
-                                          std::move(request_context_getter),
-                                          indexed_db_context_)
+                    ? 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_);
 }
 
 void IndexedDBDispatcherHost::AddBinding(
@@ skipping 71 matching lines @@
   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(
-      FROM_HERE, base::Bind(&IDBThreadHelper::GetDatabaseNamesOnIDBThread,
+      FROM_HERE, base::Bind(&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_));
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks(
       new IndexedDBDatabaseCallbacks(indexed_db_context_,
                                      std::move(database_callbacks_info)));
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBThreadHelper::OpenOnIDBThread,
+      base::Bind(&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(
       FROM_HERE,
-      base::Bind(&IDBThreadHelper::DeleteDatabaseOnIDBThread,
+      base::Bind(&IDBSequenceHelper::DeleteDatabaseOnIDBThread,
                  base::Unretained(idb_helper_), base::Passed(&callbacks),
                  origin, name, force_close));
 }
 
 void IndexedDBDispatcherHost::InvalidateWeakPtrsAndClearBindings() {
   weak_factory_.InvalidateWeakPtrs();
   cursor_bindings_.CloseAllBindings();
   database_bindings_.CloseAllBindings();
 }
 
-void IndexedDBDispatcherHost::IDBThreadHelper::GetDatabaseNamesOnIDBThread(
+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_);
 }
 
-void IndexedDBDispatcherHost::IDBThreadHelper::OpenOnIDBThread(
+void IndexedDBDispatcherHost::IDBSequenceHelper::OpenOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     const url::Origin& origin,
     const base::string16& name,
     int64_t version,
     int64_t transaction_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksInCurrentSequence());
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   callbacks->SetConnectionOpenStartTime(begin_time);
   std::unique_ptr<IndexedDBPendingConnection> connection =
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, database_callbacks, ipc_process_id_, transaction_id,
           version);
   DCHECK(request_context_getter_);
   indexed_db_context_->GetIDBFactory()->Open(name, std::move(connection),
                                              request_context_getter_, origin,
                                              indexed_db_path);
 }
 
-void IndexedDBDispatcherHost::IDBThreadHelper::DeleteDatabaseOnIDBThread(
+void IndexedDBDispatcherHost::IDBSequenceHelper::DeleteDatabaseOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const url::Origin& origin,
     const base::string16& name,
     bool force_close) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksInCurrentSequence());
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
   DCHECK(request_context_getter_);
   indexed_db_context_->GetIDBFactory()->DeleteDatabase(
       name, request_context_getter_, callbacks, origin, indexed_db_path,
       force_close);
 }
 
 }  // namespace content