Indexed DB: Use BindOnce / OnceCallback / OnceClosure where applicable

content/browser/indexed_db/indexed_db_backing_store.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_backing_store.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 2406 matching lines @@
       WriteDescriptorVec* blobs,
       scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback)
       : waiting_for_callback_(false),
         database_id_(database_id),
         backing_store_(backing_store),
         callback_(callback),
         aborted_(false) {
     blobs_.swap(*blobs);
     iter_ = blobs_.begin();
     backing_store->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ChainedBlobWriterImpl::WriteNextFile, this));
+        FROM_HERE, base::BindOnce(&ChainedBlobWriterImpl::WriteNextFile, this));
   }
 
   void set_delegate(std::unique_ptr<FileWriterDelegate> delegate) override {
     delegate_.reset(delegate.release());
   }
 
   void ReportWriteCompletion(bool succeeded, int64_t bytes_written) override {
     DCHECK(waiting_for_callback_);
     DCHECK(!succeeded || bytes_written >= 0);
     waiting_for_callback_ = false;
@@ skipping 81 matching lines @@
     } else {
       DCHECK(write_status == FileWriterDelegate::ERROR_WRITE_STARTED ||
              write_status == FileWriterDelegate::ERROR_WRITE_NOT_STARTED);
     }
 
     bool success = write_status == FileWriterDelegate::SUCCESS_COMPLETED;
     if (success && !bytes_written_) {
       // LocalFileStreamWriter only creates a file if data is actually written.
       // If none was then create one now.
       task_runner_->PostTask(
-          FROM_HERE, base::Bind(&LocalWriteClosure::CreateEmptyFile, this));
+          FROM_HERE, base::BindOnce(&LocalWriteClosure::CreateEmptyFile, this));
     } else if (success && !last_modified_.is_null()) {
       task_runner_->PostTask(
-          FROM_HERE, base::Bind(&LocalWriteClosure::UpdateTimeStamp, this));
+          FROM_HERE, base::BindOnce(&LocalWriteClosure::UpdateTimeStamp, this));
     } else {
       task_runner_->PostTask(
           FROM_HERE,
-          base::Bind(&IndexedDBBackingStore::Transaction::ChainedBlobWriter::
-                     ReportWriteCompletion,
-                     chained_blob_writer_,
-                     success,
-                     bytes_written_));
+          base::BindOnce(&IndexedDBBackingStore::Transaction::
+                             ChainedBlobWriter::ReportWriteCompletion,
+                         chained_blob_writer_, success, bytes_written_));
     }
   }
 
   void WriteBlobToFileOnIOThread(
       const FilePath& file_path,
       const GURL& blob_url,
       const base::Time& last_modified,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
     std::unique_ptr<storage::FileStreamWriter> writer(
@@ skipping 119 matching lines @@
       }
       if (!base::TouchFile(path, info.last_accessed, info.last_modified)) {
         // TODO(ericu): Complain quietly; timestamp's probably not vital.
       }
     } else {
       // TODO(ericu): Complain quietly; timestamp's probably not vital.
     }
 
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&Transaction::ChainedBlobWriter::ReportWriteCompletion,
-                   chained_blob_writer,
-                   true,
-                   info.size));
+        base::BindOnce(&Transaction::ChainedBlobWriter::ReportWriteCompletion,
+                       chained_blob_writer, true, info.size));
   } else {
     DCHECK(descriptor.url().is_valid());
     scoped_refptr<LocalWriteClosure> write_closure(
         new LocalWriteClosure(chained_blob_writer, task_runner_.get()));
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&LocalWriteClosure::WriteBlobToFileOnIOThread,
-                   write_closure, path, descriptor.url(),
-                   descriptor.last_modified(), request_context_getter_));
+        base::BindOnce(&LocalWriteClosure::WriteBlobToFileOnIOThread,
+                       write_closure, path, descriptor.url(),
+                       descriptor.last_modified(), request_context_getter_));
   }
   return true;
 }
 
 void IndexedDBBackingStore::ReportBlobUnused(int64_t database_id,
                                              int64_t blob_key) {
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   bool all_blobs = blob_key == DatabaseMetaDataKey::kAllBlobsKey;
   DCHECK(all_blobs || DatabaseMetaDataKey::IsValidBlobKey(blob_key));
   scoped_refptr<LevelDBTransaction> transaction =
@@ skipping 1789 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content