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

mojo/edk/system/raw_channel.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 "mojo/edk/system/raw_channel.h"
 
 #include <string.h>
-
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/transport_data.h"
 
@@ skipping 256 matching lines @@
   }
 
   // Normally, we want to flush any pending writes before shutting down. This
   // doesn't apply when 1) we don't have a handle (for obvious reasons),
   // 2) we have a read or write error before (doesn't matter which), or 3) when
   // there are no pending messages to be written.
   if (!IsHandleValid() || error_occurred_ || empty) {
     {
       base::AutoLock read_locker(read_lock_);
       base::AutoLock locker(write_lock_);
-      OnShutdownNoLock(read_buffer_.Pass(), write_buffer_.Pass());
+      OnShutdownNoLock(std::move(read_buffer_), std::move(write_buffer_));
     }
 
     if (initialized_) {
       base::MessageLoop::current()->RemoveDestructionObserver(this);
     }
     delete this;
     return;
   }
 
   base::AutoLock read_locker(read_lock_);
@@ skipping 31 matching lines @@
 
 // Reminder: This must be thread-safe.
 bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
   DCHECK(message);
   EnsureLazyInitialized();
   base::AutoLock locker(write_lock_);
   if (write_stopped_)
     return false;
 
   bool queue_was_empty = write_buffer_->message_queue_.IsEmpty();
-  EnqueueMessageNoLock(message.Pass());
+  EnqueueMessageNoLock(std::move(message));
   if (queue_was_empty && write_ready_)
     return SendQueuedMessagesNoLock();
 
   return true;
 }
 
 bool RawChannel::SendQueuedMessagesNoLock() {
   DCHECK_EQ(write_buffer_->data_offset_, 0u);
 
   size_t platform_handles_written = 0;
@@ skipping 42 matching lines @@
 
     uint32_t offset = 0;
     while (offset < serialized_write_buffer_size) {
       uint32_t message_num_bytes =
           std::min(static_cast<uint32_t>(max_message_num_bytes),
                    static_cast<uint32_t>(serialized_write_buffer_size) -
                        offset);
       scoped_ptr<MessageInTransit> message(new MessageInTransit(
           MessageInTransit::Type::RAW_MESSAGE, message_num_bytes,
           static_cast<const char*>(serialized_write_buffer) + offset));
-      write_buffer_->message_queue_.AddMessage(message.Pass());
+      write_buffer_->message_queue_.AddMessage(std::move(message));
       offset += message_num_bytes;
     }
   }
 }
 
 void RawChannel::OnReadCompletedNoLock(IOResult io_result, size_t bytes_read) {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   read_lock_.AssertAcquired();
   // Keep reading data in a loop, and dispatch messages if enough data is
   // received. Exit the loop if any of the following happens:
@@ skipping 107 matching lines @@
     for (size_t i = 0; i < buffers.size(); ++i) {
       buffer->insert(buffer->end(), buffers[i].addr,
                      buffers[i].addr + buffers[i].size);
     }
     write_buffer_->message_queue_.DiscardMessage();
   }
 }
 
 void RawChannel::EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) {
   write_lock_.AssertAcquired();
-  write_buffer_->message_queue_.AddMessage(message.Pass());
+  write_buffer_->message_queue_.AddMessage(std::move(message));
 }
 
 bool RawChannel::OnReadMessageForRawChannel(
     const MessageInTransit::View& message_view) {
   LOG(ERROR) << "Invalid control message (type " << message_view.type()
              << ")";
   return false;
 }
 
 RawChannel::Delegate::Error RawChannel::ReadIOResultToError(
@@ skipping 113 matching lines @@
     } else {
       ScopedPlatformHandleVectorPtr platform_handles;
       if (message_view.transport_data_buffer()) {
         size_t num_platform_handles;
         const void* platform_handle_table;
         TransportData::GetPlatformHandleTable(
             message_view.transport_data_buffer(), &num_platform_handles,
             &platform_handle_table);
 
         if (num_platform_handles > 0) {
-          platform_handles =
-              GetReadPlatformHandles(num_platform_handles,
-                                      platform_handle_table).Pass();
+          platform_handles = GetReadPlatformHandles(num_platform_handles,
+                                                    platform_handle_table);
           if (!platform_handles) {
             LOG(ERROR) << "Invalid number of platform handles received";
             CallOnError(Delegate::ERROR_READ_BAD_MESSAGE);
             *stop_dispatching = true;
             return;  // |this| may have been destroyed in |CallOnError()|.
           }
         }
       }
 
       // TODO(vtl): In the case that we aren't expecting any platform handles,
       // for the POSIX implementation, we should confirm that none are stored.
       if (delegate_) {
         DCHECK(!calling_delegate_);
         calling_delegate_ = true;
-        delegate_->OnReadMessage(message_view, platform_handles.Pass());
+        delegate_->OnReadMessage(message_view, std::move(platform_handles));
         calling_delegate_ = false;
       }
     }
 
     *did_dispatch_message = true;
 
     // Update our state.
     read_buffer_start += message_size;
     remaining_bytes -= message_size;
   }
@@ skipping 29 matching lines @@
   OnReadCompletedNoLock(io_result, bytes_read);
 }
 
 void RawChannel::WillDestroyCurrentMessageLoop() {
   base::AutoLock locker(read_lock_);
   OnReadCompletedNoLock(IO_FAILED_SHUTDOWN, 0);
 }
 
 }  // namespace edk
 }  // namespace mojo