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

mojo/edk/system/message_pipe_dispatcher.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/message_pipe_dispatcher.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_handle_utils.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/broker.h"
 #include "mojo/edk/system/configuration.h"
@@ skipping 102 matching lines @@
 }
 
 void MessagePipeDispatcher::Init(
     ScopedPlatformHandle message_pipe,
     char* serialized_read_buffer, size_t serialized_read_buffer_size,
     char* serialized_write_buffer, size_t serialized_write_buffer_size,
     std::vector<int>* serialized_read_fds,
     std::vector<int>* serialized_write_fds) {
   CHECK(transferable_);
   if (message_pipe.get().is_valid()) {
-    channel_ = RawChannel::Create(message_pipe.Pass());
+    channel_ = RawChannel::Create(std::move(message_pipe));
 
     // TODO(jam): It's probably cleaner to pass this in Init call.
     channel_->SetSerializedData(
         serialized_read_buffer, serialized_read_buffer_size,
         serialized_write_buffer, serialized_write_buffer_size,
         serialized_read_fds, serialized_write_fds);
     internal::g_io_thread_task_runner->PostTask(
         FROM_HERE, base::Bind(&MessagePipeDispatcher::InitOnIO, this));
   }
 }
@@ skipping 123 matching lines @@
   char* serialized_read_buffer = nullptr;
   size_t serialized_read_buffer_size = 0;
   char* serialized_write_buffer = nullptr;
   size_t serialized_write_buffer_size = 0;
   char* message_queue_data = nullptr;
   size_t message_queue_size = 0;
   scoped_refptr<PlatformSharedBuffer> shared_buffer;
   scoped_ptr<PlatformSharedBufferMapping> mapping;
   if (shared_memory_handle.is_valid()) {
     shared_buffer = internal::g_platform_support->CreateSharedBufferFromHandle(
-            serialization->shared_memory_size, shared_memory_handle.Pass());
+        serialization->shared_memory_size, std::move(shared_memory_handle));
     mapping = shared_buffer->Map(0, serialization->shared_memory_size);
     char* buffer = static_cast<char*>(mapping->GetBase());
     if (serialization->serialized_read_buffer_size) {
       serialized_read_buffer = buffer;
       serialized_read_buffer_size = serialization->serialized_read_buffer_size;
       buffer += serialized_read_buffer_size;
     }
     if (serialization->serialized_write_buffer_size) {
       serialized_write_buffer = buffer;
       serialized_write_buffer_size =
@@ skipping 83 matching lines @@
     }
 
     // TODO(jam): Copied below from RawChannelWin. See commment above
     // GetReadPlatformHandles.
     scoped_ptr<MessageInTransit> message(new MessageInTransit(message_view));
     if (message_view.transport_data_buffer_size() > 0) {
       DCHECK(message_view.transport_data_buffer());
       message->SetDispatchers(TransportData::DeserializeDispatchers(
           message_view.transport_data_buffer(),
           message_view.transport_data_buffer_size(),
-          temp_platform_handles.Pass()));
+          std::move(temp_platform_handles)));
     }
 
-    rv->message_queue_.AddMessage(message.Pass());
+    rv->message_queue_.AddMessage(std::move(message));
   }
 
-  rv->Init(platform_handle.Pass(),
-           serialized_read_buffer,
-           serialized_read_buffer_size,
-           serialized_write_buffer,
-           serialized_write_buffer_size,
-           &serialized_read_fds,
+  rv->Init(std::move(platform_handle), serialized_read_buffer,
+           serialized_read_buffer_size, serialized_write_buffer,
+           serialized_write_buffer_size, &serialized_read_fds,
            &serialized_write_fds);
 
   if (message_queue_size) {  // Should be empty by now.
     LOG(ERROR) << "Invalid queued messages";
     return nullptr;
   }
 
   return rv;
 }
 
