Indexed DB: Use BindOnce / OnceCallback / OnceClosure where applicable

content/browser/indexed_db/indexed_db_database.cc

 // Copyright (c) 2013 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_database.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 224 matching lines @@
                                         pending_->child_process_id);
     DCHECK_EQ(db_->connections_.count(connection_.get()), 1UL);
 
     std::vector<int64_t> object_store_ids;
     IndexedDBTransaction* transaction = db_->CreateTransaction(
         pending_->transaction_id, connection_.get(), object_store_ids,
         blink::kWebIDBTransactionModeVersionChange);
 
     DCHECK(db_->transaction_coordinator_.IsRunningVersionChangeTransaction());
     transaction->ScheduleTask(
-        base::Bind(&IndexedDBDatabase::VersionChangeOperation, db_,
-                   pending_->version, pending_->callbacks));
+        base::BindOnce(&IndexedDBDatabase::VersionChangeOperation, db_,
+                       pending_->version, pending_->callbacks));
   }
 
   // Called when the upgrade transaction has started executing.
   void UpgradeTransactionStarted(int64_t old_version) override {
     DCHECK(connection_);
     pending_->callbacks->OnUpgradeNeeded(old_version, std::move(connection_),
                                          db_->metadata_,
                                          pending_->data_loss_info);
   }
 
@@ skipping 327 matching lines @@
                                         object_store_metadata.name,
                                         object_store_metadata.key_path,
                                         object_store_metadata.auto_increment);
   if (!s.ok()) {
     ReportErrorWithDetails(s, "Internal error creating object store.");
     return;
   }
 
   AddObjectStore(object_store_metadata, object_store_id);
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::CreateObjectStoreAbortOperation,
-                 this,
-                 object_store_id));
+      base::BindOnce(&IndexedDBDatabase::CreateObjectStoreAbortOperation, this,
+                     object_store_id));
 }
 
 void IndexedDBDatabase::DeleteObjectStore(IndexedDBTransaction* transaction,
                                           int64_t object_store_id) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStore", "txn.id",
              transaction->id());
   DCHECK_EQ(transaction->mode(), blink::kWebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
-  transaction->ScheduleTask(
-      base::Bind(&IndexedDBDatabase::DeleteObjectStoreOperation,
-                 this,
-                 object_store_id));
+  transaction->ScheduleTask(base::BindOnce(
+      &IndexedDBDatabase::DeleteObjectStoreOperation, this, object_store_id));
 }
 
 void IndexedDBDatabase::RenameObjectStore(IndexedDBTransaction* transaction,
                                           int64_t object_store_id,
                                           const base::string16& new_name) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::RenameObjectStore", "txn.id",
              transaction->id());
   DCHECK_EQ(transaction->mode(), blink::kWebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   // Store renaming is done synchronously, as it may be followed by
   // index creation (also sync) since preemptive OpenCursor/SetIndexKeys
   // may follow.
   const IndexedDBObjectStoreMetadata object_store_metadata =
       metadata_.object_stores[object_store_id];
 
   leveldb::Status s =
       backing_store_->RenameObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_metadata.id, new_name);
   if (!s.ok()) {
     ReportErrorWithDetails(s, "Internal error renaming object store.");
     return;
   }
 
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::RenameObjectStoreAbortOperation,
-                 this,
-                 object_store_id,
-                 object_store_metadata.name));
+      base::BindOnce(&IndexedDBDatabase::RenameObjectStoreAbortOperation, this,
+                     object_store_id, object_store_metadata.name));
   SetObjectStoreName(object_store_id, new_name);
 }
 
 void IndexedDBDatabase::CreateIndex(IndexedDBTransaction* transaction,
                                     int64_t object_store_id,
                                     int64_t index_id,
                                     const base::string16& name,
                                     const IndexedDBKeyPath& key_path,
                                     bool unique,
                                     bool multi_entry) {
@@ skipping 26 matching lines @@
     base::string16 error_string =
         ASCIIToUTF16("Internal error creating index '") +
         index_metadata.name + ASCIIToUTF16("'.");
     transaction->Abort(IndexedDBDatabaseError(
         blink::kWebIDBDatabaseExceptionUnknownError, error_string));
     return;
   }
 
   AddIndex(object_store_id, index_metadata, index_id);
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::CreateIndexAbortOperation,
-                 this,
-                 object_store_id,
-                 index_id));
+      base::BindOnce(&IndexedDBDatabase::CreateIndexAbortOperation, this,
+                     object_store_id, index_id));
 }
 
 void IndexedDBDatabase::CreateIndexAbortOperation(int64_t object_store_id,
                                                   int64_t index_id) {
   IDB_TRACE("IndexedDBDatabase::CreateIndexAbortOperation");
   RemoveIndex(object_store_id, index_id);
 }
 
 void IndexedDBDatabase::DeleteIndex(IndexedDBTransaction* transaction,
                                     int64_t object_store_id,
                                     int64_t index_id) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::DeleteIndex", "txn.id", transaction->id());
   DCHECK_EQ(transaction->mode(), blink::kWebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreIdAndIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(
-      base::Bind(&IndexedDBDatabase::DeleteIndexOperation,
-                 this,
-                 object_store_id,
-                 index_id));
+      base::BindOnce(&IndexedDBDatabase::DeleteIndexOperation, this,
+                     object_store_id, index_id));
 }
 
 leveldb::Status IndexedDBDatabase::DeleteIndexOperation(
     int64_t object_store_id,
     int64_t index_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::DeleteIndexOperation", "txn.id", transaction->id());
 
   const IndexedDBIndexMetadata index_metadata =
       metadata_.object_stores[object_store_id].indexes[index_id];
 
   leveldb::Status s =
       backing_store_->DeleteIndex(transaction->BackingStoreTransaction(),
                                   transaction->database()->id(),
                                   object_store_id,
                                   index_id);
   if (!s.ok())
     return s;
 
   RemoveIndex(object_store_id, index_id);
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::DeleteIndexAbortOperation,
-                 this,
-                 object_store_id,
-                 index_metadata));
+      base::BindOnce(&IndexedDBDatabase::DeleteIndexAbortOperation, this,
+                     object_store_id, index_metadata));
   return s;
 }
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
     int64_t object_store_id,
     const IndexedDBIndexMetadata& index_metadata) {
   IDB_TRACE("IndexedDBDatabase::DeleteIndexAbortOperation");
   AddIndex(object_store_id, index_metadata, IndexedDBIndexMetadata::kInvalidId);
 }
 
