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

mojo/edk/system/child_broker_host.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_host.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/lazy_instance.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/broker_state.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 
 namespace mojo {
 namespace edk {
 
 namespace {
 #if defined(OS_WIN)
 static const int kDefaultReadBufferSize = 256;
 #endif
 }
 
 ChildBrokerHost::ChildBrokerHost(base::ProcessHandle child_process,
                                  ScopedPlatformHandle pipe)
     : process_id_(base::GetProcId(child_process)), child_channel_(nullptr) {
   ScopedPlatformHandle parent_async_channel_handle;
 #if defined(OS_POSIX)
-  parent_async_channel_handle = pipe.Pass();
+  parent_async_channel_handle = std::move(pipe);
 #else
   DuplicateHandle(GetCurrentProcess(), child_process,
                   GetCurrentProcess(), &child_process,
                   0, FALSE, DUPLICATE_SAME_ACCESS);
   child_process_ = base::Process(child_process);
   sync_channel_ = pipe.Pass();
   memset(&read_context_.overlapped, 0, sizeof(read_context_.overlapped));
   read_context_.handler = this;
   memset(&write_context_.overlapped, 0, sizeof(write_context_.overlapped));
   write_context_.handler = this;
@@ skipping 26 matching lines @@
 void ChildBrokerHost::ConnectToProcess(base::ProcessId process_id,
                                        ScopedPlatformHandle pipe) {
   if (!child_channel_)
     return;  // Can happen at process shutdown on Windows.
   ConnectToProcessMessage data;
   data.type = CONNECT_TO_PROCESS;
   data.process_id = process_id;
   scoped_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::MESSAGE, sizeof(data), &data));
   scoped_refptr<Dispatcher> dispatcher =
-      PlatformHandleDispatcher::Create(pipe.Pass());
+      PlatformHandleDispatcher::Create(std::move(pipe));
   internal::g_core->AddDispatcher(dispatcher);
   scoped_ptr<DispatcherVector> dispatchers(new DispatcherVector);
   dispatchers->push_back(dispatcher);
-  message->SetDispatchers(dispatchers.Pass());
+  message->SetDispatchers(std::move(dispatchers));
   message->SerializeAndCloseDispatchers();
   message->set_route_id(kBrokerRouteId);
-  child_channel_->channel()->WriteMessage(message.Pass());
+  child_channel_->channel()->WriteMessage(std::move(message));
 }
 
 void ChildBrokerHost::ConnectMessagePipe(uint64_t pipe_id,
                                          base::ProcessId process_id) {
   if (!child_channel_)
     return;  // Can happen at process shutdown on Windows.
   PeerPipeConnectedMessage data;
   data.type = PEER_PIPE_CONNECTED;
   data.pipe_id = pipe_id;
   data.process_id = process_id;
   scoped_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::MESSAGE, sizeof(data), &data));
   message->set_route_id(kBrokerRouteId);
-  child_channel_->channel()->WriteMessage(message.Pass());
+  child_channel_->channel()->WriteMessage(std::move(message));
 }
 
 ChildBrokerHost::~ChildBrokerHost() {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   BrokerState::GetInstance()->ChildBrokerHostDestructed(this);
   if (child_channel_)
     child_channel_->RemoveRoute(kBrokerRouteId);
 }
 
 void ChildBrokerHost::InitOnIO(
     ScopedPlatformHandle parent_async_channel_handle) {
   child_channel_ = new RoutedRawChannel(
-      parent_async_channel_handle.Pass(),
+      std::move(parent_async_channel_handle),
       base::Bind(&ChildBrokerHost::ChannelDestructed, base::Unretained(this)));
   child_channel_->AddRoute(kBrokerRouteId, this);
 
   BrokerState::GetInstance()->ChildBrokerHostCreated(this);
 
 #if defined(OS_WIN)
   // Call this after RoutedRawChannel calls its RawChannel::Init because this
   // call could cause us to get notified that the child has gone away and to
   // delete this class and shut down child_channel_ before Init() has run.
   base::MessageLoopForIO::current()->RegisterIOHandler(
@@ skipping 178 matching lines @@
   BOOL result = DuplicateHandle(child_process_.Handle(), handle,
                                 base::GetCurrentProcessHandle(), &rv, 0, FALSE,
                                 DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
   DCHECK(result);
   return rv;
 }
 #endif
 
 }  // namespace edk
 }  // namespace mojo