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

mojo/edk/system/raw_channel_posix.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/raw_channel.h"
 
 #include <errno.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
-
 #include <algorithm>
 #include <deque>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_channel_utils_posix.h"
@@ skipping 76 matching lines @@
 
   // This is used for posting tasks from write threads to the I/O thread. It
   // must only be accessed under |write_lock_|. The weak pointers it produces
   // are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannelPosix> weak_ptr_factory_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannelPosix);
 };
 
 RawChannelPosix::RawChannelPosix(ScopedPlatformHandle handle)
-    : fd_(handle.Pass()),
+    : fd_(std::move(handle)),
       pending_read_(false),
       pending_write_(false),
       weak_ptr_factory_(this) {
   DCHECK(fd_.is_valid());
 }
 
 RawChannelPosix::~RawChannelPosix() {
   DCHECK(!pending_read_);
   DCHECK(!pending_write_);
 
@@ skipping 22 matching lines @@
       size_t i = 0;
       for (; platform_handles->size() - i > kPlatformChannelMaxNumHandles;
            i += kPlatformChannelMaxNumHandles) {
         scoped_ptr<MessageInTransit> fd_message(new MessageInTransit(
             MessageInTransit::Type::RAW_CHANNEL_POSIX_EXTRA_PLATFORM_HANDLES, 0,
             nullptr));
         ScopedPlatformHandleVectorPtr fds(
             new PlatformHandleVector(
                 platform_handles->begin() + i,
                 platform_handles->begin() + i + kPlatformChannelMaxNumHandles));
-        fd_message->SetTransportData(make_scoped_ptr(
-            new TransportData(fds.Pass(), GetSerializedPlatformHandleSize())));
-        RawChannel::EnqueueMessageNoLock(fd_message.Pass());
+        fd_message->SetTransportData(make_scoped_ptr(new TransportData(
+            std::move(fds), GetSerializedPlatformHandleSize())));
+        RawChannel::EnqueueMessageNoLock(std::move(fd_message));
       }
 
       // Remove the handles that we "moved" into the other messages.
       platform_handles->erase(platform_handles->begin(),
                               platform_handles->begin() + i);
     }
   }
 
-  RawChannel::EnqueueMessageNoLock(message.Pass());
+  RawChannel::EnqueueMessageNoLock(std::move(message));
 }
 
 bool RawChannelPosix::OnReadMessageForRawChannel(
     const MessageInTransit::View& message_view) {
   if (message_view.type() ==
       MessageInTransit::Type::RAW_CHANNEL_POSIX_EXTRA_PLATFORM_HANDLES) {
     // We don't need to do anything. |RawChannel| won't extract the platform
     // handles, and they'll be accumulated in |Read()|.
     return true;
   }
@@ skipping 12 matching lines @@
   write_watcher_.reset();
 
   SerializeReadBuffer(0u, serialized_read_buffer);
   SerializeWriteBuffer(0u, 0u, serialized_write_buffer, serialized_write_fds);
 
   while (!read_platform_handles_.empty()) {
     serialized_read_fds->push_back(read_platform_handles_.front().handle);
     read_platform_handles_.pop_front();
   }
 
-  return fd_.Pass();
+  return std::move(fd_);
 }
 
 void RawChannelPosix::SetSerializedFDs(
     std::vector<int>* serialized_read_fds,
     std::vector<int>* serialized_write_fds) {
   if (serialized_read_fds) {
     for(auto i: *serialized_read_fds)
       read_platform_handles_.push_back(PlatformHandle(i));
   }
 
   if (serialized_write_fds) {
     size_t i = 0;
     while (i < serialized_write_fds->size()) {
       size_t batch = std::min(kPlatformChannelMaxNumHandles,
                               serialized_write_fds->size() - i);
       scoped_ptr<MessageInTransit> fd_message(new MessageInTransit(
           MessageInTransit::Type::RAW_CHANNEL_POSIX_EXTRA_PLATFORM_HANDLES, 0,
           nullptr));
       ScopedPlatformHandleVectorPtr fds(
           new PlatformHandleVector(serialized_write_fds->begin() + i,
                                    serialized_write_fds->begin() + i + batch));
-      fd_message->SetTransportData(make_scoped_ptr(
-          new TransportData(fds.Pass(), GetSerializedPlatformHandleSize())));
-      RawChannel::EnqueueMessageNoLock(fd_message.Pass());
+      fd_message->SetTransportData(make_scoped_ptr(new TransportData(
+          std::move(fds), GetSerializedPlatformHandleSize())));
+      RawChannel::EnqueueMessageNoLock(std::move(fd_message));
       i += batch;
     }
   }
 }
 
 bool RawChannelPosix::IsHandleValid() {
   return fd_.is_valid();
 }
 
 RawChannel::IOResult RawChannelPosix::Read(size_t* bytes_read) {
@@ skipping 28 matching lines @@
     return ScopedPlatformHandleVectorPtr();
   }
 
   ScopedPlatformHandleVectorPtr rv(
       new PlatformHandleVector(num_platform_handles));
   rv->assign(read_platform_handles_.begin(),
              read_platform_handles_.begin() + num_platform_handles);
   read_platform_handles_.erase(
       read_platform_handles_.begin(),
       read_platform_handles_.begin() + num_platform_handles);
-  return rv.Pass();
+  return rv;
 }
 
 size_t RawChannelPosix::SerializePlatformHandles(std::vector<int>* fds) {
   if (!write_buffer_no_lock()->HavePlatformHandlesToSend())
     return 0u;
 
   size_t num_platform_handles;
   PlatformHandle* platform_handles;
   void* serialization_data;  // Actually unused.
   write_buffer_no_lock()->GetPlatformHandlesToSend(
@@ skipping 267 matching lines @@
   }
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
 RawChannel* RawChannel::Create(ScopedPlatformHandle handle) {
-  return new RawChannelPosix(handle.Pass());
+  return new RawChannelPosix(std::move(handle));
 }
 
 size_t RawChannel::GetSerializedPlatformHandleSize() {
   // We don't actually need any space on POSIX (since we just send FDs).
   return 0;
 }
 
 bool RawChannel::IsOtherEndOf(RawChannel* other) {
 #if defined(OFFICIAL_BUILD)
   return false;
@@ skipping 12 matching lines @@
   socklen_t peek_off_size = sizeof(id1);
   getsockopt(this_handle.handle, SOL_SOCKET, SO_PEEK_OFF, &id1, &peek_off_size);
   getsockopt(other_handle.handle, SOL_SOCKET, SO_PEEK_OFF, &id2,
              &peek_off_size);
   return id1 == id2;
 #endif
 }
 
 }  // namespace edk
 }  // namespace mojo