Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/physicalsocketserver_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <signal.h>
 #include <stdarg.h>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket_unittest.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
 class PhysicalSocketTest;
 
 class FakeSocketDispatcher : public SocketDispatcher {
  public:
@@ skipping 65 matching lines @@
   PhysicalSocketTest()
     : server_(new FakePhysicalSocketServer(this)),
       scope_(server_.get()),
       fail_accept_(false),
       max_send_size_(-1) {
   }
 
   void ConnectInternalAcceptError(const IPAddress& loopback);
   void WritableAfterPartialWrite(const IPAddress& loopback);
 
-  rtc::scoped_ptr<FakePhysicalSocketServer> server_;
+  std::unique_ptr<FakePhysicalSocketServer> server_;
   SocketServerScope scope_;
   bool fail_accept_;
   int max_send_size_;
 };
 
 SOCKET FakeSocketDispatcher::DoAccept(SOCKET socket,
                                       sockaddr* addr,
                                       socklen_t* addrlen) {
   FakePhysicalSocketServer* ss =
       static_cast<FakePhysicalSocketServer*>(socketserver());
@@ skipping 51 matching lines @@
 
 TEST_F(PhysicalSocketTest, TestConnectFailIPv4) {
   SocketTest::TestConnectFailIPv4();
 }
 
 void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create two clients.
-  scoped_ptr<AsyncSocket> client1(server_->CreateAsyncSocket(loopback.family(),
-                                                             SOCK_STREAM));
+  std::unique_ptr<AsyncSocket> client1(
+      server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client1.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client1->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client1->GetLocalAddress().ipaddr());
 
-  scoped_ptr<AsyncSocket> client2(server_->CreateAsyncSocket(loopback.family(),
-                                                             SOCK_STREAM));
+  std::unique_ptr<AsyncSocket> client2(
+      server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client2.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client2->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client2->GetLocalAddress().ipaddr());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, server->GetState());
 
   // Ensure no pending server connections, since we haven't done anything yet.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 
   // Attempt first connect to listening socket.
   EXPECT_EQ(0, client1->Connect(server->GetLocalAddress()));
   EXPECT_FALSE(client1->GetLocalAddress().IsNil());
   EXPECT_NE(server->GetLocalAddress(), client1->GetLocalAddress());
 
   // Client is connecting, outcome not yet determined.
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client1->GetState());
   EXPECT_FALSE(sink.Check(client1.get(), testing::SSE_OPEN));
   EXPECT_FALSE(sink.Check(client1.get(), testing::SSE_CLOSE));
 
   // Server has pending connection, try to accept it (will fail).
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
   // Simulate "::accept" returning an error.
   SetFailAccept(true);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   EXPECT_FALSE(accepted);
   ASSERT_TRUE(accept_addr.IsNil());
 
   // Ensure no more pending server connections.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 
   // Attempt second connect to listening socket.
   EXPECT_EQ(0, client2->Connect(server->GetLocalAddress()));
   EXPECT_FALSE(client2->GetLocalAddress().IsNil());
   EXPECT_NE(server->GetLocalAddress(), client2->GetLocalAddress());
 
   // Client is connecting, outcome not yet determined.
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client2->GetState());
   EXPECT_FALSE(sink.Check(client2.get(), testing::SSE_OPEN));
   EXPECT_FALSE(sink.Check(client2.get(), testing::SSE_CLOSE));
 
   // Server has pending connection, try to accept it (will succeed).
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
   SetFailAccept(false);
-  scoped_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted2);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr);
 }
 
 TEST_F(PhysicalSocketTest, TestConnectAcceptErrorIPv4) {
   ConnectInternalAcceptError(kIPv4Loopback);
 }
 
 // Crashes on Linux. See webrtc:4923.
@@ skipping 261 matching lines @@
     if (!ret) {
       LOG(LS_ERROR) << "ExpectNone(): Received signal " << signals_received_[0]
           << ", expected none";
     }
     return ret;
   }
 
   static std::vector<int> signals_received_;
   static Thread *signaled_thread_;
 
-  scoped_ptr<PhysicalSocketServer> ss_;
+  std::unique_ptr<PhysicalSocketServer> ss_;
 };
 
 std::vector<int> PosixSignalDeliveryTest::signals_received_;
 Thread *PosixSignalDeliveryTest::signaled_thread_ = NULL;
 
 // Test receiving a synchronous signal while not in Wait() and then entering
 // Wait() afterwards.
 TEST_F(PosixSignalDeliveryTest, RaiseThenWait) {
   ASSERT_TRUE(ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal));
   raise(SIGTERM);
@@ skipping 47 matching lines @@
 TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
   ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
   // Mask out SIGTERM so that it can't be delivered to this thread.
   sigset_t mask;
   sigemptyset(&mask);
   sigaddset(&mask, SIGTERM);
   EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, NULL));
   // Start a new thread that raises it. It will have to be delivered to that
   // thread. Our implementation should safely handle it and dispatch
   // RecordSignal() on this thread.
-  scoped_ptr<Thread> thread(new Thread());
-  scoped_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
+  std::unique_ptr<Thread> thread(new Thread());
+  std::unique_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
   thread->Start(runnable.get());
   EXPECT_TRUE(ss_->Wait(1500, true));
   EXPECT_TRUE(ExpectSignal(SIGTERM));
   EXPECT_EQ(Thread::Current(), signaled_thread_);
   EXPECT_TRUE(ExpectNone());
 }
 
 #endif
 
 }  // namespace rtc