EDK: Convert remaining scoped_ptr -> std::unique_ptr in //mojo/edk/system.

mojo/edk/system/channel_endpoint.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/channel_endpoint.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint_client.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace system {
 
 ChannelEndpoint::ChannelEndpoint(ChannelEndpointClient* client,
                                  unsigned client_port,
                                  MessageInTransitQueue* message_queue)
     : state_(State::PAUSED),
       client_(client),
       client_port_(client_port),
       channel_(nullptr) {
   DCHECK(client_ || message_queue);
 
   if (message_queue)
     channel_message_queue_.Swap(message_queue);
 }
 
-bool ChannelEndpoint::EnqueueMessage(scoped_ptr<MessageInTransit> message) {
+bool ChannelEndpoint::EnqueueMessage(
+    std::unique_ptr<MessageInTransit> message) {
   DCHECK(message);
 
   MutexLocker locker(&mutex_);
 
   switch (state_) {
     case State::PAUSED:
-      channel_message_queue_.AddMessage(message.Pass());
+      channel_message_queue_.AddMessage(std::move(message));
       return true;
     case State::RUNNING:
-      return WriteMessageNoLock(message.Pass());
+      return WriteMessageNoLock(std::move(message));
     case State::DEAD:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 bool ChannelEndpoint::ReplaceClient(ChannelEndpointClient* client,
                                     unsigned client_port) {
@@ skipping 39 matching lines @@
     bool ok = WriteMessageNoLock(channel_message_queue_.GetMessage());
     LOG_IF(WARNING, !ok) << "Failed to write enqueue message to channel";
   }
 
   if (!client_) {
     channel_->DetachEndpoint(this, local_id_, remote_id_);
     DieNoLock();
   }
 }
 
-void ChannelEndpoint::OnReadMessage(scoped_ptr<MessageInTransit> message) {
+void ChannelEndpoint::OnReadMessage(std::unique_ptr<MessageInTransit> message) {
   if (message->type() == MessageInTransit::Type::ENDPOINT_CLIENT) {
-    OnReadMessageForClient(message.Pass());
+    OnReadMessageForClient(std::move(message));
     return;
   }
 
   DCHECK_EQ(message->type(), MessageInTransit::Type::ENDPOINT);
 
   // TODO(vtl)
   // Note that this won't crash on Release builds, which is important (since the
   // other side may be malicious). Doing nothing is safe and will dispose of the
   // message.
   NOTREACHED();
@@ skipping 29 matching lines @@
     client->OnDetachFromChannel(client_port);
 }
 
 ChannelEndpoint::~ChannelEndpoint() {
   DCHECK(!client_);
   DCHECK(!channel_);
   DCHECK(!local_id_.is_valid());
   DCHECK(!remote_id_.is_valid());
 }
 
-bool ChannelEndpoint::WriteMessageNoLock(scoped_ptr<MessageInTransit> message) {
+bool ChannelEndpoint::WriteMessageNoLock(
+    std::unique_ptr<MessageInTransit> message) {
   DCHECK(message);
 
   mutex_.AssertHeld();
 
   DCHECK(channel_);
   DCHECK(local_id_.is_valid());
   DCHECK(remote_id_.is_valid());
 
   message->SerializeAndCloseDispatchers(channel_);
   message->set_source_id(local_id_);
   message->set_destination_id(remote_id_);
-  return channel_->WriteMessage(message.Pass());
+  return channel_->WriteMessage(std::move(message));
 }
 
 void ChannelEndpoint::OnReadMessageForClient(
-    scoped_ptr<MessageInTransit> message) {
+    std::unique_ptr<MessageInTransit> message) {
   DCHECK_EQ(message->type(), MessageInTransit::Type::ENDPOINT_CLIENT);
 
   scoped_refptr<ChannelEndpointClient> client;
   unsigned client_port = 0;
 
   // This loop is to make |ReplaceClient()| work. We can't call the client's
   // |OnReadMessage()| under our lock, so by the time we do that, |client| may
   // no longer be our client.
   //
   // In that case, |client| must return false. We'll then yield, and retry with
@@ skipping 37 matching lines @@
   DCHECK(remote_id_.is_valid());
 
   state_ = State::DEAD;
   channel_ = nullptr;
   local_id_ = ChannelEndpointId();
   remote_id_ = ChannelEndpointId();
 }
 
 }  // namespace system
 }  // namespace mojo