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

mojo/edk/system/message_pipe.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/message_pipe.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/incoming_endpoint.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/message_pipe_endpoint.h"
 #include "mojo/edk/system/proxy_message_pipe_endpoint.h"
+#include "mojo/edk/util/make_unique.h"
 
 namespace mojo {
 namespace system {
 
 // static
 MessagePipe* MessagePipe::CreateLocalLocal() MOJO_NO_THREAD_SAFETY_ANALYSIS {
   MessagePipe* message_pipe = new MessagePipe();
   message_pipe->endpoints_[0].reset(new LocalMessagePipeEndpoint());
   message_pipe->endpoints_[1].reset(new LocalMessagePipeEndpoint());
   return message_pipe;
@@ skipping 119 matching lines @@
     unsigned port,
     UserPointer<const void> bytes,
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
   DCHECK(port == 0 || port == 1);
 
   MutexLocker locker(&mutex_);
   return EnqueueMessageNoLock(
       GetPeerPort(port),
-      make_scoped_ptr(new MessageInTransit(
+      util::MakeUnique<MessageInTransit>(
           MessageInTransit::Type::ENDPOINT_CLIENT,
-          MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA, num_bytes, bytes)),
+          MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA, num_bytes, bytes),
       transports);
 }
 
 MojoResult MessagePipe::ReadMessage(unsigned port,
                                     UserPointer<void> bytes,
                                     UserPointer<uint32_t> num_bytes,
                                     DispatcherVector* dispatchers,
                                     uint32_t* num_dispatchers,
                                     MojoReadMessageFlags flags) {
   DCHECK(port == 0 || port == 1);
@@ skipping 115 matching lines @@
     // |ChannelEndpoint::ReplaceClient()|, in which case we reject the message,
     // and the |ChannelEndpoint| can retry (calling the new client's
     // |OnReadMessage()|).
     return false;
   }
 
   // This is called when the |ChannelEndpoint| for the
   // |ProxyMessagePipeEndpoint| |port| receives a message (from the |Channel|).
   // We need to pass this message on to its peer port (typically a
   // |LocalMessagePipeEndpoint|).
-  MojoResult result = EnqueueMessageNoLock(GetPeerPort(port),
-                                           make_scoped_ptr(message), nullptr);
+  MojoResult result = EnqueueMessageNoLock(
+      GetPeerPort(port), std::unique_ptr<MessageInTransit>(message), nullptr);
   DLOG_IF(WARNING, result != MOJO_RESULT_OK)
       << "EnqueueMessageNoLock() failed (result  = " << result << ")";
   return true;
 }
 
 void MessagePipe::OnDetachFromChannel(unsigned port) {
   Close(port);
 }
 
 MessagePipe::MessagePipe() {
 }
 
 MessagePipe::~MessagePipe() {
   // Owned by the dispatchers. The owning dispatchers should only release us via
   // their |Close()| method, which should inform us of being closed via our
   // |Close()|. Thus these should already be null.
   DCHECK(!endpoints_[0]);
   DCHECK(!endpoints_[1]);
 }
 
 MojoResult MessagePipe::EnqueueMessageNoLock(
     unsigned port,
-    scoped_ptr<MessageInTransit> message,
+    std::unique_ptr<MessageInTransit> message,
     std::vector<DispatcherTransport>* transports) {
   DCHECK(port == 0 || port == 1);
   DCHECK(message);
 
   DCHECK_EQ(message->type(), MessageInTransit::Type::ENDPOINT_CLIENT);
   DCHECK(endpoints_[GetPeerPort(port)]);
 
   // The destination port need not be open, unlike the source port.
   if (!endpoints_[port])
     return MOJO_RESULT_FAILED_PRECONDITION;
 
   if (transports) {
     MojoResult result = AttachTransportsNoLock(port, message.get(), transports);
     if (result != MOJO_RESULT_OK)
       return result;
   }
 
   // The endpoint's |EnqueueMessage()| may not report failure.
-  endpoints_[port]->EnqueueMessage(message.Pass());
+  endpoints_[port]->EnqueueMessage(std::move(message));
   return MOJO_RESULT_OK;
 }
 
 MojoResult MessagePipe::AttachTransportsNoLock(
     unsigned port,
     MessageInTransit* message,
     std::vector<DispatcherTransport>* transports) {
   DCHECK(!message->has_dispatchers());
 
   // You're not allowed to send either handle to a message pipe over the message
@@ skipping 29 matching lines @@
       LOG(WARNING) << "Enqueueing null dispatcher";
       dispatchers->push_back(nullptr);
     }
   }
   message->SetDispatchers(std::move(dispatchers));
   return MOJO_RESULT_OK;
 }
 
 }  // namespace system
 }  // namespace mojo