Global conversion of Pass()→std::move() on Linux

ipc/mojo/ipc_channel_mojo.cc

 // Copyright 2014 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 "ipc/mojo/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
@@ skipping 48 matching lines @@
       : ChannelMojo(io_runner, handle, Channel::MODE_CLIENT, listener),
         binding_(this),
         weak_factory_(this) {
   }
   ~ClientChannelMojo() override {}
 
   // MojoBootstrap::Delegate implementation
   void OnPipeAvailable(mojo::embedder::ScopedPlatformHandle handle,
                        int32_t peer_pid) override {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk")) {
-      InitMessageReader(mojo::embedder::CreateChannel(
-          handle.Pass(), base::Callback<void(mojo::embedder::ChannelInfo*)>(),
-          scoped_refptr<base::TaskRunner>()), peer_pid);
+      InitMessageReader(
+          mojo::embedder::CreateChannel(
+              std::move(handle),
+              base::Callback<void(mojo::embedder::ChannelInfo*)>(),
+              scoped_refptr<base::TaskRunner>()),
+          peer_pid);
       return;
     }
-    CreateMessagingPipe(handle.Pass(), base::Bind(&ClientChannelMojo::BindPipe,
-                                                  weak_factory_.GetWeakPtr()));
+    CreateMessagingPipe(
+        std::move(handle),
+        base::Bind(&ClientChannelMojo::BindPipe, weak_factory_.GetWeakPtr()));
   }
 
   // ClientChannel implementation
   void Init(
       mojo::ScopedMessagePipeHandle pipe,
       int32_t peer_pid,
       const mojo::Callback<void(int32_t)>& callback) override {
-   InitMessageReader(pipe.Pass(), static_cast<base::ProcessId>(peer_pid));
+    InitMessageReader(std::move(pipe), static_cast<base::ProcessId>(peer_pid));
    callback.Run(GetSelfPID());
   }
 
  private:
   void BindPipe(mojo::ScopedMessagePipeHandle handle) {
-    binding_.Bind(handle.Pass());
+    binding_.Bind(std::move(handle));
   }
   void OnConnectionError() {
     listener()->OnChannelError();
   }
 
   mojo::Binding<ClientChannel> binding_;
   base::WeakPtrFactory<ClientChannelMojo> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientChannelMojo);
 };
