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

mojo/runner/child/runner_connection.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/runner/child/runner_connection.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
@@ skipping 50 matching lines @@
   base::Closure run_after_;
 
   DISALLOW_COPY_AND_ASSIGN(Blocker);
 };
 
 using GotApplicationRequestCallback =
     base::Callback<void(InterfaceRequest<Application>)>;
 
 void OnGotApplicationRequest(InterfaceRequest<Application>* out_request,
                              InterfaceRequest<Application> request) {
-  *out_request = request.Pass();
+  *out_request = std::move(request);
 }
 
 class ChildControllerImpl;
 
 class RunnerConnectionImpl : public RunnerConnection {
  public:
   RunnerConnectionImpl() : controller_thread_("controller_thread") {
     StartControllerThread();
   }
   ~RunnerConnectionImpl() override {
     controller_runner_->PostTask(
         FROM_HERE, base::Bind(&RunnerConnectionImpl::ShutdownOnControllerThread,
                               base::Unretained(this)));
     controller_thread_.Stop();
   }
 
   // Returns true if a connection to the runner has been established and
   // |request| has been modified, false if no connection was established.
   bool WaitForApplicationRequest(InterfaceRequest<Application>* request,
                                  ScopedMessagePipeHandle handle);
 
   ChildControllerImpl* controller() const { return controller_.get(); }
 
   void set_controller(scoped_ptr<ChildControllerImpl> controller) {
-    controller_ = controller.Pass();
+    controller_ = std::move(controller);
   }
 
  private:
   void StartControllerThread() {
     base::Thread::Options controller_thread_options;
     controller_thread_options.message_loop_type =
         base::MessageLoop::TYPE_CUSTOM;
     controller_thread_options.message_pump_factory =
         base::Bind(&common::MessagePumpMojo::Create);
     CHECK(controller_thread_.StartWithOptions(controller_thread_options));
@@ skipping 26 matching lines @@
   static void Create(RunnerConnectionImpl* connection,
                      const GotApplicationRequestCallback& callback,
                      ScopedMessagePipeHandle runner_handle,
                      const Blocker::Unblocker& unblocker) {
     DCHECK(connection);
     DCHECK(!connection->controller());
 
     scoped_ptr<ChildControllerImpl> impl(
         new ChildControllerImpl(connection, callback, unblocker));
 
-    impl->Bind(runner_handle.Pass());
+    impl->Bind(std::move(runner_handle));
 
-    connection->set_controller(impl.Pass());
+    connection->set_controller(std::move(impl));
   }
 
   void Bind(ScopedMessagePipeHandle handle) {
-    binding_.Bind(handle.Pass());
+    binding_.Bind(std::move(handle));
     binding_.set_connection_error_handler([this]() { OnConnectionError(); });
   }
 
   void OnConnectionError() {
     // A connection error means the connection to the shell is lost. This is not
     // recoverable.
     LOG(ERROR) << "Connection error to the shell.";
     _exit(1);
   }
 
@@ skipping 19 matching lines @@
                       const Blocker::Unblocker& unblocker)
       : connection_(connection),
         callback_(callback),
         unblocker_(unblocker),
         channel_info_(nullptr),
         binding_(this) {}
 
   static void ReturnApplicationRequestOnMainThread(
       const GotApplicationRequestCallback& callback,
       InterfaceRequest<Application> application_request) {
-    callback.Run(application_request.Pass());
+    callback.Run(std::move(application_request));
   }
 
   base::ThreadChecker thread_checker_;
   RunnerConnectionImpl* const connection_;
   GotApplicationRequestCallback callback_;
   Blocker::Unblocker unblocker_;
   StartAppCallback on_app_complete_;
 
   embedder::ChannelInfo* channel_info_;
   Binding<ChildController> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildControllerImpl);
 };
 
 bool RunnerConnectionImpl::WaitForApplicationRequest(
     InterfaceRequest<Application>* request,
     ScopedMessagePipeHandle handle) {
   // If a valid message pipe to the runner was not provided, look for one on the
   // command line.
   if (!handle.is_valid()) {
     embedder::ScopedPlatformHandle platform_channel =
         embedder::PlatformChannelPair::PassClientHandleFromParentProcess(
             *base::CommandLine::ForCurrentProcess());
     if (!platform_channel.is_valid())
       return false;
     scoped_refptr<base::TaskRunner> task_runner;
     if (!base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk"))
       task_runner = base::ThreadTaskRunnerHandle::Get();
-    handle = embedder::CreateChannel(platform_channel.Pass(),
-                                     base::Bind(&DidCreateChannel),
-                                     task_runner);
+    handle =
+        embedder::CreateChannel(std::move(platform_channel),
+                                base::Bind(&DidCreateChannel), task_runner);
     // Copy of code in child_process.cc
     if (base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk")) {
       // When using the new Mojo EDK, each message pipe is backed by a platform
       // handle. The one platform handle that comes on the command line is used
       // to bind to the ChildController interface. However we also want a
       // platform handle to setup the communication channel by which we exchange
       // handles to/from tokens, which is needed for sandboxed Windows
       // processes.
       char broker_handle[10];
       MojoHandleSignalsState state;
@@ skipping 31 matching lines @@
 
 }  // namespace
 
 RunnerConnection::~RunnerConnection() {}
 
 // static
 RunnerConnection* RunnerConnection::ConnectToRunner(
     InterfaceRequest<Application>* request,
     ScopedMessagePipeHandle handle) {
   RunnerConnectionImpl* connection = new RunnerConnectionImpl;
-  if (!connection->WaitForApplicationRequest(request, handle.Pass())) {
+  if (!connection->WaitForApplicationRequest(request, std::move(handle))) {
     delete connection;
     return nullptr;
   }
   return connection;
 }
 
 RunnerConnection::RunnerConnection() {}
 
 }  // namespace runner
 }  // namespace mojo