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

mojo/edk/system/remote_producer_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_producer_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/message_in_transit_queue.h"
 #include "mojo/edk/system/remote_consumer_data_pipe_impl.h"
 #include "mojo/edk/system/remote_data_pipe_ack.h"
 
 namespace mojo {
@@ skipping 66 matching lines @@
   const size_t element_num_bytes = validated_options.element_num_bytes;
   const size_t capacity_num_bytes = validated_options.capacity_num_bytes;
 
   std::unique_ptr<char, base::AlignedFreeDeleter> new_buffer(static_cast<char*>(
       base::AlignedAlloc(capacity_num_bytes,
                          GetConfiguration().data_pipe_buffer_alignment_bytes)));
 
   size_t current_num_bytes = 0;
   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,
                                    current_num_bytes, message.get())) {
         messages->Clear();
         return false;
       }
 
       memcpy(new_buffer.get() + current_num_bytes, message->bytes(),
              message->num_bytes());
       current_num_bytes += message->num_bytes();
     }
@@ skipping 243 matching lines @@
     // |OnReadMessage()| is racing with us calling
     // |ChannelEndpoint::ReplaceClient()|, in which case we reject the message,
     // and the |ChannelEndpoint| can retry (calling the new client's
     // |OnReadMessage()|).
     DCHECK(!channel_endpoint_);
     return false;
   }
 
   // Otherwise, we take ownership of the message. (This means that we should
   // always return true below.)
-  scoped_ptr<MessageInTransit> msg(message);
+  std::unique_ptr<MessageInTransit> msg(message);
 
   if (!ValidateIncomingMessage(element_num_bytes(), capacity_num_bytes(),
                                current_num_bytes_, msg.get())) {
     Disconnect();
     return true;
   }
 
   size_t num_bytes = msg->num_bytes();
   // The amount we can write in our first copy.
   size_t num_bytes_to_copy_first = std::min(num_bytes, GetMaxNumBytesToWrite());
@@ skipping 68 matching lines @@
   start_index_ %= capacity_num_bytes();
   current_num_bytes_ -= num_bytes;
 
   if (!producer_open()) {
     DCHECK(!channel_endpoint_);
     return;
   }
 
   RemoteDataPipeAck ack_data = {};
   ack_data.num_bytes_consumed = static_cast<uint32_t>(num_bytes);
-  scoped_ptr<MessageInTransit> message(new MessageInTransit(
+  std::unique_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::ENDPOINT_CLIENT,
       MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA_PIPE_ACK,
       static_cast<uint32_t>(sizeof(ack_data)), &ack_data));
-  if (!channel_endpoint_->EnqueueMessage(message.Pass()))
+  if (!channel_endpoint_->EnqueueMessage(std::move(message)))
     Disconnect();
 }
 
 void RemoteProducerDataPipeImpl::Disconnect() {
   DCHECK(producer_open());
   DCHECK(channel_endpoint_);
   SetProducerClosed();
   channel_endpoint_->DetachFromClient();
   channel_endpoint_ = nullptr;
   // If the consumer is still open and we still have data, we have to keep the
   // buffer around. Currently, we won't free it even if it empties later. (We
   // could do this -- requiring a check on every read -- but that seems to be
   // optimizing for the uncommon case.)
   if (!consumer_open() || !current_num_bytes_)
     DestroyBuffer();
 }
 
 }  // namespace system
 }  // namespace mojo