EDK: More scoped_ptr -> std::unique_ptr conversions.

mojo/edk/system/data_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/data_pipe.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/aligned_memory.h"
 #include "mojo/edk/system/awakable_list.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe_impl.h"
 #include "mojo/edk/system/incoming_endpoint.h"
 #include "mojo/edk/system/local_data_pipe_impl.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/options_validation.h"
 #include "mojo/edk/system/remote_consumer_data_pipe_impl.h"
 #include "mojo/edk/system/remote_producer_data_pipe_impl.h"
+#include "mojo/edk/util/make_unique.h"
 
 namespace mojo {
 namespace system {
 
 // static
 MojoCreateDataPipeOptions DataPipe::GetDefaultCreateOptions() {
   MojoCreateDataPipeOptions result = {
       static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)),
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
       1u,
@@ skipping 53 matching lines @@
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   out_options->capacity_num_bytes = reader.options().capacity_num_bytes;
 
   return MOJO_RESULT_OK;
 }
 
 // static
 DataPipe* DataPipe::CreateLocal(
     const MojoCreateDataPipeOptions& validated_options) {
   return new DataPipe(true, true, validated_options,
-                      make_scoped_ptr(new LocalDataPipeImpl()));
+                      util::MakeUnique<LocalDataPipeImpl>());
 }
 
 // static
 DataPipe* DataPipe::CreateRemoteProducerFromExisting(
     const MojoCreateDataPipeOptions& validated_options,
     MessageInTransitQueue* message_queue,
     ChannelEndpoint* channel_endpoint) {
   std::unique_ptr<char, base::AlignedFreeDeleter> buffer;
   size_t buffer_num_bytes = 0;
   if (!RemoteProducerDataPipeImpl::ProcessMessagesFromIncomingEndpoint(
           validated_options, message_queue, &buffer, &buffer_num_bytes))
     return nullptr;
 
   // Important: This is called under |IncomingEndpoint|'s (which is a
   // |ChannelEndpointClient|) lock, in particular from
   // |IncomingEndpoint::ConvertToDataPipeConsumer()|. Before releasing that
   // lock, it will reset its |endpoint_| member, which makes any later or
   // ongoing call to |IncomingEndpoint::OnReadMessage()| return false. This will
   // make |ChannelEndpoint::OnReadMessage()| retry, until its |ReplaceClient()|
   // is called.
   DataPipe* data_pipe = new DataPipe(
       false, true, validated_options,
-      make_scoped_ptr(new RemoteProducerDataPipeImpl(
-          channel_endpoint, std::move(buffer), 0, buffer_num_bytes)));
+      util::MakeUnique<RemoteProducerDataPipeImpl>(
+          channel_endpoint, std::move(buffer), 0, buffer_num_bytes));
   if (channel_endpoint) {
     if (!channel_endpoint->ReplaceClient(data_pipe, 0))
       data_pipe->OnDetachFromChannel(0);
   } else {
     data_pipe->SetProducerClosed();
   }
   return data_pipe;
 }
 
 // static
 DataPipe* DataPipe::CreateRemoteConsumerFromExisting(
     const MojoCreateDataPipeOptions& validated_options,
     size_t consumer_num_bytes,
     MessageInTransitQueue* message_queue,
     ChannelEndpoint* channel_endpoint) {
   if (!RemoteConsumerDataPipeImpl::ProcessMessagesFromIncomingEndpoint(
           validated_options, &consumer_num_bytes, message_queue))
     return nullptr;
 
   // Important: This is called under |IncomingEndpoint|'s (which is a
   // |ChannelEndpointClient|) lock, in particular from
   // |IncomingEndpoint::ConvertToDataPipeProducer()|. Before releasing that
   // lock, it will reset its |endpoint_| member, which makes any later or
   // ongoing call to |IncomingEndpoint::OnReadMessage()| return false. This will
   // make |ChannelEndpoint::OnReadMessage()| retry, until its |ReplaceClient()|
   // is called.
   DataPipe* data_pipe =
       new DataPipe(true, false, validated_options,
-                   make_scoped_ptr(new RemoteConsumerDataPipeImpl(
-                       channel_endpoint, consumer_num_bytes)));
+                   util::MakeUnique<RemoteConsumerDataPipeImpl>(
+                       channel_endpoint, consumer_num_bytes));
   if (channel_endpoint) {
     if (!channel_endpoint->ReplaceClient(data_pipe, 0))
       data_pipe->OnDetachFromChannel(0);
   } else {
     data_pipe->SetConsumerClosed();
   }
   return data_pipe;
 }
 
 // static