@@ skipping 148 matching lines @@
 scoped_refptr<Dispatcher>
 MessagePipeDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   lock().AssertAcquired();
 
   SerializeInternal();
 
   scoped_refptr<MessagePipeDispatcher> rv(
       new MessagePipeDispatcher(transferable_));
   rv->serialized_ = true;
   if (transferable_) {
-    rv->serialized_platform_handle_ = serialized_platform_handle_.Pass();
+    rv->serialized_platform_handle_ = std::move(serialized_platform_handle_);
     serialized_message_queue_.swap(rv->serialized_message_queue_);
     serialized_read_buffer_.swap(rv->serialized_read_buffer_);
     serialized_write_buffer_.swap(rv->serialized_write_buffer_);
     serialized_fds_.swap(rv->serialized_fds_);
     rv->serialized_read_fds_length_ = serialized_read_fds_length_;
     rv->serialized_write_fds_length_ = serialized_write_fds_length_;
     rv->serialized_message_fds_length_ = serialized_message_fds_length_;
     rv->write_error_ = write_error_;
   } else {
     rv->pipe_id_ = pipe_id_;
@@ skipping 30 matching lines @@
   }
 
   message->SerializeAndCloseDispatchers();
   if (!transferable_)
     message->set_route_id(pipe_id_);
   if (!transferable_ &&
       (non_transferable_state_ == WAITING_FOR_READ_OR_WRITE ||
        non_transferable_state_ == CONNECT_CALLED)) {
     if (non_transferable_state_ == WAITING_FOR_READ_OR_WRITE)
       RequestNontransferableChannel();
-    non_transferable_outgoing_message_queue_.AddMessage(message.Pass());
+    non_transferable_outgoing_message_queue_.AddMessage(std::move(message));
   } else {
-    channel_->WriteMessage(message.Pass());
+    channel_->WriteMessage(std::move(message));
   }
 
   return MOJO_RESULT_OK;
 }
 
 MojoResult MessagePipeDispatcher::ReadMessageImplNoLock(
     void* bytes,
     uint32_t* num_bytes,
     DispatcherVector* dispatchers,
     uint32_t* num_dispatchers,
@@ skipping 228 matching lines @@
 }
 
 void MessagePipeDispatcher::OnReadMessage(
     const MessageInTransit::View& message_view,
     ScopedPlatformHandleVectorPtr platform_handles) {
   scoped_ptr<MessageInTransit> message(new MessageInTransit(message_view));
   if (message_view.transport_data_buffer_size() > 0) {
     DCHECK(message_view.transport_data_buffer());
     message->SetDispatchers(TransportData::DeserializeDispatchers(
         message_view.transport_data_buffer(),
-        message_view.transport_data_buffer_size(), platform_handles.Pass()));
+        message_view.transport_data_buffer_size(),
+        std::move(platform_handles)));
   }
 
   if (started_transport_.Try()) {
     // we're not in the middle of being sent
 
     // Can get synchronously called back in Init if there was initial data.
     scoped_ptr<base::AutoLock> locker;
     if (!calling_init_) {
       locker.reset(new base::AutoLock(lock()));
     }
 
     bool was_empty = message_queue_.IsEmpty();
-    message_queue_.AddMessage(message.Pass());
+    message_queue_.AddMessage(std::move(message));
     if (was_empty)
       awakable_list_.AwakeForStateChange(GetHandleSignalsStateImplNoLock());
 
     started_transport_.Release();
   } else {
     // If RawChannel is calling OnRead, that means it has its read_lock_
     // acquired. That means StartSerialize can't be accessing message queue as
     // it waits on ReleaseHandle first which acquires readlock_.
-    message_queue_.AddMessage(message.Pass());
+    message_queue_.AddMessage(std::move(message));
   }
 }
 
 void MessagePipeDispatcher::OnError(Error error) {
   // If there's a read error, then the other side of the pipe is closed. By
   // definition, we can't write since there's no one to read it. And we can't
   // read anymore, since we just got a read erorr. So we close the pipe.
   // If there's a write error, then we stop writing. But we keep the pipe open
   // until we finish reading everything in it. This is because it's valid for
   // one endpoint to write some data and close their pipe immediately. Even
@@ skipping 82 matching lines @@
   dispatchers->reserve(transports->size());
   for (size_t i = 0; i < transports->size(); i++) {
     if ((*transports)[i].is_valid()) {
       dispatchers->push_back(
           (*transports)[i].CreateEquivalentDispatcherAndClose());
     } else {
       LOG(WARNING) << "Enqueueing null dispatcher";
       dispatchers->push_back(nullptr);
     }
   }
-  message->SetDispatchers(dispatchers.Pass());
+  message->SetDispatchers(std::move(dispatchers));
   return MOJO_RESULT_OK;
 }
 
 void MessagePipeDispatcher::RequestNontransferableChannel() {
   lock().AssertAcquired();
   CHECK(!transferable_);
   CHECK_EQ(non_transferable_state_, WAITING_FOR_READ_OR_WRITE);
   non_transferable_state_ = CONNECT_CALLED;
 #if !defined(OFFICIAL_BUILD)
   non_transferable_bound_stack_.reset(new base::debug::StackTrace);
 #endif
 
   // PostTask since the broker can call us back synchronously.
   internal::g_io_thread_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&Broker::ConnectMessagePipe,
                  base::Unretained(internal::g_broker), pipe_id_,
                  base::Unretained(this)));
 }
 
 }  // namespace edk
 }  // namespace mojo