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

chrome/utility/extensions/extensions_handler.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/utility/extensions/extensions_handler.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 43 matching lines @@
                             std::move(request));
   }
 
  private:
   // extensions::mojom::MediaParser:
   void ParseMediaMetadata(
       const std::string& mime_type,
       int64_t total_size,
       bool get_attached_images,
       extensions::mojom::MediaDataSourcePtr media_data_source,
-      const ParseMediaMetadataCallback& callback) override {
+      ParseMediaMetadataCallback callback) override {
     auto source = base::MakeUnique<metadata::IPCDataSource>(
         std::move(media_data_source), total_size);
     metadata::MediaMetadataParser* parser = new metadata::MediaMetadataParser(
         std::move(source), mime_type, get_attached_images);
-    parser->Start(base::Bind(&MediaParserImpl::ParseMediaMetadataDone, callback,
-                             base::Owned(parser)));
+    parser->Start(base::Bind(&MediaParserImpl::ParseMediaMetadataDone,
+                             base::Passed(&callback), base::Owned(parser)));
   }
 
   static void ParseMediaMetadataDone(
-      const ParseMediaMetadataCallback& callback,
+      ParseMediaMetadataCallback callback,
       metadata::MediaMetadataParser* /* parser */,
       const extensions::api::media_galleries::MediaMetadata& metadata,
       const std::vector<metadata::AttachedImage>& attached_images) {
-    callback.Run(true, metadata.ToValue(), attached_images);
+    std::move(callback).Run(true, metadata.ToValue(), attached_images);
   }
 
   void CheckMediaFile(base::TimeDelta decode_time,
                       base::File file,
-                      const CheckMediaFileCallback& callback) override {
+                      CheckMediaFileCallback callback) override {
 #if !defined(MEDIA_DISABLE_FFMPEG)
     media::MediaFileChecker checker(std::move(file));
-    callback.Run(checker.Start(decode_time));
+    std::move(callback).Run(checker.Start(decode_time));
 #else
-    callback.Run(false);
+    std::move(callback).Run(false);
 #endif
   }
 
   DISALLOW_COPY_AND_ASSIGN(MediaParserImpl);
 };
 
 class RemovableStorageWriterImpl
     : public extensions::mojom::RemovableStorageWriter {
  public:
   RemovableStorageWriterImpl() = default;
@@ skipping 34 matching lines @@
 
   static void Create(const service_manager::BindSourceInfo& source_info,
                      extensions::mojom::WiFiCredentialsGetterRequest request) {
     mojo::MakeStrongBinding(base::MakeUnique<WiFiCredentialsGetterImpl>(),
                             std::move(request));
   }
 
  private:
   // extensions::mojom::WiFiCredentialsGetter:
   void GetWiFiCredentials(const std::string& ssid,
-                          const GetWiFiCredentialsCallback& callback) override {
+                          GetWiFiCredentialsCallback callback) override {
     if (ssid == kWiFiTestNetwork) {
-      callback.Run(true, ssid);  // test-mode: return the ssid in key_data.
+      // test-mode: return the ssid in key_data.
+      std::move(callback).Run(true, ssid);
       return;
     }
 
     std::unique_ptr<wifi::WiFiService> wifi_service(
         wifi::WiFiService::Create());
     wifi_service->Initialize(nullptr);
 
     std::string key_data;
     std::string error;
     wifi_service->GetKeyFromSystem(ssid, &key_data, &error);
 
     const bool success = error.empty();
     if (!success)
       key_data.clear();
 
-    callback.Run(success, key_data);
+    std::move(callback).Run(success, key_data);
   }
 
   DISALLOW_COPY_AND_ASSIGN(WiFiCredentialsGetterImpl);
 };
 #endif  // defined(OS_WIN)
 
 }  // namespace
 
 namespace extensions {
 
@@ skipping 109 matching lines @@
   picasa::PicasaAlbumsIndexer indexer(album_uids);
   indexer.ParseFolderINI(folders_inis);
   content::UtilityThread::Get()->Send(
       new ChromeUtilityHostMsg_IndexPicasaAlbumsContents_Finished(
           indexer.albums_images()));
   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
 }
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 
 }  // namespace extensions