@@ skipping 19 matching lines @@
                                   transaction->database()->id(),
                                   object_store_id,
                                   index_id,
                                   new_name);
   if (!s.ok()) {
     ReportErrorWithDetails(s, "Internal error renaming index.");
     return;
   }
 
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::RenameIndexAbortOperation,
-                 this,
-                 object_store_id,
-                 index_id,
-                 index_metadata.name));
+      base::BindOnce(&IndexedDBDatabase::RenameIndexAbortOperation, this,
+                     object_store_id, index_id, index_metadata.name));
   SetIndexName(object_store_id, index_id, new_name);
 }
 
 void IndexedDBDatabase::RenameIndexAbortOperation(
     int64_t object_store_id,
     int64_t index_id,
     const base::string16& old_name) {
   IDB_TRACE("IndexedDBDatabase::RenameIndexAbortOperation");
   SetIndexName(object_store_id, index_id, old_name);
 }
@@ skipping 103 matching lines @@
                                std::unique_ptr<IndexedDBKeyRange> key_range,
                                bool key_only,
                                int64_t max_count,
                                scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(
+  transaction->ScheduleTask(base::BindOnce(
       &IndexedDBDatabase::GetAllOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       max_count, callbacks));
 }
 
 void IndexedDBDatabase::Get(IndexedDBTransaction* transaction,
                             int64_t object_store_id,
                             int64_t index_id,
                             std::unique_ptr<IndexedDBKeyRange> key_range,
                             bool key_only,
                             scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::Get", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(
+  transaction->ScheduleTask(base::BindOnce(
       &IndexedDBDatabase::GetOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       callbacks));
 }
 
 leveldb::Status IndexedDBDatabase::GetOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
@@ skipping 324 matching lines @@
   DCHECK(value);
   std::unique_ptr<PutOperationParams> params(
       base::MakeUnique<PutOperationParams>());
   params->object_store_id = object_store_id;
   params->value.swap(*value);
   params->handles.swap(*handles);
   params->key = std::move(key);
   params->put_mode = put_mode;
   params->callbacks = callbacks;
   params->index_keys = index_keys;
-  transaction->ScheduleTask(base::Bind(
-      &IndexedDBDatabase::PutOperation, this, base::Passed(&params)));
+  transaction->ScheduleTask(base::BindOnce(&IndexedDBDatabase::PutOperation,
+                                           this, base::Passed(&params)));
 }
 
 leveldb::Status IndexedDBDatabase::PutOperation(
     std::unique_ptr<PutOperationParams> params,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::PutOperation", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::kWebIDBTransactionModeReadOnly);
   bool key_was_generated = false;
   leveldb::Status s = leveldb::Status::OK();
 
@@ skipping 176 matching lines @@
 }
 
 void IndexedDBDatabase::SetIndexesReady(IndexedDBTransaction* transaction,
                                         int64_t,
                                         const std::vector<int64_t>& index_ids) {
   DCHECK(transaction);
   DCHECK_EQ(transaction->mode(), blink::kWebIDBTransactionModeVersionChange);
 
   transaction->ScheduleTask(
       blink::kWebIDBTaskTypePreemptive,
-      base::Bind(&IndexedDBDatabase::SetIndexesReadyOperation, this,
-                 index_ids.size()));
+      base::BindOnce(&IndexedDBDatabase::SetIndexesReadyOperation, this,
+                     index_ids.size()));
 }
 
 leveldb::Status IndexedDBDatabase::SetIndexesReadyOperation(
     size_t index_count,
     IndexedDBTransaction* transaction) {
   for (size_t i = 0; i < index_count; ++i)
     transaction->DidCompletePreemptiveEvent();
   return leveldb::Status::OK();
 }
 
