Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/base/port_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 "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/relayport.h"
 #include "webrtc/p2p/base/stunport.h"
 #include "webrtc/p2p/base/tcpport.h"
 #include "webrtc/p2p/base/testrelayserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/base/transport.h"
 #include "webrtc/p2p/base/turnport.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/natserver.h"
 #include "webrtc/base/natsocketfactory.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using rtc::AsyncPacketSocket;
 using rtc::Buffer;
 using rtc::ByteBufferReader;
 using rtc::ByteBufferWriter;
 using rtc::NATType;
 using rtc::NAT_OPEN_CONE;
 using rtc::NAT_ADDR_RESTRICTED;
 using rtc::NAT_PORT_RESTRICTED;
 using rtc::NAT_SYMMETRIC;
 using rtc::PacketSocketFactory;
-using rtc::scoped_ptr;
 using rtc::Socket;
 using rtc::SocketAddress;
 using namespace cricket;
 
 static const int kTimeout = 1000;
 static const SocketAddress kLocalAddr1("192.168.1.2", 0);
 static const SocketAddress kLocalAddr2("192.168.1.3", 0);
 static const SocketAddress kNatAddr1("77.77.77.77", rtc::NAT_SERVER_UDP_PORT);
 static const SocketAddress kNatAddr2("88.88.88.88", rtc::NAT_SERVER_UDP_PORT);
 static const SocketAddress kStunAddr("99.99.99.1", STUN_SERVER_PORT);
@@ skipping 148 matching lines @@
   }
   void set_type_preference(int type_preference) {
     type_preference_ = type_preference;
   }
 
  private:
   void OnSentPacket(rtc::AsyncPacketSocket* socket,
                     const rtc::SentPacket& sent_packet) {
     PortInterface::SignalSentPacket(sent_packet);
   }
-  rtc::scoped_ptr<Buffer> last_stun_buf_;
-  rtc::scoped_ptr<IceMessage> last_stun_msg_;
+  std::unique_ptr<Buffer> last_stun_buf_;
+  std::unique_ptr<IceMessage> last_stun_msg_;
   int type_preference_ = 0;
 };
 
 class TestChannel : public sigslot::has_slots<> {
  public:
   // Takes ownership of |p1| (but not |p2|).
   TestChannel(Port* p1)
       : ice_mode_(ICEMODE_FULL),
         port_(p1),
         complete_count_(0),
@@ skipping 110 matching lines @@
   }
 
  private:
   // ReadyToSend will only issue after a Connection recovers from EWOULDBLOCK.
   void OnConnectionReadyToSend(Connection* conn) {
     ASSERT_EQ(conn, conn_);
     connection_ready_to_send_ = true;
   }
 
   IceMode ice_mode_;
-  rtc::scoped_ptr<Port> port_;
+  std::unique_ptr<Port> port_;
 
   int complete_count_;
   Connection* conn_;
   SocketAddress remote_address_;
