Convert base::Passed() usage to std::move() where possible in Mojo

Using base::Passed() with BindOnce() is discouraged.

Bug: None
Change-Id: I28dd4217a1da4facac7ee19b93b19d8c15a53a9e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1895268Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#712841}

mojo/core/channel_unittest.cc

@@ -220,8 +220,8 @@ class ChannelTestShutdownAndWriteDelegate : public Channel::Delegate {
       // Write a fresh message, making our channel readable again.
       Channel::MessagePtr message = CreateDefaultMessage(false);
       client_thread_->task_runner()->PostTask(
-          FROM_HERE, base::BindOnce(&Channel::Write, client_channel_,
-                                    base::Passed(&message)));
+          FROM_HERE,
+          base::BindOnce(&Channel::Write, client_channel_, std::move(message)));
 
       // Close the channel and wait for it to shutdown.
       client_channel_->ShutDown();
@@ -269,7 +269,7 @@ TEST(ChannelTest, PeerShutdownDuringRead) {
   Channel::MessagePtr message = CreateDefaultMessage(false);
   client_thread->task_runner()->PostTask(
       FROM_HERE,
-      base::BindOnce(&Channel::Write, client_channel, base::Passed(&message)));
+      base::BindOnce(&Channel::Write, client_channel, std::move(message)));
 
   // Create a "server" Channel with the other end of the pipe, and process the
   // messages from it. The |server_delegate| will ShutDown the client end of

mojo/core/core.cc

@@ -140,7 +140,7 @@ Core::~Core() {
         node_controller_->io_task_runner();
     io_task_runner->PostTask(FROM_HERE,
                              base::BindOnce(&Core::PassNodeControllerToIOThread,
-                                            base::Passed(&node_controller_)));
+                                            std::move(node_controller_)));
   }
   base::trace_event::MemoryDumpManager::GetInstance()
       ->UnregisterAndDeleteDumpProviderSoon(std::move(handles_));

mojo/core/node_controller.cc

