Indexed DB: Use BindOnce / OnceCallback / OnceClosure where applicable

content/browser/indexed_db/indexed_db_callbacks.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_callbacks.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 35 matching lines @@
 
 // The following two objects protect the given objects from being destructed on
 // the IO thread if we have a shutdown or an error.
 struct SafeIOThreadConnectionWrapper {
   SafeIOThreadConnectionWrapper(std::unique_ptr<IndexedDBConnection> connection)
       : connection(std::move(connection)),
         idb_runner(base::SequencedTaskRunnerHandle::Get()) {}
   ~SafeIOThreadConnectionWrapper() {
     if (connection) {
       idb_runner->PostTask(
-          FROM_HERE, base::Bind(
+          FROM_HERE, base::BindOnce(
                          [](std::unique_ptr<IndexedDBConnection> connection) {
                            connection->ForceClose();
                          },
                          base::Passed(&connection)));
     }
   }
   SafeIOThreadConnectionWrapper(SafeIOThreadConnectionWrapper&& other) =
       default;
 
   std::unique_ptr<IndexedDBConnection> connection;
@@ skipping 143 matching lines @@
 IndexedDBCallbacks::~IndexedDBCallbacks() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendError, base::Unretained(io_helper_.get()),
-                 error));
+      base::BindOnce(&IOThreadHelper::SendError,
+                     base::Unretained(io_helper_.get()), error));
   complete_ = true;
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.Error",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
 }
 
 void IndexedDBCallbacks::OnSuccess(const std::vector<base::string16>& value) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessStringList,
-                 base::Unretained(io_helper_.get()), value));
+      base::BindOnce(&IOThreadHelper::SendSuccessStringList,
+                     base::Unretained(io_helper_.get()), value));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnBlocked(int64_t existing_version) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   if (sent_blocked_)
     return;
 
   sent_blocked_ = true;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendBlocked,
-                 base::Unretained(io_helper_.get()), existing_version));
+      base::BindOnce(&IOThreadHelper::SendBlocked,
+                     base::Unretained(io_helper_.get()), existing_version));
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.Blocked",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
 }
 
 void IndexedDBCallbacks::OnUpgradeNeeded(
     int64_t old_version,
     std::unique_ptr<IndexedDBConnection> connection,
     const IndexedDBDatabaseMetadata& metadata,
     const IndexedDBDataLossInfo& data_loss_info) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   DCHECK(!connection_created_);
 
   data_loss_ = data_loss_info.status;
   connection_created_ = true;
 
   SafeIOThreadConnectionWrapper wrapper(std::move(connection));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendUpgradeNeeded,
-                 base::Unretained(io_helper_.get()), base::Passed(&wrapper),
-                 old_version, data_loss_info.status, data_loss_info.message,
-                 metadata));
+      base::BindOnce(&IOThreadHelper::SendUpgradeNeeded,
+                     base::Unretained(io_helper_.get()), base::Passed(&wrapper),
+                     old_version, data_loss_info.status, data_loss_info.message,
+                     metadata));
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.UpgradeNeeded",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
 }
 
 void IndexedDBCallbacks::OnSuccess(
     std::unique_ptr<IndexedDBConnection> connection,
     const IndexedDBDatabaseMetadata& metadata) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   DCHECK_EQ(connection_created_, !connection);
 
   scoped_refptr<IndexedDBCallbacks> self(this);
 
   // Only create a new connection if one was not previously sent in
   // OnUpgradeNeeded.
   std::unique_ptr<IndexedDBConnection> database_connection;
   if (!connection_created_)
     database_connection = std::move(connection);
 
   SafeIOThreadConnectionWrapper wrapper(std::move(database_connection));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&IOThreadHelper::SendSuccessDatabase,
-                                     base::Unretained(io_helper_.get()),
-                                     base::Passed(&wrapper), metadata));
+                          base::BindOnce(&IOThreadHelper::SendSuccessDatabase,
+                                         base::Unretained(io_helper_.get()),
+                                         base::Passed(&wrapper), metadata));
   complete_ = true;
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.Success",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
 }
 
@@ skipping 11 matching lines @@
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
     mojo_value = ConvertAndEraseValue(value);
     blob_info.swap(value->blob_info);
   }
 
   SafeIOThreadCursorWrapper cursor_wrapper(std::move(cursor));
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessCursor,
-                 base::Unretained(io_helper_.get()),
-                 base::Passed(&cursor_wrapper), key, primary_key,
-                 base::Passed(&mojo_value), base::Passed(&blob_info)));
+      base::BindOnce(&IOThreadHelper::SendSuccessCursor,
+                     base::Unretained(io_helper_.get()),
+                     base::Passed(&cursor_wrapper), key, primary_key,
+                     base::Passed(&mojo_value), base::Passed(&blob_info)));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key,
                                    const IndexedDBKey& primary_key,
                                    IndexedDBValue* value) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   DCHECK_EQ(blink::kWebIDBDataLossNone, data_loss_);
 
   ::indexed_db::mojom::ValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
     mojo_value = ConvertAndEraseValue(value);
     blob_info.swap(value->blob_info);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessCursorContinue,
