Convert Pass()→std::move() in mojo/edk/

mojo/edk/system/child_broker.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 "mojo/edk/system/child_broker.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/system/broker_messages.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 
 namespace mojo {
 namespace edk {
 
 ChildBroker* ChildBroker::GetInstance() {
   return base::Singleton<
       ChildBroker, base::LeakySingletonTraits<ChildBroker>>::get();
 }
 
 void ChildBroker::SetChildBrokerHostHandle(ScopedPlatformHandle handle)  {
   ScopedPlatformHandle parent_async_channel_handle;
 #if defined(OS_POSIX)
-  parent_async_channel_handle = handle.Pass();
+  parent_async_channel_handle = std::move(handle);
 #else
   // On Windows we have two pipes to the parent. The first is for the token
   // exchange for creating and passing handles, since the child needs the
   // parent's help if it is sandboxed. The second is the same as POSIX, which is
   // used for multiplexing related messages. So on Windows, we send the second
   // pipe as the first string over the first one.
   parent_sync_channel_ = handle.Pass();
 
   HANDLE parent_handle = INVALID_HANDLE_VALUE;
   DWORD bytes_read = 0;
@@ skipping 76 matching lines @@
       pending_inprocess_connects_[pipe_id] = message_pipe;
       return;
     }
     // Both ends of the message pipe are in the same process.
     // First, tell the browser side that to remove its bookkeeping for a pending
     // connect, since it'll never get the other side.
 
     data.type = CANCEL_CONNECT_MESSAGE_PIPE;
     scoped_ptr<MessageInTransit> message(new MessageInTransit(
         MessageInTransit::Type::MESSAGE, sizeof(data), &data));
-    WriteAsyncMessage(message.Pass());
+    WriteAsyncMessage(std::move(message));
 
     if (!in_process_pipes_channel1_) {
       ScopedPlatformHandle server_handle, client_handle;
 #if defined(OS_WIN)
       CreatePlatformChannelPairNoLock(&server_handle, &client_handle);
 #else
       PlatformChannelPair channel_pair;
       server_handle = channel_pair.PassServerHandle();
       client_handle = channel_pair.PassClientHandle();
 #endif
       in_process_pipes_channel1_ = new RoutedRawChannel(
-          server_handle.Pass(),
+          std::move(server_handle),
           base::Bind(&ChildBroker::ChannelDestructed, base::Unretained(this)));
       in_process_pipes_channel2_ = new RoutedRawChannel(
-          client_handle.Pass(),
+          std::move(client_handle),
           base::Bind(&ChildBroker::ChannelDestructed, base::Unretained(this)));
     }
 
     AttachMessagePipe(pending_connects_[pipe_id], pipe_id,
                       in_process_pipes_channel1_);
     AttachMessagePipe(message_pipe, pipe_id, in_process_pipes_channel2_);
     pending_connects_.erase(pipe_id);
     return;
   }
 
   data.type = CONNECT_MESSAGE_PIPE;
   scoped_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::MESSAGE, sizeof(data), &data));
   pending_connects_[pipe_id] = message_pipe;
-  WriteAsyncMessage(message.Pass());
+  WriteAsyncMessage(std::move(message));
 }
 
 void ChildBroker::CloseMessagePipe(
     uint64_t pipe_id, MessagePipeDispatcher* message_pipe) {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   CHECK(connected_pipes_.find(message_pipe) != connected_pipes_.end());
   connected_pipes_[message_pipe]->RemoveRoute(pipe_id);
   connected_pipes_.erase(message_pipe);
 }
 
@@ skipping 21 matching lines @@
   if (type == CONNECT_TO_PROCESS) {
     DCHECK_EQ(platform_handles->size(), 1u);
     ScopedPlatformHandle handle((*platform_handles.get())[0]);
     (*platform_handles.get())[0] = PlatformHandle();
 
     const ConnectToProcessMessage* message =
         static_cast<const ConnectToProcessMessage*>(message_view.bytes());
 
     CHECK(channels_.find(message->process_id) == channels_.end());
     channels_[message->process_id] = new RoutedRawChannel(
-        handle.Pass(),
+        std::move(handle),
         base::Bind(&ChildBroker::ChannelDestructed, base::Unretained(this)));
   } else if (type == PEER_PIPE_CONNECTED) {
     DCHECK(!platform_handles);
     const PeerPipeConnectedMessage* message =
         static_cast<const PeerPipeConnectedMessage*>(message_view.bytes());
 
     uint64_t pipe_id = message->pipe_id;
     uint64_t peer_pid = message->process_id;
 
     CHECK(pending_connects_.find(pipe_id) != pending_connects_.end());
@@ skipping 25 matching lines @@
       channels_.erase(it.first);
       break;
     }
   }
 }
 
 void ChildBroker::WriteAsyncMessage(scoped_ptr<MessageInTransit> message) {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   message->set_route_id(kBrokerRouteId);
   if (parent_async_channel_) {
-    parent_async_channel_->channel()->WriteMessage(message.Pass());
+    parent_async_channel_->channel()->WriteMessage(std::move(message));
   } else {
-    async_channel_queue_.AddMessage(message.Pass());
+    async_channel_queue_.AddMessage(std::move(message));
   }
 }
 
 void ChildBroker::InitAsyncChannel(
     ScopedPlatformHandle parent_async_channel_handle) {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
 
   parent_async_channel_ = new RoutedRawChannel(
-      parent_async_channel_handle.Pass()  ,
+      std::move(parent_async_channel_handle),
       base::Bind(&ChildBroker::ChannelDestructed, base::Unretained(this)));
   parent_async_channel_->AddRoute(kBrokerRouteId, this);
   while (!async_channel_queue_.IsEmpty()) {
     parent_async_channel_->channel()->WriteMessage(
         async_channel_queue_.GetMessage());
   }
 
   while (!pending_inprocess_connects_.empty()) {
     ConnectMessagePipe(pending_inprocess_connects_.begin()->first,
                        pending_inprocess_connects_.begin()->second);
@@ skipping 60 matching lines @@
   if (WriteAndReadResponse(&message, handles, response_size)) {
     server->reset(PlatformHandle(handles[0]));
     client->reset(PlatformHandle(handles[1]));
   }
 }
 
 #endif
 
 }  // namespace edk
 }  // namespace mojo