Use OnceCallback on Mojo interfaces in //content

content/shell/utility/shell_content_utility_client.cc

 // Copyright 2015 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/shell/utility/shell_content_utility_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 
 class TestServiceImpl : public mojom::TestService {
  public:
   static void Create(const service_manager::BindSourceInfo&,
                      mojom::TestServiceRequest request) {
     mojo::MakeStrongBinding(base::WrapUnique(new TestServiceImpl),
                             std::move(request));
   }
 
   // mojom::TestService implementation:
-  void DoSomething(const DoSomethingCallback& callback) override {
-    callback.Run();
+  void DoSomething(DoSomethingCallback callback) override {
+    std::move(callback).Run();
   }
 
-  void DoTerminateProcess(const DoTerminateProcessCallback& callback) override {
+  void DoTerminateProcess(DoTerminateProcessCallback callback) override {
     base::Process::Current().Terminate(0, false);
   }
 
-  void CreateFolder(const CreateFolderCallback& callback) override {
+  void CreateFolder(CreateFolderCallback callback) override {
     // Note: This is used to check if the sandbox is disabled or not since
     //       creating a folder is forbidden when it is enabled.
-    callback.Run(base::ScopedTempDir().CreateUniqueTempDir());
+    std::move(callback).Run(base::ScopedTempDir().CreateUniqueTempDir());
   }
 
-  void GetRequestorName(const GetRequestorNameCallback& callback) override {
+  void GetRequestorName(GetRequestorNameCallback callback) override {
     NOTREACHED();
   }
 
   void CreateSharedBuffer(const std::string& message,
-                          const CreateSharedBufferCallback& callback) override {
+                          CreateSharedBufferCallback callback) override {
     mojo::ScopedSharedBufferHandle buffer =
         mojo::SharedBufferHandle::Create(message.size());
     CHECK(buffer.is_valid());
 
     mojo::ScopedSharedBufferMapping mapping = buffer->Map(message.size());
     CHECK(mapping);
     std::copy(message.begin(), message.end(),
               reinterpret_cast<char*>(mapping.get()));
 
-    callback.Run(std::move(buffer));
+    std::move(callback).Run(std::move(buffer));
   }
 
  private:
   explicit TestServiceImpl() {}
 
   DISALLOW_COPY_AND_ASSIGN(TestServiceImpl);
 };
 
 std::unique_ptr<service_manager::Service> CreateTestService() {
   return std::unique_ptr<service_manager::Service>(new TestService);
@@ skipping 57 matching lines @@
 
 void ShellContentUtilityClient::BindNetworkServiceTestRequest(
     const service_manager::BindSourceInfo& source_info,
     mojom::NetworkServiceTestRequest request) {
   DCHECK(!network_service_test_);
   network_service_test_ =
       base::MakeUnique<NetworkServiceTestImpl>(std::move(request));
 }
 
 }  // namespace content