-  rtc::scoped_ptr<StunMessage> remote_request_;
+  std::unique_ptr<StunMessage> remote_request_;
   std::string remote_frag_;
   bool nominated_;
   bool connection_ready_to_send_ = false;
 };
 
 class PortTest : public testing::Test, public sigslot::has_slots<> {
  public:
   PortTest()
       : main_(rtc::Thread::Current()),
         pss_(new rtc::PhysicalSocketServer),
@@ skipping 394 matching lines @@
 
   rtc::BasicPacketSocketFactory* nat_socket_factory1() {
     return &nat_socket_factory1_;
   }
 
  protected:
   rtc::VirtualSocketServer* vss() { return ss_.get(); }
 
  private:
   rtc::Thread* main_;
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
-  rtc::scoped_ptr<rtc::NATServer> nat_server1_;
-  rtc::scoped_ptr<rtc::NATServer> nat_server2_;
+  std::unique_ptr<rtc::NATServer> nat_server1_;
+  std::unique_ptr<rtc::NATServer> nat_server2_;
   rtc::NATSocketFactory nat_factory1_;
   rtc::NATSocketFactory nat_factory2_;
   rtc::BasicPacketSocketFactory nat_socket_factory1_;
   rtc::BasicPacketSocketFactory nat_socket_factory2_;
-  scoped_ptr<TestStunServer> stun_server_;
+  std::unique_ptr<TestStunServer> stun_server_;
   TestTurnServer turn_server_;
   TestRelayServer relay_server_;
   std::string username_;
   std::string password_;
   bool role_conflict_;
   bool destroyed_;
 };
 
 void PortTest::TestConnectivity(const char* name1, Port* port1,
                                 const char* name2, Port* port2,
@@ skipping 421 matching lines @@
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
   // Set up a channel and ensure the port will be deleted.
   TestChannel ch1(port1);
   EXPECT_EQ(0, ch1.complete_count());
 
   ch1.Start();
   ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
 
-  rtc::scoped_ptr<rtc::AsyncSocket> server(
+  std::unique_ptr<rtc::AsyncSocket> server(
       vss()->CreateAsyncSocket(kLocalAddr2.family(), SOCK_STREAM));
   // Bind but not listen.
   EXPECT_EQ(0, server->Bind(kLocalAddr2));
 
   Candidate c = GetCandidate(port1);
   c.set_address(server->GetLocalAddress());
 
   ch1.CreateConnection(c);
   EXPECT_TRUE(ch1.conn());
   EXPECT_TRUE_WAIT(!ch1.conn(), kTimeout);  // for TCP connect
@@ skipping 84 matching lines @@
   port2->SetIceTiebreaker(kTiebreaker2);
   // Same parameters as TestLocalToLocal above.
   TestConnectivity("udp", port1, "udp", port2, true, true, true, true);
 }
 
 // This test is trying to validate a successful and failure scenario in a
 // loopback test when protocol is RFC5245. For success IceTiebreaker, username
 // should remain equal to the request generated by the port and role of port
 // must be in controlling.
 TEST_F(PortTest, TestLoopbackCal) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   lport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   Connection* conn = lport->CreateConnection(lport->Candidates()[0],
                                              Port::ORIGIN_MESSAGE);
   conn->Ping(0);
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
@@ skipping 11 matching lines @@
   lport->Reset();
   lport->AddCandidateAddress(kLocalAddr2);
   // Creating a different connection as |conn| is receiving.
   Connection* conn1 = lport->CreateConnection(lport->Candidates()[1],
                                               Port::ORIGIN_MESSAGE);
   conn1->Ping(0);
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
-  rtc::scoped_ptr<IceMessage> modified_req(
+  std::unique_ptr<IceMessage> modified_req(
       CreateStunMessage(STUN_BINDING_REQUEST));
   const StunByteStringAttribute* username_attr = msg->GetByteString(
       STUN_ATTR_USERNAME);
   modified_req->AddAttribute(new StunByteStringAttribute(
       STUN_ATTR_USERNAME, username_attr->GetString()));
   // To make sure we receive error response, adding tiebreaker less than
   // what's present in request.
   modified_req->AddAttribute(new StunUInt64Attribute(
       STUN_ATTR_ICE_CONTROLLING, kTiebreaker1 - 1));
   modified_req->AddMessageIntegrity("lpass");
   modified_req->AddFingerprint();
 
   lport->Reset();
-  rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
+  std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   WriteStunMessage(modified_req.get(), buf.get());
   conn1->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
 }
 
 // This test verifies role conflict signal is received when there is
 // conflict in the role. In this case both ports are in controlling and
 // |rport| has higher tiebreaker value than |lport|. Since |lport| has lower
 // value of tiebreaker, when it receives ping request from |rport| it will
 // send role conflict signal.
 TEST_F(PortTest, TestIceRoleConflict) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
-  rtc::scoped_ptr<TestPort> rport(
+  std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(rport->Candidates()[0],
                                               Port::ORIGIN_MESSAGE);
@@ skipping 23 matching lines @@
   ASSERT_EQ(0, success);  // GetOption() should complete successfully w/ 0
   ASSERT_EQ(1, option_value);
   delete port1;
 }
 
 TEST_F(PortTest, TestDelayedBindingUdp) {
   FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
   FakePacketSocketFactory socket_factory;
 
   socket_factory.set_next_udp_socket(socket);
-  scoped_ptr<UDPPort> port(
-      CreateUdpPort(kLocalAddr1, &socket_factory));
+  std::unique_ptr<UDPPort> port(CreateUdpPort(kLocalAddr1, &socket_factory));
 
   socket->set_state(AsyncPacketSocket::STATE_BINDING);
   port->PrepareAddress();
 
   EXPECT_EQ(0U, port->Candidates().size());
   socket->SignalAddressReady(socket, kLocalAddr2);
 
   EXPECT_EQ(1U, port->Candidates().size());
 }
 
 TEST_F(PortTest, TestDelayedBindingTcp) {
   FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
   FakePacketSocketFactory socket_factory;
 
   socket_factory.set_next_server_tcp_socket(socket);
-  scoped_ptr<TCPPort> port(
-      CreateTcpPort(kLocalAddr1, &socket_factory));
+  std::unique_ptr<TCPPort> port(CreateTcpPort(kLocalAddr1, &socket_factory));
 
   socket->set_state(AsyncPacketSocket::STATE_BINDING);
   port->PrepareAddress();
 
   EXPECT_EQ(0U, port->Candidates().size());
   socket->SignalAddressReady(socket, kLocalAddr2);
 
   EXPECT_EQ(1U, port->Candidates().size());
 }
 
 void PortTest::TestCrossFamilyPorts(int type) {
   FakePacketSocketFactory factory;
-  scoped_ptr<Port> ports[4];
+  std::unique_ptr<Port> ports[4];
   SocketAddress addresses[4] = {SocketAddress("192.168.1.3", 0),
                                 SocketAddress("192.168.1.4", 0),
                                 SocketAddress("2001:db8::1", 0),
                                 SocketAddress("2001:db8::2", 0)};
   for (int i = 0; i < 4; i++) {
     FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
     if (type == SOCK_DGRAM) {
       factory.set_next_udp_socket(socket);
       ports[i].reset(CreateUdpPort(addresses[i], &factory));
     } else if (type == SOCK_STREAM) {
@@ skipping 49 matching lines @@
     EXPECT_FALSE(NULL == c);
     EXPECT_EQ(1U, p1->connections().size());
   } else {
     EXPECT_TRUE(NULL == c);
     EXPECT_EQ(0U, p1->connections().size());
   }
 }
 
 TEST_F(PortTest, TestUdpV6CrossTypePorts) {
   FakePacketSocketFactory factory;
-  scoped_ptr<Port> ports[4];
+  std::unique_ptr<Port> ports[4];
   SocketAddress addresses[4] = {SocketAddress("2001:db8::1", 0),
                                 SocketAddress("fe80::1", 0),
                                 SocketAddress("fe80::2", 0),
                                 SocketAddress("::1", 0)};
   for (int i = 0; i < 4; i++) {
     FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
     factory.set_next_udp_socket(socket);
     ports[i].reset(CreateUdpPort(addresses[i], &factory));
     socket->set_state(AsyncPacketSocket::STATE_BINDING);
     socket->SignalAddressReady(socket, addresses[i]);
@@ skipping 12 matching lines @@
 
   ExpectPortsCanConnect(true, link_local1, link_local2);
   ExpectPortsCanConnect(true, localhost, standard);
   ExpectPortsCanConnect(true, standard, localhost);
 }
 
 // This test verifies DSCP value set through SetOption interface can be
 // get through DefaultDscpValue.
 TEST_F(PortTest, TestDefaultDscpValue) {
   int dscp;
-  rtc::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
+  std::unique_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
   EXPECT_EQ(0, udpport->SetOption(rtc::Socket::OPT_DSCP,
                                   rtc::DSCP_CS6));
   EXPECT_EQ(0, udpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
-  rtc::scoped_ptr<TCPPort> tcpport(CreateTcpPort(kLocalAddr1));
+  std::unique_ptr<TCPPort> tcpport(CreateTcpPort(kLocalAddr1));
   EXPECT_EQ(0, tcpport->SetOption(rtc::Socket::OPT_DSCP,
                                  rtc::DSCP_AF31));
   EXPECT_EQ(0, tcpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
   EXPECT_EQ(rtc::DSCP_AF31, dscp);
-  rtc::scoped_ptr<StunPort> stunport(
+  std::unique_ptr<StunPort> stunport(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   EXPECT_EQ(0, stunport->SetOption(rtc::Socket::OPT_DSCP,
                                   rtc::DSCP_AF41));
   EXPECT_EQ(0, stunport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
   EXPECT_EQ(rtc::DSCP_AF41, dscp);
-  rtc::scoped_ptr<TurnPort> turnport1(CreateTurnPort(
-      kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
+  std::unique_ptr<TurnPort> turnport1(
+      CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   // Socket is created in PrepareAddress.
   turnport1->PrepareAddress();
   EXPECT_EQ(0, turnport1->SetOption(rtc::Socket::OPT_DSCP,
                                   rtc::DSCP_CS7));
   EXPECT_EQ(0, turnport1->GetOption(rtc::Socket::OPT_DSCP, &dscp));
   EXPECT_EQ(rtc::DSCP_CS7, dscp);
   // This will verify correct value returned without the socket.
-  rtc::scoped_ptr<TurnPort> turnport2(CreateTurnPort(
-      kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
+  std::unique_ptr<TurnPort> turnport2(
+      CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   EXPECT_EQ(0, turnport2->SetOption(rtc::Socket::OPT_DSCP,
                                   rtc::DSCP_CS6));
   EXPECT_EQ(0, turnport2->GetOption(rtc::Socket::OPT_DSCP, &dscp));
   EXPECT_EQ(rtc::DSCP_CS6, dscp);
 }
 
 // Test sending STUN messages.
 TEST_F(PortTest, TestSendStunMessage) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
-  rtc::scoped_ptr<TestPort> rport(
+  std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(rport->Candidates().empty());
@@ skipping 26 matching lines @@
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == NULL);
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
   EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
       lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
 
   // Request should not include ping count.
   ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL);
 
   // Save a copy of the BINDING-REQUEST for use below.
-  rtc::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
+  std::unique_ptr<IceMessage> request(CopyStunMessage(msg));
 
   // Respond with a BINDING-RESPONSE.
   rport->SendBindingResponse(request.get(), lport->Candidates()[0].address());
   msg = rport->last_stun_msg();
   ASSERT_TRUE(msg != NULL);
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
 
 
   EXPECT_FALSE(msg->IsLegacy());
   const StunAddressAttribute* addr_attr = msg->GetAddress(
@@ skipping 70 matching lines @@
   lport->SendBindingResponse(request.get(), rport->Candidates()[0].address());
   msg = lport->last_stun_msg();
 
   // Response should include same ping count.
   retransmit_attr = msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT);
   ASSERT_TRUE(retransmit_attr != NULL);
   EXPECT_EQ(2U, retransmit_attr->value());
 }
 
 TEST_F(PortTest, TestUseCandidateAttribute) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
-  rtc::scoped_ptr<TestPort> rport(
+  std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(
       rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping(0);
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt64Attribute* ice_controlling_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
   ASSERT_TRUE(ice_controlling_attr != NULL);
   const StunByteStringAttribute* use_candidate_attr = msg->GetByteString(
       STUN_ATTR_USE_CANDIDATE);
   ASSERT_TRUE(use_candidate_attr != NULL);
 }
 
 TEST_F(PortTest, TestNetworkInfoAttribute) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   // Set the network type for rport to be cellular so its cost will be 999.
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
-  rtc::scoped_ptr<TestPort> rport(
+  std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   uint16_t lnetwork_id = 9;
   lport->Network()->set_id(lnetwork_id);
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
@@ skipping 22 matching lines @@
   network_info_attr = msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
   ASSERT_TRUE(network_info_attr != NULL);
   network_info = network_info_attr->value();
   EXPECT_EQ(rnetwork_id, network_info >> 16);
   EXPECT_EQ(cricket::kMaxNetworkCost, network_info & 0xFFFF);
 }
 
 // Test handling STUN messages.
 TEST_F(PortTest, TestHandleStunMessage) {
   // Our port will act as the "remote" port.
-  rtc::scoped_ptr<TestPort> port(
-      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+  std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
-  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
-  rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
+  std::unique_ptr<IceMessage> in_msg, out_msg;
+  std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username,
   // MESSAGE-INTEGRITY, and FINGERPRINT.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "rfrag:lfrag"));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
@@ skipping 25 matching lines @@
   EXPECT_TRUE(out_msg.get() != NULL);
   EXPECT_EQ("", username);
   ASSERT_TRUE(out_msg->GetErrorCode() != NULL);
   EXPECT_EQ(STUN_ERROR_SERVER_ERROR, out_msg->GetErrorCode()->code());
   EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR),
       out_msg->GetErrorCode()->reason());
 }
 
 // Tests handling of ICE binding requests with missing or incorrect usernames.
 TEST_F(PortTest, TestHandleStunMessageBadUsername) {
-  rtc::scoped_ptr<TestPort> port(
-      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+  std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
-  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
-  rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
+  std::unique_ptr<IceMessage> in_msg, out_msg;
+  std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST with no username.
   in_msg.reset(CreateStunMessage(STUN_BINDING_REQUEST));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
@@ skipping 44 matching lines @@
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 }
 
 // Test handling STUN messages with missing or malformed M-I.
 TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
   // Our port will act as the "remote" port.
-  rtc::scoped_ptr<TestPort> port(
-      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+  std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
-  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
-  rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
+  std::unique_ptr<IceMessage> in_msg, out_msg;
+  std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username and
   // FINGERPRINT, but no MESSAGE-INTEGRITY.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "rfrag:lfrag"));
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
@@ skipping 16 matching lines @@
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 
   // TODO: BINDING-RESPONSES and BINDING-ERROR-RESPONSES are checked
   // by the Connection, not the Port, since they require the remote username.
   // Change this test to pass in data via Connection::OnReadPacket instead.
 }
 
 // Test handling STUN messages with missing or malformed FINGERPRINT.
 TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
   // Our port will act as the "remote" port.
-  rtc::scoped_ptr<TestPort> port(
-      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+  std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
-  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
-  rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
+  std::unique_ptr<IceMessage> in_msg, out_msg;
+  std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username and
   // MESSAGE-INTEGRITY, but no FINGERPRINT; GetStunMessage should fail.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "rfrag:lfrag"));
   in_msg->AddMessageIntegrity("rpass");
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
@@ skipping 41 matching lines @@
   in_msg->SetTransactionID("TESTTESTBADD");
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                     &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 }
 
 // Test handling of STUN binding indication messages . STUN binding
 // indications are allowed only to the connection which is in read mode.
 TEST_F(PortTest, TestHandleStunBindingIndication) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr2, "lfrag", "lpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
 
   // Verifying encoding and decoding STUN indication message.
-  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
-  rtc::scoped_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
+  std::unique_ptr<IceMessage> in_msg, out_msg;
+  std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   in_msg.reset(CreateStunMessage(STUN_BINDING_INDICATION));
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(lport->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                     &username));
   EXPECT_TRUE(out_msg.get() != NULL);
   EXPECT_EQ(out_msg->type(), STUN_BINDING_INDICATION);
   EXPECT_EQ("", username);
 
   // Verify connection can handle STUN indication and updates
   // last_ping_received.
-  rtc::scoped_ptr<TestPort> rport(
+  std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   ASSERT_FALSE(rport->Candidates().empty());
 
   Connection* lconn = lport->CreateConnection(rport->Candidates()[0],
@@ skipping 15 matching lines @@
 
   // Adding a delay of 100ms.
   rtc::Thread::Current()->ProcessMessages(100);
   // Pinging lconn using stun indication message.
   lconn->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
   int64_t last_ping_received2 = lconn->last_ping_received();
   EXPECT_GT(last_ping_received2, last_ping_received1);
 }
 
 TEST_F(PortTest, TestComputeCandidatePriority) {
-  rtc::scoped_ptr<TestPort> port(
-      CreateTestPort(kLocalAddr1, "name", "pass"));
+  std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr1, "name", "pass"));
   port->set_type_preference(90);
   port->set_component(177);
   port->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
   port->AddCandidateAddress(SocketAddress("2001:db8::1234", 1234));
   port->AddCandidateAddress(SocketAddress("fc12:3456::1234", 1234));
   port->AddCandidateAddress(SocketAddress("::ffff:192.168.1.4", 1234));
   port->AddCandidateAddress(SocketAddress("::192.168.1.4", 1234));
   port->AddCandidateAddress(SocketAddress("2002::1234:5678", 1234));
   port->AddCandidateAddress(SocketAddress("2001::1234:5678", 1234));
   port->AddCandidateAddress(SocketAddress("fecf::1234:5678", 1234));
@@ skipping 16 matching lines @@
   ASSERT_EQ(expected_priority_v4compat, port->Candidates()[4].priority());
   ASSERT_EQ(expected_priority_6to4, port->Candidates()[5].priority());
   ASSERT_EQ(expected_priority_teredo, port->Candidates()[6].priority());
   ASSERT_EQ(expected_priority_sitelocal, port->Candidates()[7].priority());
   ASSERT_EQ(expected_priority_6bone, port->Candidates()[8].priority());
 }
 
 // In the case of shared socket, one port may be shared by local and stun.
 // Test that candidates with different types will have different foundation.
 TEST_F(PortTest, TestFoundation) {
-  rtc::scoped_ptr<TestPort> testport(
+  std::unique_ptr<TestPort> testport(
       CreateTestPort(kLocalAddr1, "name", "pass"));
   testport->AddCandidateAddress(kLocalAddr1, kLocalAddr1,
                                 LOCAL_PORT_TYPE,
                                 cricket::ICE_TYPE_PREFERENCE_HOST, false);
   testport->AddCandidateAddress(kLocalAddr2, kLocalAddr1,
                                 STUN_PORT_TYPE,
                                 cricket::ICE_TYPE_PREFERENCE_SRFLX, true);
   EXPECT_NE(testport->Candidates()[0].foundation(),
             testport->Candidates()[1].foundation());
 }
 
 // This test verifies the foundation of different types of ICE candidates.
 TEST_F(PortTest, TestCandidateFoundation) {
-  rtc::scoped_ptr<rtc::NATServer> nat_server(
+  std::unique_ptr<rtc::NATServer> nat_server(
       CreateNatServer(kNatAddr1, NAT_OPEN_CONE));
-  rtc::scoped_ptr<UDPPort> udpport1(CreateUdpPort(kLocalAddr1));
+  std::unique_ptr<UDPPort> udpport1(CreateUdpPort(kLocalAddr1));
   udpport1->PrepareAddress();
-  rtc::scoped_ptr<UDPPort> udpport2(CreateUdpPort(kLocalAddr1));
+  std::unique_ptr<UDPPort> udpport2(CreateUdpPort(kLocalAddr1));
   udpport2->PrepareAddress();
   EXPECT_EQ(udpport1->Candidates()[0].foundation(),
             udpport2->Candidates()[0].foundation());
-  rtc::scoped_ptr<TCPPort> tcpport1(CreateTcpPort(kLocalAddr1));
+  std::unique_ptr<TCPPort> tcpport1(CreateTcpPort(kLocalAddr1));
   tcpport1->PrepareAddress();
-  rtc::scoped_ptr<TCPPort> tcpport2(CreateTcpPort(kLocalAddr1));
+  std::unique_ptr<TCPPort> tcpport2(CreateTcpPort(kLocalAddr1));
   tcpport2->PrepareAddress();
   EXPECT_EQ(tcpport1->Candidates()[0].foundation(),
             tcpport2->Candidates()[0].foundation());
-  rtc::scoped_ptr<Port> stunport(
+  std::unique_ptr<Port> stunport(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   stunport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kTimeout);
   EXPECT_NE(tcpport1->Candidates()[0].foundation(),
             stunport->Candidates()[0].foundation());
   EXPECT_NE(tcpport2->Candidates()[0].foundation(),
             stunport->Candidates()[0].foundation());
   EXPECT_NE(udpport1->Candidates()[0].foundation(),
             stunport->Candidates()[0].foundation());
   EXPECT_NE(udpport2->Candidates()[0].foundation(),
             stunport->Candidates()[0].foundation());
   // Verify GTURN candidate foundation.
-  rtc::scoped_ptr<RelayPort> relayport(
-      CreateGturnPort(kLocalAddr1));
+  std::unique_ptr<RelayPort> relayport(CreateGturnPort(kLocalAddr1));
   relayport->AddServerAddress(
       cricket::ProtocolAddress(kRelayUdpIntAddr, cricket::PROTO_UDP));
   relayport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, relayport->Candidates().size(), kTimeout);
   EXPECT_NE(udpport1->Candidates()[0].foundation(),
             relayport->Candidates()[0].foundation());
   EXPECT_NE(udpport2->Candidates()[0].foundation(),
             relayport->Candidates()[0].foundation());
   // Verifying TURN candidate foundation.
-  rtc::scoped_ptr<Port> turnport1(CreateTurnPort(
-      kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
+  std::unique_ptr<Port> turnport1(
+      CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   turnport1->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport1->Candidates().size(), kTimeout);
   EXPECT_NE(udpport1->Candidates()[0].foundation(),
             turnport1->Candidates()[0].foundation());
   EXPECT_NE(udpport2->Candidates()[0].foundation(),
             turnport1->Candidates()[0].foundation());
   EXPECT_NE(stunport->Candidates()[0].foundation(),
             turnport1->Candidates()[0].foundation());
-  rtc::scoped_ptr<Port> turnport2(CreateTurnPort(
-      kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
+  std::unique_ptr<Port> turnport2(
+      CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   turnport2->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport2->Candidates().size(), kTimeout);
   EXPECT_EQ(turnport1->Candidates()[0].foundation(),
             turnport2->Candidates()[0].foundation());
 
   // Running a second turn server, to get different base IP address.
   SocketAddress kTurnUdpIntAddr2("99.99.98.4", STUN_SERVER_PORT);
   SocketAddress kTurnUdpExtAddr2("99.99.98.5", 0);
   TestTurnServer turn_server2(
       rtc::Thread::Current(), kTurnUdpIntAddr2, kTurnUdpExtAddr2);
-  rtc::scoped_ptr<Port> turnport3(CreateTurnPort(
-      kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP,
-      kTurnUdpIntAddr2));
+  std::unique_ptr<Port> turnport3(
+      CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP,
+                     kTurnUdpIntAddr2));
   turnport3->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport3->Candidates().size(), kTimeout);
   EXPECT_NE(turnport3->Candidates()[0].foundation(),
             turnport2->Candidates()[0].foundation());
 
   // Start a TCP turn server, and check that two turn candidates have
   // different foundations if their relay protocols are different.
   TestTurnServer turn_server3(rtc::Thread::Current(), kTurnTcpIntAddr,
                               kTurnUdpExtAddr, PROTO_TCP);
-  rtc::scoped_ptr<Port> turnport4(
+  std::unique_ptr<Port> turnport4(
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_TCP, PROTO_UDP));
   turnport4->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport4->Candidates().size(), kTimeout);
   EXPECT_NE(turnport2->Candidates()[0].foundation(),
             turnport4->Candidates()[0].foundation());
 }
 
 // This test verifies the related addresses of different types of
 // ICE candiates.
 TEST_F(PortTest, TestCandidateRelatedAddress) {
-  rtc::scoped_ptr<rtc::NATServer> nat_server(
+  std::unique_ptr<rtc::NATServer> nat_server(
       CreateNatServer(kNatAddr1, NAT_OPEN_CONE));
-  rtc::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
+  std::unique_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
   udpport->PrepareAddress();
   // For UDPPort, related address will be empty.
   EXPECT_TRUE(udpport->Candidates()[0].related_address().IsNil());
   // Testing related address for stun candidates.
   // For stun candidate related address must be equal to the base
   // socket address.
-  rtc::scoped_ptr<StunPort> stunport(
+  std::unique_ptr<StunPort> stunport(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   stunport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kTimeout);
   // Check STUN candidate address.
   EXPECT_EQ(stunport->Candidates()[0].address().ipaddr(),
             kNatAddr1.ipaddr());
   // Check STUN candidate related address.
   EXPECT_EQ(stunport->Candidates()[0].related_address(),
             stunport->GetLocalAddress());
   // Verifying the related address for the GTURN candidates.
   // NOTE: In case of GTURN related address will be equal to the mapped
   // address, but address(mapped) will not be XOR.
-  rtc::scoped_ptr<RelayPort> relayport(
-      CreateGturnPort(kLocalAddr1));
+  std::unique_ptr<RelayPort> relayport(CreateGturnPort(kLocalAddr1));
   relayport->AddServerAddress(
       cricket::ProtocolAddress(kRelayUdpIntAddr, cricket::PROTO_UDP));
   relayport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, relayport->Candidates().size(), kTimeout);
   // For Gturn related address is set to "0.0.0.0:0"
   EXPECT_EQ(rtc::SocketAddress(),
             relayport->Candidates()[0].related_address());
   // Verifying the related address for TURN candidate.
   // For TURN related address must be equal to the mapped address.
-  rtc::scoped_ptr<Port> turnport(CreateTurnPort(
-      kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
+  std::unique_ptr<Port> turnport(
+      CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   turnport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport->Candidates().size(), kTimeout);
   EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
             turnport->Candidates()[0].address().ipaddr());
   EXPECT_EQ(kNatAddr1.ipaddr(),
             turnport->Candidates()[0].related_address().ipaddr());
 }
 
 // Test priority value overflow handling when preference is set to 3.
 TEST_F(PortTest, TestCandidatePriority) {
   cricket::Candidate cand1;
   cand1.set_priority(3);
   cricket::Candidate cand2;
   cand2.set_priority(1);
   EXPECT_TRUE(cand1.priority() > cand2.priority());
 }
 
 // Test the Connection priority is calculated correctly.
 TEST_F(PortTest, TestConnectionPriority) {
-  rtc::scoped_ptr<TestPort> lport(
+  std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_HOST);
-  rtc::scoped_ptr<TestPort> rport(
+  std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY);
   lport->set_component(123);
   lport->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
   rport->set_component(23);
   rport->AddCandidateAddress(SocketAddress("10.1.1.100", 1234));
 
   EXPECT_EQ(0x7E001E85U, lport->Candidates()[0].priority());
   EXPECT_EQ(0x2001EE9U, rport->Candidates()[0].priority());
 
@@ skipping 119 matching lines @@
 
 // This test verifies the connection setup between ICEMODE_FULL
 // and ICEMODE_LITE.
 // In this test |ch1| behaves like FULL mode client and we have created
 // port which responds to the ping message just like LITE client.
 TEST_F(PortTest, TestIceLiteConnectivity) {
   TestPort* ice_full_port = CreateTestPort(
       kLocalAddr1, "lfrag", "lpass",
       cricket::ICEROLE_CONTROLLING, kTiebreaker1);
 
-  rtc::scoped_ptr<TestPort> ice_lite_port(CreateTestPort(
-      kLocalAddr2, "rfrag", "rpass",
-      cricket::ICEROLE_CONTROLLED, kTiebreaker2));
+  std::unique_ptr<TestPort> ice_lite_port(
+      CreateTestPort(kLocalAddr2, "rfrag", "rpass", cricket::ICEROLE_CONTROLLED,
+                     kTiebreaker2));
   // Setup TestChannel. This behaves like FULL mode client.
   TestChannel ch1(ice_full_port);
   ch1.SetIceMode(ICEMODE_FULL);
 
   // Start gathering candidates.
   ch1.Start();
   ice_lite_port->PrepareAddress();
 
   ASSERT_EQ_WAIT(1, ch1.complete_count(), kTimeout);
   ASSERT_FALSE(ice_lite_port->Candidates().empty());
@@ skipping 11 matching lines @@
   ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, 1000);
   IceMessage* msg = ice_full_port->last_stun_msg();
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL);
 
   // Respond with a BINDING-RESPONSE from litemode client.
   // NOTE: Ideally we should't create connection at this stage from lite
   // port, as it should be done only after receiving ping with USE_CANDIDATE.
   // But we need a connection to send a response message.
   ice_lite_port->CreateConnection(
       ice_full_port->Candidates()[0], cricket::Port::ORIGIN_MESSAGE);
-  rtc::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
+  std::unique_ptr<IceMessage> request(CopyStunMessage(msg));
   ice_lite_port->SendBindingResponse(
       request.get(), ice_full_port->Candidates()[0].address());
 
   // Feeding the respone message from litemode to the full mode connection.
   ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->data<char>(),
                            ice_lite_port->last_stun_buf()->size(),
                            rtc::PacketTime());
   // Verifying full mode connection becomes writable from the response.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kTimeout);
@@ skipping 93 matching lines @@
   EXPECT_TRUE_WAIT(ch2.conn() == nullptr, kTimeout);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLED);
   port2->SetIceRole(cricket::ICEROLE_CONTROLLING);
 
   // After the connection is destroyed, the port should not be destroyed.
   rtc::Thread::Current()->ProcessMessages(kTimeout);
   EXPECT_FALSE(destroyed());
 }
 
 TEST_F(PortTest, TestSupportsProtocol) {
-  rtc::scoped_ptr<Port> udp_port(CreateUdpPort(kLocalAddr1));
+  std::unique_ptr<Port> udp_port(CreateUdpPort(kLocalAddr1));
   EXPECT_TRUE(udp_port->SupportsProtocol(UDP_PROTOCOL_NAME));
   EXPECT_FALSE(udp_port->SupportsProtocol(TCP_PROTOCOL_NAME));
 
-  rtc::scoped_ptr<Port> stun_port(
+  std::unique_ptr<Port> stun_port(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   EXPECT_TRUE(stun_port->SupportsProtocol(UDP_PROTOCOL_NAME));
   EXPECT_FALSE(stun_port->SupportsProtocol(TCP_PROTOCOL_NAME));
 
-  rtc::scoped_ptr<Port> tcp_port(CreateTcpPort(kLocalAddr1));
+  std::unique_ptr<Port> tcp_port(CreateTcpPort(kLocalAddr1));
   EXPECT_TRUE(tcp_port->SupportsProtocol(TCP_PROTOCOL_NAME));
   EXPECT_TRUE(tcp_port->SupportsProtocol(SSLTCP_PROTOCOL_NAME));
   EXPECT_FALSE(tcp_port->SupportsProtocol(UDP_PROTOCOL_NAME));
 
-  rtc::scoped_ptr<Port> turn_port(
+  std::unique_ptr<Port> turn_port(
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   EXPECT_TRUE(turn_port->SupportsProtocol(UDP_PROTOCOL_NAME));
   EXPECT_FALSE(turn_port->SupportsProtocol(TCP_PROTOCOL_NAME));
 }