Some easy conversions of scoped_ptr -> std::unique_ptr in the EDK.

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 <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"
@@ skipping 41 matching lines @@
 RemoteProducerDataPipeImpl::RemoteProducerDataPipeImpl(
     ChannelEndpoint* channel_endpoint)
     : channel_endpoint_(channel_endpoint),
       start_index_(0),
       current_num_bytes_(0) {
   // Note: |buffer_| is lazily allocated.
 }
 
 RemoteProducerDataPipeImpl::RemoteProducerDataPipeImpl(
     ChannelEndpoint* channel_endpoint,
-    scoped_ptr<char, base::AlignedFreeDeleter> buffer,
+    std::unique_ptr<char, base::AlignedFreeDeleter> buffer,
     size_t start_index,
     size_t current_num_bytes)
     : channel_endpoint_(channel_endpoint),
-      buffer_(buffer.Pass()),
+      buffer_(std::move(buffer)),
       start_index_(start_index),
       current_num_bytes_(current_num_bytes) {
   DCHECK(buffer_ || !current_num_bytes);
 }
 
 // static
 bool RemoteProducerDataPipeImpl::ProcessMessagesFromIncomingEndpoint(
     const MojoCreateDataPipeOptions& validated_options,
     MessageInTransitQueue* messages,
-    scoped_ptr<char, base::AlignedFreeDeleter>* buffer,
+    std::unique_ptr<char, base::AlignedFreeDeleter>* buffer,
     size_t* buffer_num_bytes) {
   DCHECK(!*buffer);  // Not wrong, but unlikely.
 
   const size_t element_num_bytes = validated_options.element_num_bytes;
   const size_t capacity_num_bytes = validated_options.capacity_num_bytes;
 
-  scoped_ptr<char, base::AlignedFreeDeleter> new_buffer(static_cast<char*>(
+  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());
       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();
     }
   }
 
-  *buffer = new_buffer.Pass();
+  *buffer = std::move(new_buffer);
   *buffer_num_bytes = current_num_bytes;
   return true;
 }
 
 RemoteProducerDataPipeImpl::~RemoteProducerDataPipeImpl() {
 }
 
 void RemoteProducerDataPipeImpl::ProducerClose() {
   NOTREACHED();
 }
@@ skipping 343 matching lines @@
   // 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