@@ skipping 10 matching lines @@
   }
   ~ServerChannelMojo() override {
     Close();
   }
 
   // MojoBootstrap::Delegate implementation
   void OnPipeAvailable(mojo::embedder::ScopedPlatformHandle handle,
                        int32_t peer_pid) override {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk")) {
       message_pipe_ = mojo::embedder::CreateChannel(
-          handle.Pass(), base::Callback<void(mojo::embedder::ChannelInfo*)>(),
+          std::move(handle),
+          base::Callback<void(mojo::embedder::ChannelInfo*)>(),
           scoped_refptr<base::TaskRunner>());
       if (!message_pipe_.is_valid()) {
         LOG(WARNING) << "mojo::CreateMessagePipe failed: ";
         listener()->OnChannelError();
         return;
       }
-      InitMessageReader(message_pipe_.Pass(), peer_pid);
+      InitMessageReader(std::move(message_pipe_), peer_pid);
       return;
     }
 
     mojo::ScopedMessagePipeHandle peer;
     MojoResult create_result =
         mojo::CreateMessagePipe(nullptr, &message_pipe_, &peer);
     if (create_result != MOJO_RESULT_OK) {
       LOG(WARNING) << "mojo::CreateMessagePipe failed: " << create_result;
       listener()->OnChannelError();
       return;
     }
     CreateMessagingPipe(
-        handle.Pass(),
+        std::move(handle),
         base::Bind(&ServerChannelMojo::InitClientChannel,
                    weak_factory_.GetWeakPtr(), base::Passed(&peer)));
   }
   // Channel override
   void Close() override {
     client_channel_.reset();
     message_pipe_.reset();
     ChannelMojo::Close();
   }
 
  private:
   void InitClientChannel(mojo::ScopedMessagePipeHandle peer_handle,
                          mojo::ScopedMessagePipeHandle handle) {
     client_channel_.Bind(
-        mojo::InterfacePtrInfo<ClientChannel>(handle.Pass(), 0u));
+        mojo::InterfacePtrInfo<ClientChannel>(std::move(handle), 0u));
     client_channel_.set_connection_error_handler(base::Bind(
         &ServerChannelMojo::OnConnectionError, base::Unretained(this)));
     client_channel_->Init(
-        peer_handle.Pass(), static_cast<int32_t>(GetSelfPID()),
+        std::move(peer_handle), static_cast<int32_t>(GetSelfPID()),
         base::Bind(&ServerChannelMojo::ClientChannelWasInitialized,
                    base::Unretained(this)));
   }
 
   void OnConnectionError() {
     listener()->OnChannelError();
   }
 
   // ClientChannelClient implementation
   void ClientChannelWasInitialized(int32_t peer_pid) {
-    InitMessageReader(message_pipe_.Pass(), peer_pid);
+    InitMessageReader(std::move(message_pipe_), peer_pid);
   }
 
   mojo::InterfacePtr<ClientChannel> client_channel_;
   mojo::ScopedMessagePipeHandle message_pipe_;
   base::WeakPtrFactory<ServerChannelMojo> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerChannelMojo);
 };
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
@@ skipping 102 matching lines @@
       new ScopedIPCSupport(base::MessageLoop::current()->task_runner()));
 }
 
 void ChannelMojo::CreateMessagingPipe(
     mojo::embedder::ScopedPlatformHandle handle,
     const CreateMessagingPipeCallback& callback) {
   auto return_callback = base::Bind(&ChannelMojo::OnMessagingPipeCreated,
                                     weak_factory_.GetWeakPtr(), callback);
   if (!g_use_channel_on_io_thread_only ||
       base::ThreadTaskRunnerHandle::Get() == io_runner_) {
-    CreateMessagingPipeOnIOThread(
-        handle.Pass(), base::ThreadTaskRunnerHandle::Get(), return_callback);
+    CreateMessagingPipeOnIOThread(std::move(handle),
+                                  base::ThreadTaskRunnerHandle::Get(),
+                                  return_callback);
   } else {
     io_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ChannelMojo::CreateMessagingPipeOnIOThread,
                    base::Passed(&handle), base::ThreadTaskRunnerHandle::Get(),
                    return_callback));
   }
 }
 
 // static
 void ChannelMojo::CreateMessagingPipeOnIOThread(
     mojo::embedder::ScopedPlatformHandle handle,
     scoped_refptr<base::TaskRunner> callback_runner,
     const CreateMessagingPipeOnIOThreadCallback& callback) {
   mojo::embedder::ChannelInfo* channel_info;
   mojo::ScopedMessagePipeHandle pipe =
-      mojo::embedder::CreateChannelOnIOThread(handle.Pass(), &channel_info);
+      mojo::embedder::CreateChannelOnIOThread(std::move(handle), &channel_info);
   if (base::ThreadTaskRunnerHandle::Get() == callback_runner) {
-    callback.Run(pipe.Pass(), channel_info);
+    callback.Run(std::move(pipe), channel_info);
   } else {
     callback_runner->PostTask(
         FROM_HERE, base::Bind(callback, base::Passed(&pipe), channel_info));
   }
 }
 
 void ChannelMojo::OnMessagingPipeCreated(
     const CreateMessagingPipeCallback& callback,
     mojo::ScopedMessagePipeHandle handle,
     mojo::embedder::ChannelInfo* channel_info) {
   DCHECK(!channel_info_.get());
   channel_info_ = scoped_ptr<mojo::embedder::ChannelInfo, ChannelInfoDeleter>(
       channel_info, ChannelInfoDeleter(io_runner_));
-  callback.Run(handle.Pass());
+  callback.Run(std::move(handle));
 }
 
 bool ChannelMojo::Connect() {
   DCHECK(!message_reader_);
   return bootstrap_->Connect();
 }
 
 void ChannelMojo::Close() {
   scoped_ptr<internal::MessagePipeReader, ReaderDeleter> to_be_deleted;
 
   {
     // |message_reader_| has to be cleared inside the lock,
     // but the instance has to be deleted outside.
     base::AutoLock l(lock_);
-    to_be_deleted = message_reader_.Pass();
+    to_be_deleted = std::move(message_reader_);
     // We might Close() before we Connect().
     waiting_connect_ = false;
   }
 
   channel_info_.reset();
   ipc_support_.reset();
   to_be_deleted.reset();
 }
 
 void ChannelMojo::OnBootstrapError() {
@@ skipping 11 matching lines @@
     ptr->CloseWithErrorIfPending();
     delete ptr;
   }
 };
 
 } // namespace
 
 void ChannelMojo::InitMessageReader(mojo::ScopedMessagePipeHandle pipe,
                                     int32_t peer_pid) {
   scoped_ptr<internal::MessagePipeReader, ClosingDeleter> reader(
-      new internal::MessagePipeReader(pipe.Pass(), this));
+      new internal::MessagePipeReader(std::move(pipe), this));
 
   {
     base::AutoLock l(lock_);
     for (size_t i = 0; i < pending_messages_.size(); ++i) {
       bool sent = reader->Send(make_scoped_ptr(pending_messages_[i]));
       pending_messages_[i] = nullptr;
       if (!sent) {
         // OnChannelError() is notified through ClosingDeleter.
         pending_messages_.clear();
         LOG(ERROR)  << "Failed to flush pending messages";
@@ skipping 143 matching lines @@
     if (!ok) {
       LOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
 
   return MOJO_RESULT_OK;
 }
 
 }  // namespace IPC