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

mojo/edk/system/ipc_support_unittest.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/ipc_support.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/system/channel_manager.h"
 #include "mojo/edk/system/connection_identifier.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/message_pipe.h"
@@ skipping 327 matching lines @@
   TestSlave* slave() { return slave_.get(); }
   // Note: To close the slave message pipe, use |PassSlaveMessagePipe()|.
   MessagePipeDispatcher* slave_mp() { return slave_mp_.get(); }
 
  private:
   embedder::SimplePlatformSupport* const platform_support_;
   TestIOThread* const test_io_thread_;
   TestMasterProcessDelegate* const master_process_delegate_;
   IPCSupport* const master_ipc_support_;
 
-  scoped_ptr<TestSlaveConnection> slave_connection_;
+  std::unique_ptr<TestSlaveConnection> slave_connection_;
   scoped_refptr<MessagePipeDispatcher> master_mp_;
 
-  scoped_ptr<TestSlave> slave_;
+  std::unique_ptr<TestSlave> slave_;
   scoped_refptr<MessagePipeDispatcher> slave_mp_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlaveSetup);
 };
 
 class IPCSupportTest : public testing::Test {
  public:
   // Note: Run master process delegate methods on the I/O thread.
   IPCSupportTest()
       : test_io_thread_(TestIOThread::kAutoStart),
         master_ipc_support_(&platform_support_,
                             embedder::ProcessType::MASTER,
                             test_io_thread_.task_runner(),
                             &master_process_delegate_,
                             test_io_thread_.task_runner(),
                             embedder::ScopedPlatformHandle()) {}
   ~IPCSupportTest() override {}
 
-  scoped_ptr<TestSlaveSetup> SetupSlave() {
-    scoped_ptr<TestSlaveSetup> s(
+  std::unique_ptr<TestSlaveSetup> SetupSlave() {
+    std::unique_ptr<TestSlaveSetup> s(
         new TestSlaveSetup(&platform_support_, &test_io_thread_,
                            &master_process_delegate_, &master_ipc_support_));
     s->Init();
     return s;
   }
 
   void ShutdownMasterIPCSupport() {
     test_io_thread_.PostTaskAndWait(
         FROM_HERE, base::Bind(&IPCSupport::ShutdownOnIOThread,
                               base::Unretained(&master_ipc_support_)));
@@ skipping 28 matching lines @@
       MessagePipeDispatcher::kDefaultCreateOptions);
   rv.second = MessagePipeDispatcher::Create(
       MessagePipeDispatcher::kDefaultCreateOptions);
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal());
   rv.first->Init(mp, 0);
   rv.second->Init(mp, 1);
   return rv;
 }
 
 TEST_F(IPCSupportTest, MasterSlave) {
-  scoped_ptr<TestSlaveSetup> s(SetupSlave());
+  std::unique_ptr<TestSlaveSetup> s(SetupSlave());
 
   s->TestConnection();
 
   // Don't need the message pipe anymore.
   s->PassMasterMessagePipe()->Close();
   s->PassSlaveMessagePipe()->Close();
 
   // A message was sent through the message pipe, |Channel|s must have been
   // established on both sides. The events have thus almost certainly been
   // signalled, but we'll wait just to be sure.
   s->slave_connection()->WaitForChannelToSlave();
   s->slave()->WaitForChannelToMaster();
 
   s->Shutdown();
 
   ShutdownMasterIPCSupport();
 }
 
 // Simulates a master and two slaves. Initially, there are just message pipes
 // from the master to the slaves. This tests the master creating a message pipe
 // and sending an end to each slave, which should result in a direct connection
 // between the two slaves (TODO(vtl): this part doesn't happen yet).
 // TODO(vtl): There are various other similar scenarios we'll need to test, so
 // we'll need to factor out some of the code.
 // TODO(vtl): In this scenario, we can't test the intermediary (the master)
 // going away.
 TEST_F(IPCSupportTest, ConnectTwoSlaves) {
-  scoped_ptr<TestSlaveSetup> s1(SetupSlave());
-  scoped_ptr<TestSlaveSetup> s2(SetupSlave());
+  std::unique_ptr<TestSlaveSetup> s1(SetupSlave());
+  std::unique_ptr<TestSlaveSetup> s2(SetupSlave());
   s1->TestConnection();
   s2->TestConnection();
 
   // Make a message pipe (logically "in" the master) and send one end to each
   // slave.
   MessagePipeDispatcherPair send_mp = CreateMessagePipe();
   scoped_refptr<MessagePipeDispatcher> slave1_received_mp =
       SendMessagePipeDispatcher(s1->master_mp(), s1->slave_mp(), send_mp.first);
   scoped_refptr<MessagePipeDispatcher> slave2_received_mp =
       SendMessagePipeDispatcher(s2->master_mp(), s2->slave_mp(),
@@ skipping 16 matching lines @@
   slave2_received_mp->Close();
 
   s1->Shutdown();
   s2->Shutdown();
 
   ShutdownMasterIPCSupport();
 }
 
 // Like |ConnectTwoSlaves|, but does it twice, to test reusing a connection.
 TEST_F(IPCSupportTest, ConnectTwoSlavesTwice) {
-  scoped_ptr<TestSlaveSetup> s1(SetupSlave());
-  scoped_ptr<TestSlaveSetup> s2(SetupSlave());
+  std::unique_ptr<TestSlaveSetup> s1(SetupSlave());
+  std::unique_ptr<TestSlaveSetup> s2(SetupSlave());
   s1->TestConnection();
   s2->TestConnection();
 
   MessagePipeDispatcherPair send_mp1 = CreateMessagePipe();
   scoped_refptr<MessagePipeDispatcher> slave1_received_mp1 =
       SendMessagePipeDispatcher(s1->master_mp(), s1->slave_mp(),
                                 send_mp1.first);
   scoped_refptr<MessagePipeDispatcher> slave2_received_mp1 =
       SendMessagePipeDispatcher(s2->master_mp(), s2->slave_mp(),
                                 send_mp1.second);
@@ skipping 28 matching lines @@
 
   s1->Shutdown();
   s2->Shutdown();
 
   ShutdownMasterIPCSupport();
 }
 
 // Creates a message pipe in the slave, which sends both ends (in separate
 // messages) to the master.
 TEST_F(IPCSupportTest, SlavePassBackToMaster) {
-  scoped_ptr<TestSlaveSetup> s(SetupSlave());
+  std::unique_ptr<TestSlaveSetup> s(SetupSlave());
 
   s->TestConnection();
 
   // Make a message pipe (logically "in" the slave) and send both ends
   // (separately) to the master.
   MessagePipeDispatcherPair send_mp = CreateMessagePipe();
   scoped_refptr<MessagePipeDispatcher> received_mp1 =
       SendMessagePipeDispatcher(s->slave_mp(), s->master_mp(), send_mp.first);
 
   TestWriteReadMessage(received_mp1, send_mp.second);
@@ skipping 161 matching lines @@
   test_io_thread.PostTaskAndWait(FROM_HERE,
                                  base::Bind(&IPCSupport::ShutdownOnIOThread,
                                             base::Unretained(&ipc_support)));
 }
 
 // TODO(vtl): Also test the case of the master "dying" before the slave. (The
 // slave should get OnMasterDisconnect(), which we currently don't test.)
 
 }  // namespace system
 }  // namespace mojo