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

mojo/edk/system/routed_raw_channel.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/routed_raw_channel.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 
 namespace mojo {
 namespace edk {
 
 namespace {
 const uint64_t kInternalRouteId = 0;
 }
 
 RoutedRawChannel::PendingMessage::PendingMessage() {
 }
 
 RoutedRawChannel::PendingMessage::~PendingMessage() {
 }
 
 RoutedRawChannel::RoutedRawChannel(
     ScopedPlatformHandle handle,
     const base::Callback<void(RoutedRawChannel*)>& destruct_callback)
-    : channel_(RawChannel::Create(handle.Pass())),
+    : channel_(RawChannel::Create(std::move(handle))),
       destruct_callback_(destruct_callback) {
   internal::g_io_thread_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&RawChannel::Init, base::Unretained(channel_), this));
   internal::g_io_thread_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&RawChannel::EnsureLazyInitialized,
                   base::Unretained(channel_)));
 }
 
 void RoutedRawChannel::AddRoute(uint64_t route_id,
                                 RawChannel::Delegate* delegate) {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   CHECK_NE(route_id, kInternalRouteId) << kInternalRouteId << " is reserved";
   CHECK(routes_.find(route_id) == routes_.end());
   routes_[route_id] = delegate;
 
   for (size_t i = 0; i < pending_messages_.size();) {
     MessageInTransit::View view(pending_messages_[i]->message.size(),
                                 &pending_messages_[i]->message[0]);
     if (view.route_id() == route_id) {
-      delegate->OnReadMessage(view, pending_messages_[i]->handles.Pass());
+      delegate->OnReadMessage(view, std::move(pending_messages_[i]->handles));
       pending_messages_.erase(pending_messages_.begin() + i);
     } else {
       ++i;
     }
   }
 
   if (close_routes_.find(route_id) != close_routes_.end())
     delegate->OnError(ERROR_READ_SHUTDOWN);
 }
 
@@ skipping 10 matching lines @@
   if (close_routes_.find(route_id) != close_routes_.end()) {
     close_routes_.erase(route_id);
   } else if (channel_) {
     // Default route id of 0 to reach the other side's RoutedRawChannel.
     char message_data[sizeof(uint64_t)];
     memcpy(&message_data[0], &route_id, sizeof(uint64_t));
     scoped_ptr<MessageInTransit> message(new MessageInTransit(
         MessageInTransit::Type::MESSAGE, arraysize(message_data),
           message_data));
     message->set_route_id(kInternalRouteId);
-    channel_->WriteMessage(message.Pass());
+    channel_->WriteMessage(std::move(message));
   }
 
   if (!channel_ && routes_.empty()) {
     // PostTask to avoid reentrancy since the broker might be calling us.
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 }
 
 RoutedRawChannel::~RoutedRawChannel() {
   DCHECK(!channel_);
@@ skipping 23 matching lines @@
     }
     close_routes_.insert(closed_route);
     if (routes_.find(closed_route) == routes_.end())
       return;  // This side hasn't connected yet.
 
     routes_[closed_route]->OnError(ERROR_READ_SHUTDOWN);
     return;
   }
 
   if (routes_.find(route_id) != routes_.end()) {
-    routes_[route_id]->OnReadMessage(message_view, platform_handles.Pass());
+    routes_[route_id]->OnReadMessage(message_view, std::move(platform_handles));
   } else {
     scoped_ptr<PendingMessage> msg(new PendingMessage);
     msg->message.resize(message_view.total_size());
     memcpy(&msg->message[0], message_view.main_buffer(),
            message_view.total_size());
-    msg->handles = platform_handles.Pass();
-    pending_messages_.push_back(msg.Pass());
+    msg->handles = std::move(platform_handles);
+    pending_messages_.push_back(std::move(msg));
   }
 }
 
 void RoutedRawChannel::OnError(Error error) {
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
 
   // Note: we must ensure we don't call RawChannel::Shutdown until after we've
   // called OnError on each route's delegate.
   for (auto it = routes_.begin(); it != routes_.end();) {
     // The delegate might call RemoveRoute in their OnError implementation which
     // would invalidate |it|. So increment it first.
     auto cur_it = it++;
     cur_it->second->OnError(error);
   }
 
   if (routes_.empty()) {
     channel_->Shutdown();
     channel_ = nullptr;
     delete this;
     return;
   }
 }
 
 }  // namespace edk
 }  // namespace mojo