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

mojo/edk/system/data_pipe_consumer_dispatcher.cc

 // Copyright 2013 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/data_pipe_consumer_dispatcher.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/data_pipe.h"
 
 namespace mojo {
 namespace edk {
 
 struct SharedMemoryHeader {
   uint32_t data_size;
   uint32_t read_buffer_size;
 };
 
 void DataPipeConsumerDispatcher::Init(
     ScopedPlatformHandle message_pipe,
     char* serialized_read_buffer, size_t serialized_read_buffer_size) {
   if (message_pipe.is_valid()) {
-    channel_ = RawChannel::Create(message_pipe.Pass());
+    channel_ = RawChannel::Create(std::move(message_pipe));
     channel_->SetSerializedData(
         serialized_read_buffer, serialized_read_buffer_size, nullptr, 0u,
         nullptr, nullptr);
     internal::g_io_thread_task_runner->PostTask(
         FROM_HERE, base::Bind(&DataPipeConsumerDispatcher::InitOnIO, this));
   } else {
     // The data pipe consumer could have read all the data and the producer
     // closed its end subsequently (before the consumer was sent). In that case
     // when we deserialize the consumer we must make sure to set error_ or
     // otherwise the peer-closed signal will never be satisfied.
@@ skipping 35 matching lines @@
       &shared_memory_handle, &shared_memory_size);
 
   scoped_refptr<DataPipeConsumerDispatcher> rv(Create(options));
 
   char* serialized_read_buffer = nullptr;
   size_t serialized_read_buffer_size = 0;
   scoped_refptr<PlatformSharedBuffer> shared_buffer;
   scoped_ptr<PlatformSharedBufferMapping> mapping;
   if (shared_memory_size) {
     shared_buffer = internal::g_platform_support->CreateSharedBufferFromHandle(
-        shared_memory_size, shared_memory_handle.Pass());
+        shared_memory_size, std::move(shared_memory_handle));
     mapping = shared_buffer->Map(0, shared_memory_size);
     char* buffer = static_cast<char*>(mapping->GetBase());
     SharedMemoryHeader* header = reinterpret_cast<SharedMemoryHeader*>(buffer);
     buffer += sizeof(SharedMemoryHeader);
     if (header->data_size) {
       rv->data_.assign(buffer, buffer + header->data_size);
       buffer += header->data_size;
     }
 
     if (header->read_buffer_size) {
       serialized_read_buffer = buffer;
       serialized_read_buffer_size = header->read_buffer_size;
       buffer += header->read_buffer_size;
     }
   }
 
-  rv->Init(platform_handle.Pass(), serialized_read_buffer,
+  rv->Init(std::move(platform_handle), serialized_read_buffer,
            serialized_read_buffer_size);
   return rv;
 }
 
 DataPipeConsumerDispatcher::DataPipeConsumerDispatcher(
     const MojoCreateDataPipeOptions& options)
     : options_(options),
       channel_(nullptr),
       calling_init_(false),
       in_two_phase_read_(false),
@@ skipping 23 matching lines @@
 
 scoped_refptr<Dispatcher>
 DataPipeConsumerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   lock().AssertAcquired();
 
   SerializeInternal();
 
   scoped_refptr<DataPipeConsumerDispatcher> rv = Create(options_);
   data_.swap(rv->data_);
   serialized_read_buffer_.swap(rv->serialized_read_buffer_);
-  rv->serialized_platform_handle_ = serialized_platform_handle_.Pass();
+  rv->serialized_platform_handle_ = std::move(serialized_platform_handle_);
   rv->serialized_ = true;
 
   return scoped_refptr<Dispatcher>(rv.get());
 }
 
 MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock(
     void* elements,
     uint32_t* num_bytes,
     MojoReadDataFlags flags) {
   lock().AssertAcquired();
@@ skipping 209 matching lines @@
 
     if (!serialized_read_buffer_.empty()) {
       memcpy(start, &serialized_read_buffer_[0],
              serialized_read_buffer_.size());
       start += serialized_read_buffer_.size();
     }
 
     shared_memory_handle.reset(shared_buffer->PassPlatformHandle().release());
   }
 
-  DataPipe::EndSerialize(
-      options_,
-      serialized_platform_handle_.Pass(),
-      shared_memory_handle.Pass(), shared_memory_size,
-      destination, actual_size, platform_handles);
+  DataPipe::EndSerialize(options_, std::move(serialized_platform_handle_),
+                         std::move(shared_memory_handle), shared_memory_size,
+                         destination, actual_size, platform_handles);
   CloseImplNoLock();
   return true;
 }
 
 void DataPipeConsumerDispatcher::TransportStarted() {
   started_transport_.Acquire();
 }
 
 void DataPipeConsumerDispatcher::TransportEnded() {
   started_transport_.Release();
@@ skipping 101 matching lines @@
     CHECK(!write_error) << "DataPipeConsumerDispatcher doesn't write.";
 
     channel_ = nullptr;
   }
 
   serialized_ = true;
 }
 
 }  // namespace edk
 }  // namespace mojo