@@ skipping 29 matching lines @@
   std::unique_ptr<OpenCursorOperationParams> params(
       base::MakeUnique<OpenCursorOperationParams>());
   params->object_store_id = object_store_id;
   params->index_id = index_id;
   params->key_range = std::move(key_range);
   params->direction = direction;
   params->cursor_type =
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE;
   params->task_type = task_type;
   params->callbacks = callbacks;
-  transaction->ScheduleTask(base::Bind(
+  transaction->ScheduleTask(base::BindOnce(
       &IndexedDBDatabase::OpenCursorOperation, this, base::Passed(&params)));
 }
 
 leveldb::Status IndexedDBDatabase::OpenCursorOperation(
     std::unique_ptr<OpenCursorOperationParams> params,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::OpenCursorOperation", "txn.id", transaction->id());
 
   // The frontend has begun indexing, so this pauses the transaction
@@ skipping 72 matching lines @@
                               int64_t object_store_id,
                               int64_t index_id,
                               std::unique_ptr<IndexedDBKeyRange> key_range,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::CountOperation,
-                                       this,
-                                       object_store_id,
-                                       index_id,
-                                       base::Passed(&key_range),
-                                       callbacks));
+  transaction->ScheduleTask(
+      base::BindOnce(&IndexedDBDatabase::CountOperation, this, object_store_id,
+                     index_id, base::Passed(&key_range), callbacks));
 }
 
 leveldb::Status IndexedDBDatabase::CountOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::CountOperation", "txn.id", transaction->id());
   uint32_t count = 0;
@@ skipping 33 matching lines @@
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::DeleteRange", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::kWebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::DeleteRangeOperation,
-                                       this,
-                                       object_store_id,
-                                       base::Passed(&key_range),
-                                       callbacks));
+  transaction->ScheduleTask(
+      base::BindOnce(&IndexedDBDatabase::DeleteRangeOperation, this,
+                     object_store_id, base::Passed(&key_range), callbacks));
 }
 
 leveldb::Status IndexedDBDatabase::DeleteRangeOperation(
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRangeOperation", "txn.id",
              transaction->id());
   leveldb::Status s =
@@ skipping 10 matching lines @@
 void IndexedDBDatabase::Clear(IndexedDBTransaction* transaction,
                               int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::kWebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
-  transaction->ScheduleTask(base::Bind(
-      &IndexedDBDatabase::ClearOperation, this, object_store_id, callbacks));
+  transaction->ScheduleTask(base::BindOnce(&IndexedDBDatabase::ClearOperation,
+                                           this, object_store_id, callbacks));
 }
 
 leveldb::Status IndexedDBDatabase::ClearOperation(
     int64_t object_store_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
   if (!s.ok())
@@ skipping 16 matching lines @@
       metadata_.object_stores[object_store_id];
   leveldb::Status s =
       backing_store_->DeleteObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_id);
   if (!s.ok())
     return s;
 
   RemoveObjectStore(object_store_id);
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::DeleteObjectStoreAbortOperation,
-                 this,
-                 object_store_metadata));
+      base::BindOnce(&IndexedDBDatabase::DeleteObjectStoreAbortOperation, this,
+                     object_store_metadata));
   return s;
 }
 
 leveldb::Status IndexedDBDatabase::VersionChangeOperation(
     int64_t version,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::VersionChangeOperation", "txn.id", transaction->id());
   int64_t old_version = metadata_.version;
   DCHECK_GT(version, old_version);
 
   backing_store_->UpdateIDBDatabaseIntVersion(
       transaction->BackingStoreTransaction(), id(), version);
 
   transaction->ScheduleAbortTask(
-      base::Bind(&IndexedDBDatabase::VersionChangeAbortOperation, this,
-                 metadata_.version));
+      base::BindOnce(&IndexedDBDatabase::VersionChangeAbortOperation, this,
+                     metadata_.version));
   metadata_.version = version;
 
   active_request_->UpgradeTransactionStarted(old_version);
   return leveldb::Status::OK();
 }
 
 void IndexedDBDatabase::TransactionFinished(IndexedDBTransaction* transaction,
                                             bool committed) {
   IDB_TRACE1("IndexedDBTransaction::TransactionFinished", "txn.id",
              transaction->id());
@@ skipping 185 matching lines @@
   if (status.IsCorruption()) {
     IndexedDBDatabaseError error(blink::kWebIDBDatabaseExceptionUnknownError,
                                  message);
     factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
   } else {
     factory_->HandleBackingStoreFailure(backing_store_->origin());
   }
 }
 
 }  // namespace content