Use OnceCallback on Mojo interfaces in //chrome/common/extensions

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 11 matching lines @@
                       extensions::mojom::MediaDataSourcePtr* interface)
       : binding_(this, interface), safe_media_metadata_parser_(owner) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   }
 
   ~MediaDataSourceImpl() override = default;
 
  private:
   void ReadBlob(int64_t position,
                 int64_t length,
-                const ReadBlobCallback& callback) override {
-    safe_media_metadata_parser_->StartBlobRequest(callback, position, length);
+                ReadBlobCallback callback) override {
+    safe_media_metadata_parser_->StartBlobRequest(std::move(callback), position,
+                                                  length);
   }
 
   mojo::Binding<extensions::mojom::MediaDataSource> binding_;
   // |safe_media_metadata_parser_| owns |this|.
   SafeMediaMetadataParser* const safe_media_metadata_parser_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaDataSourceImpl);
 };
 
 SafeMediaMetadataParser::SafeMediaMetadataParser(Profile* profile,
@@ skipping 75 matching lines @@
       base::MakeUnique<std::vector<metadata::AttachedImage>>(attached_images);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::BindOnce(callback_, parse_success,
                      base::Passed(&metadata_dictionary),
                      base::Passed(&attached_images_copy)));
 }
 
 void SafeMediaMetadataParser::StartBlobRequest(
-    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    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::BindOnce(&SafeMediaMetadataParser::StartBlobReaderOnUIThread, this,
-                     callback, position, length));
+                     std::move(callback), position, length));
 }
 
 void SafeMediaMetadataParser::StartBlobReaderOnUIThread(
-    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    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));
+                 base::Passed(&callback)));
   reader->SetByteRange(position, length);
   reader->Start();
 }
 
 void SafeMediaMetadataParser::BlobReaderDoneOnUIThread(
-    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    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::BindOnce(&SafeMediaMetadataParser::FinishBlobRequest, this,
-                     callback, base::Passed(std::move(data))));
+                     std::move(callback), std::move(data)));
 }
 
 void SafeMediaMetadataParser::FinishBlobRequest(
-    const extensions::mojom::MediaDataSource::ReadBlobCallback& callback,
+    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()));
+    std::move(callback).Run(std::vector<uint8_t>(data->begin(), data->end()));
 }
 
 }  // namespace metadata