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

mojo/edk/system/master_connection_manager.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/master_connection_manager.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/system/connection_manager_messages.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/system/transport_data.h"
+#include "mojo/edk/util/make_unique.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 const ProcessIdentifier kFirstSlaveProcessIdentifier = 2;
 
 static_assert(kMasterProcessIdentifier != kInvalidProcessIdentifier,
@@ skipping 155 matching lines @@
       ConnectionManagerResultToMessageInTransitSubtype(result), num_bytes,
       bytes));
 
   if (result == Result::SUCCESS_CONNECT_NEW_CONNECTION) {
     DCHECK_EQ(message_view.subtype(),
               MessageInTransit::Subtype::CONNECTION_MANAGER_CONNECT);
     DCHECK(platform_handle.is_valid());
     embedder::ScopedPlatformHandleVectorPtr platform_handles(
         new embedder::PlatformHandleVector());
     platform_handles->push_back(platform_handle.release());
-    response->SetTransportData(make_scoped_ptr(
-        new TransportData(platform_handles.Pass(),
-                          raw_channel_->GetSerializedPlatformHandleSize())));
+    response->SetTransportData(util::MakeUnique<TransportData>(
+        platform_handles.Pass(),
+        raw_channel_->GetSerializedPlatformHandleSize()));
   } else {
     DCHECK(!platform_handle.is_valid());
   }
 
   if (!raw_channel_->WriteMessage(response.Pass())) {
     LOG(ERROR) << "WriteMessage failed";
     FatalError();  // WARNING: This destroys us.
     return;
   }
 }
@@ skipping 338 matching lines @@
              << ": first Connect() from process identifier "
              << process_identifier;
     *peer_process_identifier = peer;
     *is_first = true;
     return ConnectImplHelperNoLock(process_identifier, peer, platform_handle);
   }
 
   // The remaining cases all result in |it| being removed from
   // |pending_connects_| and deleting |info|.
   pending_connects_.erase(it);
-  scoped_ptr<PendingConnectInfo> info_deleter(info);
+  std::unique_ptr<PendingConnectInfo> info_deleter(info);
 
   // |remaining_connectee| should be the same as |process_identifier|.
   ProcessIdentifier remaining_connectee;
   if (info->state == PendingConnectInfo::State::AWAITING_CONNECT_FROM_FIRST) {
     remaining_connectee = info->first;
     peer = info->second;
   } else if (info->state ==
              PendingConnectInfo::State::AWAITING_CONNECT_FROM_SECOND) {
     remaining_connectee = info->second;
     peer = info->first;
@@ skipping 97 matching lines @@
 
 void MasterConnectionManager::AddSlaveOnPrivateThread(
     embedder::SlaveInfo slave_info,
     embedder::ScopedPlatformHandle platform_handle,
     ProcessIdentifier slave_process_identifier,
     base::WaitableEvent* event) {
   DCHECK(platform_handle.is_valid());
   DCHECK(event);
   AssertOnPrivateThread();
 
-  scoped_ptr<Helper> helper(new Helper(this, slave_process_identifier,
-                                       slave_info, platform_handle.Pass()));
+  std::unique_ptr<Helper> helper(new Helper(
+      this, slave_process_identifier, slave_info, platform_handle.Pass()));
   helper->Init();
 
   DCHECK(helpers_.find(slave_process_identifier) == helpers_.end());
   helpers_[slave_process_identifier] = helper.release();
 
   DVLOG(1) << "Added slave process identifier " << slave_process_identifier;
   event->Signal();
 }
 
 void MasterConnectionManager::OnError(ProcessIdentifier process_identifier) {
@@ skipping 46 matching lines @@
 }
 
 void MasterConnectionManager::AssertOnPrivateThread() const {
   // This should only be called after |Init()| and before |Shutdown()|.
   DCHECK(private_thread_.message_loop());
   DCHECK_EQ(base::MessageLoop::current(), private_thread_.message_loop());
 }
 
 }  // namespace system
 }  // namespace mojo