-                 base::Unretained(io_helper_.get()), key, primary_key,
-                 base::Passed(&mojo_value), base::Passed(&blob_info)));
+      base::BindOnce(&IOThreadHelper::SendSuccessCursorContinue,
+                     base::Unretained(io_helper_.get()), key, primary_key,
+                     base::Passed(&mojo_value), base::Passed(&blob_info)));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccessWithPrefetch(
     const std::vector<IndexedDBKey>& keys,
     const std::vector<IndexedDBKey>& primary_keys,
     std::vector<IndexedDBValue>* values) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
   DCHECK_EQ(keys.size(), primary_keys.size());
   DCHECK_EQ(keys.size(), values->size());
 
   DCHECK_EQ(blink::kWebIDBDataLossNone, data_loss_);
 
   std::vector<::indexed_db::mojom::ValuePtr> mojo_values;
   mojo_values.reserve(values->size());
   for (size_t i = 0; i < values->size(); ++i)
     mojo_values.push_back(ConvertAndEraseValue(&(*values)[i]));
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessCursorPrefetch,
-                 base::Unretained(io_helper_.get()), keys, primary_keys,
-                 base::Passed(&mojo_values), *values));
+      base::BindOnce(&IOThreadHelper::SendSuccessCursorPrefetch,
+                     base::Unretained(io_helper_.get()), keys, primary_keys,
+                     base::Passed(&mojo_values), *values));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccess(IndexedDBReturnValue* value) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
 
   DCHECK_EQ(blink::kWebIDBDataLossNone, data_loss_);
 
   ::indexed_db::mojom::ReturnValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
     mojo_value = ConvertReturnValue(value);
     blob_info = value->blob_info;
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessValue,
-                 base::Unretained(io_helper_.get()), base::Passed(&mojo_value),
-                 base::Passed(&blob_info)));
+      base::BindOnce(&IOThreadHelper::SendSuccessValue,
+                     base::Unretained(io_helper_.get()),
+                     base::Passed(&mojo_value), base::Passed(&blob_info)));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccessArray(
     std::vector<IndexedDBReturnValue>* values) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   DCHECK_EQ(blink::kWebIDBDataLossNone, data_loss_);
 
   std::vector<::indexed_db::mojom::ReturnValuePtr> mojo_values;
   mojo_values.reserve(values->size());
   for (size_t i = 0; i < values->size(); ++i)
     mojo_values.push_back(ConvertReturnValue(&(*values)[i]));
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&IOThreadHelper::SendSuccessArray,
-                                     base::Unretained(io_helper_.get()),
-                                     base::Passed(&mojo_values), *values));
+                          base::BindOnce(&IOThreadHelper::SendSuccessArray,
+                                         base::Unretained(io_helper_.get()),
+                                         base::Passed(&mojo_values), *values));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   DCHECK_EQ(blink::kWebIDBDataLossNone, data_loss_);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessKey,
-                 base::Unretained(io_helper_.get()), value));
+      base::BindOnce(&IOThreadHelper::SendSuccessKey,
+                     base::Unretained(io_helper_.get()), value));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccess(int64_t value) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadHelper::SendSuccessInteger,
-                 base::Unretained(io_helper_.get()), value));
+      base::BindOnce(&IOThreadHelper::SendSuccessInteger,
+                     base::Unretained(io_helper_.get()), value));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::OnSuccess() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!complete_);
   DCHECK(io_helper_);
 
   DCHECK_EQ(blink::kWebIDBDataLossNone, data_loss_);
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&IOThreadHelper::SendSuccess,
-                                     base::Unretained(io_helper_.get())));
+                          base::BindOnce(&IOThreadHelper::SendSuccess,
+                                         base::Unretained(io_helper_.get())));
   complete_ = true;
 }
 
 void IndexedDBCallbacks::SetConnectionOpenStartTime(
     const base::TimeTicks& start_time) {
   connection_open_start_time_ = start_time;
 }
 
 IndexedDBCallbacks::IOThreadHelper::IOThreadHelper(
     CallbacksAssociatedPtrInfo callbacks_info,
     base::WeakPtr<IndexedDBDispatcherHost> dispatcher_host,
     url::Origin origin,
     scoped_refptr<base::SequencedTaskRunner> idb_runner)
     : dispatcher_host_(std::move(dispatcher_host)),
       origin_(origin),
       idb_runner_(idb_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (callbacks_info.is_valid()) {
     callbacks_.Bind(std::move(callbacks_info));
-    callbacks_.set_connection_error_handler(
-        base::Bind(&IOThreadHelper::OnConnectionError, base::Unretained(this)));
+    callbacks_.set_connection_error_handler(base::BindOnce(
+        &IOThreadHelper::OnConnectionError, base::Unretained(this)));
   }
 }
 
 IndexedDBCallbacks::IOThreadHelper::~IOThreadHelper() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendError(
     const IndexedDBDatabaseError& error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 253 matching lines @@
   return true;
 }
 
 void IndexedDBCallbacks::IOThreadHelper::OnConnectionError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callbacks_.reset();
   dispatcher_host_ = nullptr;
 }
 
 }  // namespace content