Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/media_galleries

chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.cc

 // Copyright 2014 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 "chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/blob_reader.h"
@@ skipping 40 matching lines @@
       mime_type_(mime_type),
       get_attached_images_(get_attached_images) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 void SafeMediaMetadataParser::Start(const DoneCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeMediaMetadataParser::StartOnIOThread, this, callback));
+      base::BindOnce(&SafeMediaMetadataParser::StartOnIOThread, this,
+                     callback));
 }
 
 SafeMediaMetadataParser::~SafeMediaMetadataParser() = default;
 
 void SafeMediaMetadataParser::StartOnIOThread(const DoneCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!utility_process_mojo_client_);
   DCHECK(callback);
 
   callback_ = callback;
@@ skipping 20 matching lines @@
   utility_process_mojo_client_.reset();  // Terminate the utility process.
   media_data_source_.reset();
 
   std::unique_ptr<base::DictionaryValue> metadata_dictionary =
       base::MakeUnique<base::DictionaryValue>();
   std::unique_ptr<std::vector<metadata::AttachedImage>> attached_images =
       base::MakeUnique<std::vector<metadata::AttachedImage>>();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(callback_, false, base::Passed(&metadata_dictionary),
-                 base::Passed(&attached_images)));
+      base::BindOnce(callback_, false, base::Passed(&metadata_dictionary),
+                     base::Passed(&attached_images)));
 }
 
 void SafeMediaMetadataParser::ParseMediaMetadataDone(
     bool parse_success,
     std::unique_ptr<base::DictionaryValue> metadata_dictionary,
     const std::vector<AttachedImage>& attached_images) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   utility_process_mojo_client_.reset();  // Terminate the utility process.
   media_data_source_.reset();
 
   // We need to make a scoped copy of this vector since it will be destroyed
   // at the end of the handler.
   std::unique_ptr<std::vector<metadata::AttachedImage>> attached_images_copy =
       base::MakeUnique<std::vector<metadata::AttachedImage>>(attached_images);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(callback_, parse_success, base::Passed(&metadata_dictionary),
-                 base::Passed(&attached_images_copy)));
+      base::BindOnce(callback_, parse_success,
+                     base::Passed(&metadata_dictionary),
+                     base::Passed(&attached_images_copy)));
 }
 
 void SafeMediaMetadataParser::StartBlobRequest(
     const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     int64_t position,
     int64_t length) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&SafeMediaMetadataParser::StartBlobReaderOnUIThread, this,
-                 callback, position, length));
+      base::BindOnce(&SafeMediaMetadataParser::StartBlobReaderOnUIThread, this,
+                     callback, position, length));
 }
 
 void SafeMediaMetadataParser::StartBlobReaderOnUIThread(
     const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     int64_t position,
     int64_t length) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   BlobReader* reader = new BlobReader(  // BlobReader is self-deleting.
       profile_, blob_uuid_,
       base::Bind(&SafeMediaMetadataParser::BlobReaderDoneOnUIThread, this,
                  callback));
   reader->SetByteRange(position, length);
   reader->Start();
 }
 
 void SafeMediaMetadataParser::BlobReaderDoneOnUIThread(
     const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     std::unique_ptr<std::string> data,
     int64_t /* blob_total_size */) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeMediaMetadataParser::FinishBlobRequest, this, callback,
-                 base::Passed(std::move(data))));
+      base::BindOnce(&SafeMediaMetadataParser::FinishBlobRequest, this,
+                     callback, base::Passed(std::move(data))));
 }
 
 void SafeMediaMetadataParser::FinishBlobRequest(
     const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
     std::unique_ptr<std::string> data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (utility_process_mojo_client_)
     callback.Run(std::vector<uint8_t>(data->begin(), data->end()));
 }
 
 }  // namespace metadata