Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 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 <math.h>
 #include <time.h>
 #if defined(WEBRTC_POSIX)
 #include <netinet/in.h>
 #endif
 
+#include <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using namespace rtc;
@@ skipping 29 matching lines @@
 
     count += size;
     memcpy(dummy, &cur_time, sizeof(cur_time));
     socket->Send(dummy, size, options);
 
     last_send = cur_time;
     thread->PostDelayed(NextDelay(), this, 1);
   }
 
   Thread* thread;
-  scoped_ptr<AsyncUDPSocket> socket;
+  std::unique_ptr<AsyncUDPSocket> socket;
   rtc::PacketOptions options;
   bool done;
   uint32_t rate;  // bytes per second
   uint32_t count;
   uint32_t last_send;
   char dummy[4096];
 };
 
 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
   Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
@@ skipping 39 matching lines @@
 
     // It is always possible for us to receive more than expected because
     // packets can be further delayed in delivery.
     if (bandwidth > 0)
       ASSERT_TRUE(sec_count <= 5 * bandwidth / 4);
     sec_count = 0;
     thread->PostDelayed(1000, this, 1);
   }
 
   Thread* thread;
-  scoped_ptr<AsyncUDPSocket> socket;
+  std::unique_ptr<AsyncUDPSocket> socket;
   uint32_t bandwidth;
   bool done;
   size_t count;
   size_t sec_count;
   double sum;
   double sum_sq;
   uint32_t samples;
 };
 
 class VirtualSocketServerTest : public testing::Test {
@@ skipping 201 matching lines @@
     EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
   }
 
   void CloseDuringConnectTest(const SocketAddress& initial_addr) {
     testing::StreamSink sink;
     SocketAddress accept_addr;
     const SocketAddress empty_addr =
         EmptySocketAddressWithFamily(initial_addr.family());
 
     // Create client and server
-    scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(initial_addr.family(),
-                                                          SOCK_STREAM));
+    std::unique_ptr<AsyncSocket> client(
+        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(client.get());
-    scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(initial_addr.family(),
-                                                          SOCK_STREAM));
+    std::unique_ptr<AsyncSocket> server(
+        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(server.get());
 
     // Initiate connect
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
     // Server close before socket enters accept queue
@@ skipping 36 matching lines @@
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
     ss_->ProcessMessagesUntilIdle();
 
     // Server accepts connection
     EXPECT_TRUE(sink.Check(server.get(), testing::SSE_READ));
-    scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+    std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
     ASSERT_TRUE(NULL != accepted.get());
     sink.Monitor(accepted.get());
 
     // Client closes before connection complets
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
 
     // Connected message has not been processed yet.
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     client->Close();
 
     ss_->ProcessMessagesUntilIdle();
 
     // Result: accepted socket closes
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_TRUE(sink.Check(accepted.get(), testing::SSE_CLOSE));
     EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
   }
 
   void CloseTest(const SocketAddress& initial_addr) {
     testing::StreamSink sink;
     const SocketAddress kEmptyAddr;
 
     // Create clients
     AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(a);
     a->Bind(initial_addr);
     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
 
-
-    scoped_ptr<AsyncSocket> b(ss_->CreateAsyncSocket(initial_addr.family(),
-                                                     SOCK_STREAM));
+    std::unique_ptr<AsyncSocket> b(
+        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(b.get());
     b->Bind(initial_addr);
     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
 
     ss_->ProcessMessagesUntilIdle();
 
     EXPECT_TRUE(sink.Check(a, testing::SSE_OPEN));
@@ skipping 600 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }