Indexed DB: Use BindOnce / OnceCallback / OnceClosure where applicable

content/browser/indexed_db/database_impl.cc

 // Copyright 2016 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/database_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/sequence_checker.h"
@@ skipping 136 matching lines @@
                            const url::Origin& origin,
                            IndexedDBDispatcherHost* dispatcher_host,
                            scoped_refptr<base::SequencedTaskRunner> idb_runner)
     : dispatcher_host_(dispatcher_host),
       origin_(origin),
       idb_runner_(std::move(idb_runner)) {
   DCHECK(connection);
   helper_ = new IDBSequenceHelper(std::move(connection), origin,
                                   dispatcher_host->context());
   idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::ConnectionOpened,
-                                   base::Unretained(helper_)));
+                        base::BindOnce(&IDBSequenceHelper::ConnectionOpened,
+                                       base::Unretained(helper_)));
 }
 
 DatabaseImpl::~DatabaseImpl() {
   idb_runner_->DeleteSoon(FROM_HERE, helper_);
 }
 
 void DatabaseImpl::CreateObjectStore(int64_t transaction_id,
                                      int64_t object_store_id,
                                      const base::string16& name,
                                      const IndexedDBKeyPath& key_path,
                                      bool auto_increment) {
   idb_runner_->PostTask(
-      FROM_HERE, base::Bind(&IDBSequenceHelper::CreateObjectStore,
-                            base::Unretained(helper_), transaction_id,
-                            object_store_id, name, key_path, auto_increment));
+      FROM_HERE,
+      base::BindOnce(&IDBSequenceHelper::CreateObjectStore,
+                     base::Unretained(helper_), transaction_id, object_store_id,
+                     name, key_path, auto_increment));
 }
 
 void DatabaseImpl::DeleteObjectStore(int64_t transaction_id,
                                      int64_t object_store_id) {
   idb_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&IDBSequenceHelper::DeleteObjectStore,
-                 base::Unretained(helper_), transaction_id, object_store_id));
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::DeleteObjectStore,
+                                base::Unretained(helper_), transaction_id,
+                                object_store_id));
 }
 
 void DatabaseImpl::RenameObjectStore(int64_t transaction_id,
                                      int64_t object_store_id,
                                      const base::string16& new_name) {
-  idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::RenameObjectStore,
-                                   base::Unretained(helper_), transaction_id,
-                                   object_store_id, new_name));
+  idb_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::RenameObjectStore,
+                                base::Unretained(helper_), transaction_id,
+                                object_store_id, new_name));
 }
 
 void DatabaseImpl::CreateTransaction(
     int64_t transaction_id,
     const std::vector<int64_t>& object_store_ids,
     blink::WebIDBTransactionMode mode) {
-  idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::CreateTransaction,
-                                   base::Unretained(helper_), transaction_id,
-                                   object_store_ids, mode));
+  idb_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::CreateTransaction,
+                                base::Unretained(helper_), transaction_id,
+                                object_store_ids, mode));
 }
 
 void DatabaseImpl::Close() {
-  idb_runner_->PostTask(FROM_HERE, base::Bind(&IDBSequenceHelper::Close,
-                                              base::Unretained(helper_)));
+  idb_runner_->PostTask(FROM_HERE, base::BindOnce(&IDBSequenceHelper::Close,
+                                                  base::Unretained(helper_)));
 }
 
 void DatabaseImpl::VersionChangeIgnored() {
   idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::VersionChangeIgnored,
-                                   base::Unretained(helper_)));
+                        base::BindOnce(&IDBSequenceHelper::VersionChangeIgnored,
+                                       base::Unretained(helper_)));
 }
 
 void DatabaseImpl::AddObserver(int64_t transaction_id,
                                int32_t observer_id,
                                bool include_transaction,
                                bool no_records,
                                bool values,
                                uint16_t operation_types) {
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::AddObserver, base::Unretained(helper_),
-                 transaction_id, observer_id, include_transaction, no_records,
-                 values, operation_types));
+      base::BindOnce(&IDBSequenceHelper::AddObserver, base::Unretained(helper_),
+                     transaction_id, observer_id, include_transaction,
+                     no_records, values, operation_types));
 }
 
 void DatabaseImpl::RemoveObservers(const std::vector<int32_t>& observers) {
   idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::RemoveObservers,
-                                   base::Unretained(helper_), observers));
+                        base::BindOnce(&IDBSequenceHelper::RemoveObservers,
+                                       base::Unretained(helper_), observers));
 }
 
 void DatabaseImpl::Get(
     int64_t transaction_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& key_range,
     bool key_only,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
   idb_runner_->PostTask(
-      FROM_HERE, base::Bind(&IDBSequenceHelper::Get, base::Unretained(helper_),
-                            transaction_id, object_store_id, index_id,
-                            key_range, key_only, base::Passed(&callbacks)));
+      FROM_HERE,
+      base::BindOnce(&IDBSequenceHelper::Get, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id, key_range,
+                     key_only, base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::GetAll(
     int64_t transaction_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& key_range,
     bool key_only,
     int64_t max_count,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::GetAll, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id, key_range, key_only,
-                 max_count, base::Passed(&callbacks)));
+      base::BindOnce(&IDBSequenceHelper::GetAll, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id, key_range,
+                     key_only, max_count, base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::Put(
     int64_t transaction_id,
     int64_t object_store_id,
     ::indexed_db::mojom::ValuePtr value,
     const IndexedDBKey& key,
     blink::WebIDBPutMode mode,
     const std::vector<IndexedDBIndexKeys>& index_keys,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
@@ skipping 17 matching lines @@
 
     // Due to known issue crbug.com/351753, blobs can die while being passed to
     // a different process. So this case must be handled gracefully.
     // TODO(dmurph): Revert back to using mojo::ReportBadMessage once fixed.
     UMA_HISTOGRAM_BOOLEAN("Storage.IndexedDB.PutValidBlob",
                           handle.get() != nullptr);
     if (!handle) {
       IndexedDBDatabaseError error(blink::kWebIDBDatabaseExceptionUnknownError,
                                    kInvalidBlobUuid);
       idb_runner_->PostTask(
-          FROM_HERE, base::Bind(&IDBSequenceHelper::AbortWithError,
-                                base::Unretained(helper_), transaction_id,
-                                base::Passed(&callbacks), error));
+          FROM_HERE, base::BindOnce(&IDBSequenceHelper::AbortWithError,
+                                    base::Unretained(helper_), transaction_id,
+                                    base::Passed(&callbacks), error));
       return;
     }
     uint64_t size = handle->size();
     UMA_HISTOGRAM_MEMORY_KB("Storage.IndexedDB.PutBlobSizeKB", size / 1024ull);
     total_blob_size += size;
     handles[i] = std::move(handle);
 
     if (info->file) {
       if (!info->file->path.empty() &&
           !policy->CanReadFile(dispatcher_host_->ipc_process_id(),
@@ skipping 15 matching lines @@
                             blob_info.size());
   uint64_t blob_size = 0;
   total_blob_size.AssignIfValid(&blob_size);
   if (blob_size != 0) {
     // 1KB to 1GB.
     UMA_HISTOGRAM_COUNTS_1M("WebCore.IndexedDB.PutBlobsTotalSize",
                             blob_size / 1024);
   }
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::Put, base::Unretained(helper_),
-                 transaction_id, object_store_id, base::Passed(&value),
-                 base::Passed(&handles), base::Passed(&blob_info), key, mode,
-                 index_keys, base::Passed(&callbacks)));
+      base::BindOnce(&IDBSequenceHelper::Put, base::Unretained(helper_),
+                     transaction_id, object_store_id, base::Passed(&value),
+                     base::Passed(&handles), base::Passed(&blob_info), key,
+                     mode, index_keys, base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::SetIndexKeys(
     int64_t transaction_id,
     int64_t object_store_id,
     const IndexedDBKey& primary_key,
     const std::vector<IndexedDBIndexKeys>& index_keys) {
   idb_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&IDBSequenceHelper::SetIndexKeys, base::Unretained(helper_),
-                 transaction_id, object_store_id, primary_key, index_keys));
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::SetIndexKeys,
+                                base::Unretained(helper_), transaction_id,
+                                object_store_id, primary_key, index_keys));
 }
 
 void DatabaseImpl::SetIndexesReady(int64_t transaction_id,
                                    int64_t object_store_id,
                                    const std::vector<int64_t>& index_ids) {
   idb_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&IDBSequenceHelper::SetIndexesReady, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_ids));
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::SetIndexesReady,
+                                base::Unretained(helper_), transaction_id,
+                                object_store_id, index_ids));
 }
 
 void DatabaseImpl::OpenCursor(
     int64_t transaction_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& key_range,
     blink::WebIDBCursorDirection direction,
     bool key_only,
     blink::WebIDBTaskType task_type,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::OpenCursor, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id, key_range,
-                 direction, key_only, task_type, base::Passed(&callbacks)));
+      base::BindOnce(&IDBSequenceHelper::OpenCursor, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id, key_range,
+                     direction, key_only, task_type, base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::Count(
     int64_t transaction_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& key_range,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::Count, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id, key_range,
-                 base::Passed(&callbacks)));
+      base::BindOnce(&IDBSequenceHelper::Count, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id, key_range,
+                     base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::DeleteRange(
     int64_t transaction_id,
     int64_t object_store_id,
     const IndexedDBKeyRange& key_range,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::DeleteRange, base::Unretained(helper_),
-                 transaction_id, object_store_id, key_range,
-                 base::Passed(&callbacks)));
+      base::BindOnce(&IDBSequenceHelper::DeleteRange, base::Unretained(helper_),
+                     transaction_id, object_store_id, key_range,
+                     base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::Clear(
     int64_t transaction_id,
     int64_t object_store_id,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
   idb_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&IDBSequenceHelper::Clear, base::Unretained(helper_),
-                 transaction_id, object_store_id, base::Passed(&callbacks)));
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::Clear,
+                                base::Unretained(helper_), transaction_id,
+                                object_store_id, base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::CreateIndex(int64_t transaction_id,
                                int64_t object_store_id,
                                int64_t index_id,
                                const base::string16& name,
                                const IndexedDBKeyPath& key_path,
                                bool unique,
                                bool multi_entry) {
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::CreateIndex, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id, name, key_path,
-                 unique, multi_entry));
+      base::BindOnce(&IDBSequenceHelper::CreateIndex, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id, name, key_path,
+                     unique, multi_entry));
 }
 
 void DatabaseImpl::DeleteIndex(int64_t transaction_id,
                                int64_t object_store_id,
                                int64_t index_id) {
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::DeleteIndex, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id));
+      base::BindOnce(&IDBSequenceHelper::DeleteIndex, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id));
 }
 
 void DatabaseImpl::RenameIndex(int64_t transaction_id,
                                int64_t object_store_id,
                                int64_t index_id,
                                const base::string16& new_name) {
   idb_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IDBSequenceHelper::RenameIndex, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id, new_name));
+      base::BindOnce(&IDBSequenceHelper::RenameIndex, base::Unretained(helper_),
+                     transaction_id, object_store_id, index_id, new_name));
 }
 
 void DatabaseImpl::Abort(int64_t transaction_id) {
-  idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::Abort,
-                                   base::Unretained(helper_), transaction_id));
+  idb_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::Abort,
+                                base::Unretained(helper_), transaction_id));
 }
 
 void DatabaseImpl::Commit(int64_t transaction_id) {
-  idb_runner_->PostTask(FROM_HERE,
-                        base::Bind(&IDBSequenceHelper::Commit,
-                                   base::Unretained(helper_), transaction_id));
+  idb_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&IDBSequenceHelper::Commit,
+                                base::Unretained(helper_), transaction_id));
 }
 
 void DatabaseImpl::AckReceivedBlobs(const std::vector<std::string>& uuids) {
   for (const auto& uuid : uuids)
     dispatcher_host_->DropBlobData(uuid);
 }
 
 DatabaseImpl::IDBSequenceHelper::IDBSequenceHelper(
     std::unique_ptr<IndexedDBConnection> connection,
     const url::Origin& origin,
@@ skipping 457 matching lines @@
       usage + transaction->size() <= quota) {
     connection_->database()->Commit(transaction);
   } else {
     connection_->AbortTransaction(
         transaction,
         IndexedDBDatabaseError(blink::kWebIDBDatabaseExceptionQuotaError));
   }
 }
 
 }  // namespace content