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

mojo/edk/system/remote_consumer_data_pipe_impl.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/remote_consumer_data_pipe_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
+#include <memory>
+#include <utility>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/remote_data_pipe_ack.h"
 
 namespace mojo {
 namespace system {
 
@@ skipping 66 matching lines @@
 // static
 bool RemoteConsumerDataPipeImpl::ProcessMessagesFromIncomingEndpoint(
     const MojoCreateDataPipeOptions& validated_options,
     size_t* consumer_num_bytes,
     MessageInTransitQueue* messages) {
   const size_t element_num_bytes = validated_options.element_num_bytes;
   const size_t capacity_num_bytes = validated_options.capacity_num_bytes;
 
   if (messages) {
     while (!messages->IsEmpty()) {
-      scoped_ptr<MessageInTransit> message(messages->GetMessage());
+      std::unique_ptr<MessageInTransit> message(messages->GetMessage());
       if (!ValidateIncomingMessage(element_num_bytes, capacity_num_bytes,
                                    *consumer_num_bytes, message.get())) {
         messages->Clear();
         return false;
       }
 
       const RemoteDataPipeAck* ack =
           static_cast<const RemoteDataPipeAck*>(message->bytes());
       size_t num_bytes_consumed = ack->num_bytes_consumed;
       *consumer_num_bytes -= num_bytes_consumed;
@@ skipping 31 matching lines @@
   // element size.
   // TODO(vtl): Copied from |LocalDataPipeImpl::ConvertDataToMessages()|.
   size_t max_message_num_bytes = GetConfiguration().max_message_num_bytes;
   max_message_num_bytes -= max_message_num_bytes % element_num_bytes();
   DCHECK_GT(max_message_num_bytes, 0u);
 
   size_t offset = 0;
   while (offset < num_bytes_to_write) {
     size_t message_num_bytes =
         std::min(max_message_num_bytes, num_bytes_to_write - offset);
-    scoped_ptr<MessageInTransit> message(new MessageInTransit(
+    std::unique_ptr<MessageInTransit> message(new MessageInTransit(
         MessageInTransit::Type::ENDPOINT_CLIENT,
         MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA,
         static_cast<uint32_t>(message_num_bytes), elements.At(offset)));
-    if (!channel_endpoint_->EnqueueMessage(message.Pass())) {
+    if (!channel_endpoint_->EnqueueMessage(std::move(message))) {
       Disconnect();
       break;
     }
 
     offset += message_num_bytes;
     consumer_num_bytes_ += message_num_bytes;
   }
 
   DCHECK_LE(consumer_num_bytes_, capacity_num_bytes());
   // TODO(vtl): We report |num_bytes_to_write|, instead of |offset|, even if we
@@ skipping 54 matching lines @@
   // element size.
   // TODO(vtl): Mostly copied from |LocalDataPipeImpl::ConvertDataToMessages()|.
   size_t max_message_num_bytes = GetConfiguration().max_message_num_bytes;
   max_message_num_bytes -= max_message_num_bytes % element_num_bytes();
   DCHECK_GT(max_message_num_bytes, 0u);
 
   size_t offset = 0;
   while (offset < num_bytes_written) {
     size_t message_num_bytes =
         std::min(max_message_num_bytes, num_bytes_written - offset);
-    scoped_ptr<MessageInTransit> message(new MessageInTransit(
+    std::unique_ptr<MessageInTransit> message(new MessageInTransit(
         MessageInTransit::Type::ENDPOINT_CLIENT,
         MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA,
         static_cast<uint32_t>(message_num_bytes), buffer_.get() + offset));
-    if (!channel_endpoint_->EnqueueMessage(message.Pass())) {
+    if (!channel_endpoint_->EnqueueMessage(std::move(message))) {
       set_producer_two_phase_max_num_bytes_written(0);
       Disconnect();
       return MOJO_RESULT_OK;
     }
 
     offset += message_num_bytes;
     consumer_num_bytes_ += message_num_bytes;
   }
 
   DCHECK_LE(consumer_num_bytes_, capacity_num_bytes());
@@ skipping 121 matching lines @@
     size_t* /*actual_size*/,
     embedder::PlatformHandleVector* /*platform_handles*/) {
   NOTREACHED();
   return false;
 }
 
 bool RemoteConsumerDataPipeImpl::OnReadMessage(unsigned /*port*/,
                                                MessageInTransit* message) {
   // Always take ownership of the message. (This means that we should always
   // return true.)
-  scoped_ptr<MessageInTransit> msg(message);
+  std::unique_ptr<MessageInTransit> msg(message);
 
   if (!ValidateIncomingMessage(element_num_bytes(), capacity_num_bytes(),
                                consumer_num_bytes_, msg.get())) {
     Disconnect();
     return true;
   }
 
   const RemoteDataPipeAck* ack =
       static_cast<const RemoteDataPipeAck*>(msg->bytes());
   size_t num_bytes_consumed = ack->num_bytes_consumed;
@@ skipping 34 matching lines @@
   DCHECK(channel_endpoint_);
   SetConsumerClosed();
   channel_endpoint_->DetachFromClient();
   channel_endpoint_ = nullptr;
   if (!producer_in_two_phase_write())
     DestroyBuffer();
 }
 
 }  // namespace system
 }  // namespace mojo