@@ -247,8 +247,8 @@ void NodeController::ConnectIsolated(ConnectionParams connection_params,
   io_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&NodeController::ConnectIsolatedOnIOThread,
-                     base::Unretained(this), base::Passed(&connection_params),
-                     port, connection_name.as_string()));
+                     base::Unretained(this), std::move(connection_params), port,
+                     connection_name.as_string()));
 }
 
 void NodeController::SetPortObserver(const ports::PortRef& port,

mojo/public/cpp/bindings/interface_endpoint_client.h

@@ -127,7 +127,7 @@ class COMPONENT_EXPORT(MOJO_CPP_BINDINGS) InterfaceEndpointClient
   // The following methods send interface control messages.
   // They must only be called when the handle is not in pending association
   // state.
-  void QueryVersion(const base::Callback<void(uint32_t)>& callback);
+  void QueryVersion(base::OnceCallback<void(uint32_t)> callback);
   void RequireVersion(uint32_t version);
   void FlushForTesting();
   void FlushAsyncForTesting(base::OnceClosure callback);

mojo/public/cpp/bindings/lib/control_message_proxy.cc

@@ -114,12 +114,12 @@ void SendRunOrClosePipeMessage(
 }
 
 void RunVersionCallback(
-    const base::Callback<void(uint32_t)>& callback,
+    base::OnceCallback<void(uint32_t)> callback,
     interface_control::RunResponseMessageParamsPtr run_response) {
   uint32_t version = 0u;
   if (run_response->output && run_response->output->is_query_version_result())
     version = run_response->output->get_query_version_result()->version;
-  callback.Run(version);
+  std::move(callback).Run(version);
 }
 
 void RunClosure(base::OnceClosure callback,
@@ -140,11 +140,11 @@ ControlMessageProxy::~ControlMessageProxy() {
 }
 
 void ControlMessageProxy::QueryVersion(
-    const base::Callback<void(uint32_t)>& callback) {
+    base::OnceCallback<void(uint32_t)> callback) {
   auto input_ptr = interface_control::RunInput::New();
   input_ptr->set_query_version(interface_control::QueryVersion::New());
   SendRunMessage(owner_, std::move(input_ptr),
-                 base::BindOnce(&RunVersionCallback, callback));
+                 base::BindOnce(&RunVersionCallback, std::move(callback)));
 }
 
 void ControlMessageProxy::RequireVersion(uint32_t version) {

mojo/public/cpp/bindings/lib/control_message_proxy.h

@@ -25,7 +25,7 @@ class COMPONENT_EXPORT(MOJO_CPP_BINDINGS) ControlMessageProxy {
   explicit ControlMessageProxy(InterfaceEndpointClient* owner);
   ~ControlMessageProxy();
 
-  void QueryVersion(const base::Callback<void(uint32_t)>& callback);
+  void QueryVersion(base::OnceCallback<void(uint32_t)> callback);
   void RequireVersion(uint32_t version);
 
   void FlushForTesting();

mojo/public/cpp/bindings/lib/interface_endpoint_client.cc

@@ -385,8 +385,8 @@ void InterfaceEndpointClient::NotifyError(
 }
 
 void InterfaceEndpointClient::QueryVersion(
-    const base::Callback<void(uint32_t)>& callback) {
-  control_message_proxy_.QueryVersion(callback);
+    base::OnceCallback<void(uint32_t)> callback) {
+  control_message_proxy_.QueryVersion(std::move(callback));
 }
 
 void InterfaceEndpointClient::RequireVersion(uint32_t version) {

mojo/public/cpp/bindings/lib/interface_ptr_state.cc

@@ -22,8 +22,8 @@ void InterfacePtrStateBase::QueryVersion(
   // It is safe to capture |this| because the callback won't be run after this
   // object goes away.
   endpoint_client_->QueryVersion(
-      base::BindRepeating(&InterfacePtrStateBase::OnQueryVersion,
-                          base::Unretained(this), base::Passed(&callback)));
+      base::BindOnce(&InterfacePtrStateBase::OnQueryVersion,
+                     base::Unretained(this), std::move(callback)));
 }
 
 void InterfacePtrStateBase::RequireVersion(uint32_t version) {

mojo/public/cpp/bindings/tests/native_struct_unittest.cc

@@ -52,7 +52,7 @@ TEST_P(NativeStructTest, NativeStruct) {
   test::TestNativeStruct s("hello world", 5, 42);
   base::RunLoop loop;
   remote()->PassNativeStruct(
-      s, base::Bind(
+      s, base::BindOnce(
              [](test::TestNativeStruct* expected_struct, base::RunLoop* loop,
                 const test::TestNativeStruct& passed) {
                EXPECT_EQ(expected_struct->message(), passed.message());
@@ -72,7 +72,7 @@ TEST_P(NativeStructTest, NativeStructWithAttachments) {
   base::RunLoop loop;
   remote()->PassNativeStructWithAttachments(
       std::move(s),
-      base::Bind(
+      base::BindOnce(
           [](const std::string& expected_message,
              mojo::ScopedMessagePipeHandle peer_pipe, base::RunLoop* loop,
              test::TestNativeStructWithAttachments passed) {
@@ -90,7 +90,7 @@ TEST_P(NativeStructTest, NativeStructWithAttachments) {
             EXPECT_EQ("ping", std::string(bytes.begin(), bytes.end()));
             loop->Quit();
           },
-          kTestMessage, base::Passed(&pipe.handle1), &loop));
+          kTestMessage, std::move(pipe.handle1), &loop));
   loop.Run();
 }
 

mojo/public/cpp/bindings/tests/struct_traits_unittest.cc

@@ -490,8 +490,7 @@ TEST_F(StructTraitsTest, TypemapUniquePtr) {
     base::RunLoop loop;
     proxy->EchoStructWithTraitsForUniquePtr(
         std::make_unique<int>(12345),
-        base::BindOnce(&ExpectUniquePtr,
-                       base::Passed(std::make_unique<int>(12345)),
+        base::BindOnce(&ExpectUniquePtr, std::make_unique<int>(12345),
                        loop.QuitClosure()));
     loop.Run();
   }