@@ skipping 24 matching lines @@
     return false;
   }
 
   if (!consumer_open) {
     if (s->consumer_num_bytes != static_cast<size_t>(-1)) {
       LOG(ERROR)
           << "Invalid serialized data pipe producer (bad consumer_num_bytes)";
       return false;
     }
 
-    *data_pipe = new DataPipe(
-        true, false, revalidated_options,
-        make_scoped_ptr(new RemoteConsumerDataPipeImpl(nullptr, 0)));
+    *data_pipe =
+        new DataPipe(true, false, revalidated_options,
+                     util::MakeUnique<RemoteConsumerDataPipeImpl>(nullptr, 0));
     (*data_pipe)->SetConsumerClosed();
 
     return true;
   }
 
   if (s->consumer_num_bytes > revalidated_options.capacity_num_bytes ||
       s->consumer_num_bytes % revalidated_options.element_num_bytes != 0) {
     LOG(ERROR)
         << "Invalid serialized data pipe producer (bad consumer_num_bytes)";
     return false;
@@ skipping 449 matching lines @@
 }
 
 bool DataPipe::ConsumerIsBusy() const {
   MutexLocker locker(&mutex_);
   return consumer_in_two_phase_read_no_lock();
 }
 
 DataPipe::DataPipe(bool has_local_producer,
                    bool has_local_consumer,
                    const MojoCreateDataPipeOptions& validated_options,
-                   scoped_ptr<DataPipeImpl> impl)
+                   std::unique_ptr<DataPipeImpl> impl)
     : validated_options_(validated_options),
       producer_open_(true),
       consumer_open_(true),
       producer_awakable_list_(has_local_producer ? new AwakableList()
                                                  : nullptr),
       consumer_awakable_list_(has_local_consumer ? new AwakableList()
                                                  : nullptr),
       producer_two_phase_max_num_bytes_written_(0),
       consumer_two_phase_max_num_bytes_read_(0),
-      impl_(impl.Pass()) {
+      impl_(std::move(impl)) {
   impl_->set_owner(this);
 
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
   // Check that the passed in options actually are validated.
   MojoCreateDataPipeOptions unused = {};
   DCHECK_EQ(ValidateCreateOptions(MakeUserPointer(&validated_options), &unused),
             MOJO_RESULT_OK);
 #endif  // !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 }
 
 DataPipe::~DataPipe() {
   DCHECK(!producer_open_);
   DCHECK(!consumer_open_);
   DCHECK(!producer_awakable_list_);
   DCHECK(!consumer_awakable_list_);
 }
 
-scoped_ptr<DataPipeImpl> DataPipe::ReplaceImplNoLock(
-    scoped_ptr<DataPipeImpl> new_impl) {
+std::unique_ptr<DataPipeImpl> DataPipe::ReplaceImplNoLock(
+    std::unique_ptr<DataPipeImpl> new_impl) {
   mutex_.AssertHeld();
   DCHECK(new_impl);
 
   impl_->set_owner(nullptr);
-  scoped_ptr<DataPipeImpl> rv(impl_.Pass());
-  impl_ = new_impl.Pass();
+  std::unique_ptr<DataPipeImpl> rv(std::move(impl_));
+  impl_ = std::move(new_impl);
   impl_->set_owner(this);
-  return rv.Pass();
+  return rv;
 }
 
 void DataPipe::SetProducerClosedNoLock() {
   mutex_.AssertHeld();
   DCHECK(!has_local_producer_no_lock());
   DCHECK(producer_open_);
   producer_open_ = false;
 }
 
 void DataPipe::SetConsumerClosedNoLock() {
@@ skipping 100 matching lines @@
   SetProducerClosedNoLock();
 }
 
 void DataPipe::SetConsumerClosed() {
   MutexLocker locker(&mutex_);
   SetConsumerClosedNoLock();
 }
 
 }  // namespace system
 }  // namespace mojo