Replace scoped_ptr with unique_ptr in webrtc/p2p/

But keep #including scoped_ptr.h in .h files, so as not to break
WebRTC users who expect those .h files to give them rtc::scoped_ptr.

BUG=webrtc:5520

Review URL: https://codereview.webrtc.org/1923163003

Cr-Commit-Position: refs/heads/master@{#12532}

webrtc/p2p/base/asyncstuntcpsocket_unittest.cc

diff --git a/webrtc/p2p/base/asyncstuntcpsocket_unittest.cc b/webrtc/p2p/base/asyncstuntcpsocket_unittest.cc
index 22c1b26..5929d1f 100644
--- a/webrtc/p2p/base/asyncstuntcpsocket_unittest.cc
+++ b/webrtc/p2p/base/asyncstuntcpsocket_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/p2p/base/asyncstuntcpsocket.h"
 #include "webrtc/base/asyncsocket.h"
 #include "webrtc/base/gunit.h"
@@ -122,11 +124,11 @@
     return ret;
   }
 
-  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::SocketServerScope ss_scope_;
-  rtc::scoped_ptr<AsyncStunTCPSocket> send_socket_;
-  rtc::scoped_ptr<AsyncStunTCPSocket> recv_socket_;
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> listen_socket_;
+  std::unique_ptr<AsyncStunTCPSocket> send_socket_;
+  std::unique_ptr<AsyncStunTCPSocket> recv_socket_;
+  std::unique_ptr<rtc::AsyncPacketSocket> listen_socket_;
   std::list<std::string> recv_packets_;
 };
 

webrtc/p2p/base/basicpacketsocketfactory.cc

diff --git a/webrtc/p2p/base/basicpacketsocketfactory.cc b/webrtc/p2p/base/basicpacketsocketfactory.cc
index 697518d..a05f9df 100644
--- a/webrtc/p2p/base/basicpacketsocketfactory.cc
+++ b/webrtc/p2p/base/basicpacketsocketfactory.cc
@@ -17,7 +17,6 @@
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"

webrtc/p2p/base/dtlstransport.h

diff --git a/webrtc/p2p/base/dtlstransport.h b/webrtc/p2p/base/dtlstransport.h
index 276b05f..2ff2ea5 100644
--- a/webrtc/p2p/base/dtlstransport.h
+++ b/webrtc/p2p/base/dtlstransport.h
@@ -11,6 +11,8 @@
 #ifndef WEBRTC_P2P_BASE_DTLSTRANSPORT_H_
 #define WEBRTC_P2P_BASE_DTLSTRANSPORT_H_
 
+#include <memory>
+
 #include "webrtc/p2p/base/dtlstransportchannel.h"
 #include "webrtc/p2p/base/transport.h"
 
@@ -67,7 +69,7 @@
     if (local_fp) {
       // Sanity check local fingerprint.
       if (certificate_) {
-        rtc::scoped_ptr<rtc::SSLFingerprint> local_fp_tmp(
+        std::unique_ptr<rtc::SSLFingerprint> local_fp_tmp(
             rtc::SSLFingerprint::Create(local_fp->algorithm,
                                         certificate_->identity()));
         ASSERT(local_fp_tmp.get() != NULL);
@@ -242,7 +244,7 @@
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
   rtc::SSLRole secure_role_;
   rtc::SSLProtocolVersion ssl_max_version_;
-  rtc::scoped_ptr<rtc::SSLFingerprint> remote_fingerprint_;
+  std::unique_ptr<rtc::SSLFingerprint> remote_fingerprint_;
 };
 
 }  // namespace cricket

webrtc/p2p/base/p2ptransportchannel.h

diff --git a/webrtc/p2p/base/p2ptransportchannel.h b/webrtc/p2p/base/p2ptransportchannel.h
index 08c2b4f..2afe03e 100644
--- a/webrtc/p2p/base/p2ptransportchannel.h
+++ b/webrtc/p2p/base/p2ptransportchannel.h
@@ -21,6 +21,7 @@
 #define WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>

webrtc/p2p/base/p2ptransportchannel_unittest.cc

diff --git a/webrtc/p2p/base/p2ptransportchannel_unittest.cc b/webrtc/p2p/base/p2ptransportchannel_unittest.cc
index d921a1e..8ff0b6e 100644
--- a/webrtc/p2p/base/p2ptransportchannel_unittest.cc
+++ b/webrtc/p2p/base/p2ptransportchannel_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 #include "webrtc/p2p/base/testrelayserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
@@ -211,7 +213,7 @@
 
     std::string name_;  // TODO - Currently not used.
     std::list<std::string> ch_packets_;
-    rtc::scoped_ptr<cricket::P2PTransportChannel> ch_;
+    std::unique_ptr<cricket::P2PTransportChannel> ch_;
   };
 
   struct CandidatesData : public rtc::MessageData {
@@ -255,7 +257,7 @@
     }
 
     rtc::FakeNetworkManager network_manager_;
-    rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+    std::unique_ptr<cricket::BasicPortAllocator> allocator_;
     ChannelData cd1_;
     ChannelData cd2_;
     cricket::IceRole role_;
@@ -702,7 +704,7 @@
   void OnMessage(rtc::Message* msg) {
     switch (msg->message_id) {
       case MSG_ADD_CANDIDATES: {
-        rtc::scoped_ptr<CandidatesData> data(
+        std::unique_ptr<CandidatesData> data(
             static_cast<CandidatesData*>(msg->pdata));
         cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
         for (auto& c : data->candidates) {
@@ -717,7 +719,7 @@
         break;
       }
       case MSG_REMOVE_CANDIDATES: {
-        rtc::scoped_ptr<CandidatesData> data(
+        std::unique_ptr<CandidatesData> data(
             static_cast<CandidatesData*>(msg->pdata));
         cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
         for (cricket::Candidate& c : data->candidates) {
@@ -797,12 +799,12 @@
 
  private:
   rtc::Thread* main_;
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
-  rtc::scoped_ptr<rtc::NATSocketServer> nss_;
-  rtc::scoped_ptr<rtc::FirewallSocketServer> ss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
+  std::unique_ptr<rtc::NATSocketServer> nss_;
+  std::unique_ptr<rtc::FirewallSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_;
   cricket::TestTurnServer turn_server_;
   cricket::TestRelayServer relay_server_;
   rtc::SocksProxyServer socks_server1_;
@@ -1994,8 +1996,8 @@
   void reset_channel_ready_to_send() { channel_ready_to_send_ = false; }
 
  private:
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::SocketServerScope ss_scope_;
   cricket::CandidatePairInterface* last_selected_candidate_pair_ = nullptr;
   int last_sent_packet_id_ = -1;
@@ -2640,10 +2642,10 @@
   }
 
  private:
-  rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+  std::unique_ptr<cricket::BasicPortAllocator> allocator_;
   rtc::FakeNetworkManager network_manager_;
   cricket::TestTurnServer turn_server_;
-  rtc::scoped_ptr<cricket::P2PTransportChannel> channel_;
+  std::unique_ptr<cricket::P2PTransportChannel> channel_;
 };
 
 // Test that Relay/Relay connections will be pinged first when no other

webrtc/p2p/base/port.cc

diff --git a/webrtc/p2p/base/port.cc b/webrtc/p2p/base/port.cc
index 0238aa2..2ee012a 100644
--- a/webrtc/p2p/base/port.cc
+++ b/webrtc/p2p/base/port.cc
@@ -21,7 +21,6 @@
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/network.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 
@@ -278,7 +277,7 @@
 
   // If this is an authenticated STUN request, then signal unknown address and
   // send back a proper binding response.
-  rtc::scoped_ptr<IceMessage> msg;
+  std::unique_ptr<IceMessage> msg;
   std::string remote_username;
   if (!GetStunMessage(data, size, addr, &msg, &remote_username)) {
     LOG_J(LS_ERROR, this) << "Received non-STUN packet from unknown address ("
@@ -325,7 +324,7 @@
 bool Port::GetStunMessage(const char* data,
                           size_t size,
                           const rtc::SocketAddress& addr,
-                          rtc::scoped_ptr<IceMessage>* out_msg,
+                          std::unique_ptr<IceMessage>* out_msg,
                           std::string* out_username) {
   // NOTE: This could clearly be optimized to avoid allocating any memory.
   //       However, at the data rates we'll be looking at on the client side,
@@ -342,7 +341,7 @@
 
   // Parse the request message.  If the packet is not a complete and correct
   // STUN message, then ignore it.
-  rtc::scoped_ptr<IceMessage> stun_msg(new IceMessage());
+  std::unique_ptr<IceMessage> stun_msg(new IceMessage());
   rtc::ByteBufferReader buf(data, size);
   if (!stun_msg->Read(&buf) || (buf.Length() > 0)) {
     return false;
@@ -895,7 +894,7 @@
 
 void Connection::OnReadPacket(
   const char* data, size_t size, const rtc::PacketTime& packet_time) {
-  rtc::scoped_ptr<IceMessage> msg;
+  std::unique_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
   if (!port_->GetStunMessage(data, size, addr, &msg, &remote_ufrag)) {

webrtc/p2p/base/port.h

diff --git a/webrtc/p2p/base/port.h b/webrtc/p2p/base/port.h
index 2961355..7ec33bc 100644
--- a/webrtc/p2p/base/port.h
+++ b/webrtc/p2p/base/port.h
@@ -12,6 +12,7 @@
 #define WEBRTC_P2P_BASE_PORT_H_
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -336,7 +337,7 @@
   bool GetStunMessage(const char* data,
                       size_t size,
                       const rtc::SocketAddress& addr,
-                      rtc::scoped_ptr<IceMessage>* out_msg,
+                      std::unique_ptr<IceMessage>* out_msg,
                       std::string* out_username);
 
   // Checks if the address in addr is compatible with the port's ip.

webrtc/p2p/base/port_unittest.cc

diff --git a/webrtc/p2p/base/port_unittest.cc b/webrtc/p2p/base/port_unittest.cc
index fc49f20..7e787e0 100644
--- a/webrtc/p2p/base/port_unittest.cc
+++ b/webrtc/p2p/base/port_unittest.cc
@@ -8,6 +8,8 @@
  *  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"
@@ -26,7 +28,6 @@
 #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"
@@ -43,7 +44,6 @@
 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;
@@ -212,8 +212,8 @@
                     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;
 };
 
@@ -344,12 +344,12 @@
   }
 
   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;
@@ -764,18 +764,18 @@
 
  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_;
@@ -1217,7 +1217,7 @@
   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));
@@ -1322,7 +1322,7 @@
 // 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);
@@ -1354,7 +1354,7 @@
   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);
@@ -1368,7 +1368,7 @@
   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);
@@ -1382,11 +1382,11 @@
 // 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);
@@ -1430,8 +1430,7 @@
   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();
@@ -1447,8 +1446,7 @@
   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();
@@ -1461,7 +1459,7 @@
 
 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),
@@ -1531,7 +1529,7 @@
 
 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),
@@ -1564,23 +1562,23 @@
 // 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,
@@ -1588,8 +1586,8 @@
   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));
@@ -1598,9 +1596,9 @@
 
 // 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);
@@ -1647,7 +1645,7 @@
   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());
@@ -1738,9 +1736,9 @@
 }
 
 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);
@@ -1765,11 +1763,11 @@
 }
 
 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);
@@ -1812,11 +1810,10 @@
 // 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;
 
@@ -1862,11 +1859,10 @@
 
 // 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;
 
@@ -1931,11 +1927,10 @@
 // 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;
 
@@ -1972,11 +1967,10 @@
 // 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;
 
@@ -2038,14 +2032,14 @@
 // 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;
 
@@ -2060,7 +2054,7 @@
 
   // 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);
@@ -2096,8 +2090,7 @@
 }
 
 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));
@@ -2134,7 +2127,7 @@
 // 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,
@@ -2148,21 +2141,21 @@
 
 // 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);
@@ -2175,8 +2168,7 @@
   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();
@@ -2186,8 +2178,8 @@
   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(),
@@ -2196,8 +2188,8 @@
             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(),
@@ -2208,9 +2200,9 @@
   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(),
@@ -2220,7 +2212,7 @@
   // 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);
@@ -2231,16 +2223,16 @@
 // 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);
@@ -2253,8 +2245,7 @@
   // 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();
@@ -2264,8 +2255,8 @@
             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(),
@@ -2285,10 +2276,10 @@
 
 // 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);
@@ -2428,9 +2419,9 @@
       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);
@@ -2462,7 +2453,7 @@
   // 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());
 
@@ -2576,21 +2567,21 @@
 }
 
 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));

webrtc/p2p/base/pseudotcp.cc

diff --git a/webrtc/p2p/base/pseudotcp.cc b/webrtc/p2p/base/pseudotcp.cc
index 1dfdcbb..612623b 100644
--- a/webrtc/p2p/base/pseudotcp.cc
+++ b/webrtc/p2p/base/pseudotcp.cc
@@ -14,6 +14,7 @@
 #include <stdlib.h>
 
 #include <algorithm>
+#include <memory>
 #include <set>
 
 #include "webrtc/base/arraysize.h"
@@ -22,7 +23,6 @@
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
@@ -518,7 +518,7 @@
 
   uint32_t now = Now();
 
-  rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[MAX_PACKET]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[MAX_PACKET]);
   long_to_bytes(m_conv, buffer.get());
   long_to_bytes(seq, buffer.get() + 4);
   long_to_bytes(m_rcv_nxt, buffer.get() + 8);

webrtc/p2p/base/relayport_unittest.cc

diff --git a/webrtc/p2p/base/relayport_unittest.cc b/webrtc/p2p/base/relayport_unittest.cc
index d644d67..738ea9a 100644
--- a/webrtc/p2p/base/relayport_unittest.cc
+++ b/webrtc/p2p/base/relayport_unittest.cc
@@ -8,6 +8,8 @@
  *  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/relayserver.h"
@@ -15,7 +17,6 @@
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
@@ -179,7 +180,7 @@
 
     // Create a tcp server socket that listens on the fake address so
     // the relay port can attempt to connect to it.
-    rtc::scoped_ptr<rtc::AsyncSocket> tcp_server_socket(
+    std::unique_ptr<rtc::AsyncSocket> tcp_server_socket(
         CreateServerSocket(kRelayTcpAddr));
 
     // Add server addresses to the relay port and let it start.
@@ -244,16 +245,15 @@
   typedef std::map<rtc::AsyncPacketSocket*, int> PacketMap;
 
   rtc::Thread* main_;
-  rtc::scoped_ptr<rtc::PhysicalSocketServer>
-      physical_socket_server_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> virtual_socket_server_;
+  std::unique_ptr<rtc::PhysicalSocketServer> physical_socket_server_;
+  std::unique_ptr<rtc::VirtualSocketServer> virtual_socket_server_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
   std::string username_;
   std::string password_;
-  rtc::scoped_ptr<cricket::RelayPort> relay_port_;
-  rtc::scoped_ptr<cricket::RelayServer> relay_server_;
+  std::unique_ptr<cricket::RelayPort> relay_port_;
+  std::unique_ptr<cricket::RelayServer> relay_server_;
   std::vector<cricket::ProtocolAddress> failed_connections_;
   std::vector<cricket::ProtocolAddress> soft_timedout_connections_;
   PacketMap received_packet_count_;

webrtc/p2p/base/relayserver_unittest.cc

diff --git a/webrtc/p2p/base/relayserver_unittest.cc b/webrtc/p2p/base/relayserver_unittest.cc
index 3581f71..1d07a07 100644
--- a/webrtc/p2p/base/relayserver_unittest.cc
+++ b/webrtc/p2p/base/relayserver_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 
 #include "webrtc/p2p/base/relayserver.h"
@@ -60,16 +61,14 @@
   }
 
   void Allocate() {
-    rtc::scoped_ptr<StunMessage> req(
-        CreateStunMessage(STUN_ALLOCATE_REQUEST));
+    std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST));
     AddUsernameAttr(req.get(), username_);
     AddLifetimeAttr(req.get(), LIFETIME);
     Send1(req.get());
     delete Receive1();
   }
   void Bind() {
-    rtc::scoped_ptr<StunMessage> req(
-        CreateStunMessage(STUN_BINDING_REQUEST));
+    std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST));
     AddUsernameAttr(req.get(), username_);
     Send2(req.get());
     delete Receive1();
@@ -172,12 +171,12 @@
     msg->AddAttribute(attr);
   }
 
-  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::scoped_ptr<RelayServer> server_;
-  rtc::scoped_ptr<rtc::TestClient> client1_;
-  rtc::scoped_ptr<rtc::TestClient> client2_;
+  std::unique_ptr<RelayServer> server_;
+  std::unique_ptr<rtc::TestClient> client1_;
+  std::unique_ptr<rtc::TestClient> client2_;
   std::string username_;
   std::string password_;
 };
@@ -190,8 +189,8 @@
 
 // Send an allocate request without a username and verify it is rejected.
 TEST_F(RelayServerTest, TestAllocateNoUsername) {
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)),
+      res;
 
   Send1(req.get());
   res.reset(Receive1());
@@ -209,8 +208,8 @@
 
 // Send a binding request and verify that it is rejected.
 TEST_F(RelayServerTest, TestBindingRequest) {
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_BINDING_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)),
+      res;
   AddUsernameAttr(req.get(), username_);
 
   Send1(req.get());
@@ -229,8 +228,8 @@
 
 // Send an allocate request and verify that it is accepted.
 TEST_F(RelayServerTest, TestAllocate) {
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)),
+      res;
   AddUsernameAttr(req.get(), username_);
   AddLifetimeAttr(req.get(), LIFETIME);
 
@@ -259,8 +258,8 @@
 TEST_F(RelayServerTest, TestReallocate) {
   Allocate();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)),
+      res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
 
@@ -289,8 +288,8 @@
 TEST_F(RelayServerTest, TestRemoteBind) {
   Allocate();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_BINDING_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)),
+      res;
   AddUsernameAttr(req.get(), username_);
 
   Send2(req.get());
@@ -304,7 +303,7 @@
   ASSERT_TRUE(recv_data != NULL);
 
   rtc::ByteBufferReader buf(recv_data->bytes(), recv_data->length());
-  rtc::scoped_ptr<StunMessage> res2(new StunMessage());
+  std::unique_ptr<StunMessage> res2(new StunMessage());
   EXPECT_TRUE(res2->Read(&buf));
   EXPECT_EQ(STUN_BINDING_REQUEST, res2->type());
   EXPECT_EQ(req->transaction_id(), res2->transaction_id());
@@ -335,8 +334,7 @@
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
 
   Send1(req.get());
@@ -358,8 +356,7 @@
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), "foobarbizbaz");
 
@@ -383,8 +380,7 @@
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
 
@@ -407,8 +403,7 @@
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
   AddDestinationAttr(req.get(), client2_addr);
@@ -432,8 +427,8 @@
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_BINDING_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)),
+      res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
 
@@ -458,8 +453,7 @@
   Bind();
 
   for (int i = 0; i < 10; i++) {
-    rtc::scoped_ptr<StunMessage> req(
-        CreateStunMessage(STUN_SEND_REQUEST)), res;
+    std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
     AddMagicCookieAttr(req.get());
     AddUsernameAttr(req.get(), username_);
     AddDestinationAttr(req.get(), client2_addr);
@@ -501,8 +495,7 @@
   // Wait twice the lifetime to make sure the server has expired the binding.
   rtc::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000);
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
   AddDestinationAttr(req.get(), client2_addr);

webrtc/p2p/base/stun.cc

diff --git a/webrtc/p2p/base/stun.cc b/webrtc/p2p/base/stun.cc
index d0f0014..ac3fd5f 100644
--- a/webrtc/p2p/base/stun.cc
+++ b/webrtc/p2p/base/stun.cc
@@ -12,12 +12,13 @@
 
 #include <string.h>
 
+#include <memory>
+
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 
 using rtc::ByteBufferReader;
@@ -173,7 +174,7 @@
 
   // Getting length of the message to calculate Message Integrity.
   size_t mi_pos = current_pos;
-  rtc::scoped_ptr<char[]> temp_data(new char[current_pos]);
+  std::unique_ptr<char[]> temp_data(new char[current_pos]);
   memcpy(temp_data.get(), data, current_pos);
   if (size > mi_pos + kStunAttributeHeaderSize + kStunMessageIntegritySize) {
     // Stun message has other attributes after message integrity.

webrtc/p2p/base/stun_unittest.cc

diff --git a/webrtc/p2p/base/stun_unittest.cc b/webrtc/p2p/base/stun_unittest.cc
index 2213397..d7ca999 100644
--- a/webrtc/p2p/base/stun_unittest.cc
+++ b/webrtc/p2p/base/stun_unittest.cc
@@ -16,7 +16,6 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketaddress.h"
 
 namespace cricket {

webrtc/p2p/base/stunport.h

diff --git a/webrtc/p2p/base/stunport.h b/webrtc/p2p/base/stunport.h
index a0eba51..cd844aa 100644
--- a/webrtc/p2p/base/stunport.h
+++ b/webrtc/p2p/base/stunport.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_P2P_BASE_STUNPORT_H_
 #define WEBRTC_P2P_BASE_STUNPORT_H_
 
+#include <memory>
 #include <string>
 
 #include "webrtc/p2p/base/port.h"
@@ -224,7 +225,7 @@
   StunRequestManager requests_;
   rtc::AsyncPacketSocket* socket_;
   int error_;
-  rtc::scoped_ptr<AddressResolver> resolver_;
+  std::unique_ptr<AddressResolver> resolver_;
   bool ready_;
   int stun_keepalive_delay_;
   int stun_keepalive_lifetime_;

webrtc/p2p/base/stunport_unittest.cc

diff --git a/webrtc/p2p/base/stunport_unittest.cc b/webrtc/p2p/base/stunport_unittest.cc
index 1926b93..702ec25 100644
--- a/webrtc/p2p/base/stunport_unittest.cc
+++ b/webrtc/p2p/base/stunport_unittest.cc
@@ -8,13 +8,14 @@
  *  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/stunport.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.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/virtualsocketserver.h"
@@ -155,15 +156,15 @@
   }
 
  private:
-  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<cricket::UDPPort> stun_port_;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_1_;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_2_;
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
+  std::unique_ptr<cricket::UDPPort> stun_port_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_1_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_2_;
+  std::unique_ptr<rtc::AsyncPacketSocket> socket_;
   bool done_;
   bool error_;
   int stun_keepalive_delay_;

webrtc/p2p/base/stunrequest.cc

diff --git a/webrtc/p2p/base/stunrequest.cc b/webrtc/p2p/base/stunrequest.cc
index 546dd15..b12e7cb 100644
--- a/webrtc/p2p/base/stunrequest.cc
+++ b/webrtc/p2p/base/stunrequest.cc
@@ -11,6 +11,8 @@
 #include "webrtc/p2p/base/stunrequest.h"
 
 #include <algorithm>
+#include <memory>
+
 #include "webrtc/base/common.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
@@ -139,7 +141,7 @@
   // Parse the STUN message and continue processing as usual.
 
   rtc::ByteBufferReader buf(data, size);
-  rtc::scoped_ptr<StunMessage> response(iter->second->msg_->CreateNew());
+  std::unique_ptr<StunMessage> response(iter->second->msg_->CreateNew());
   if (!response->Read(&buf)) {
     LOG(LS_WARNING) << "Failed to read STUN response " << rtc::hex_encode(id);
     return false;

webrtc/p2p/base/stunserver.h

diff --git a/webrtc/p2p/base/stunserver.h b/webrtc/p2p/base/stunserver.h
index a7eeab1..3f7e7de 100644
--- a/webrtc/p2p/base/stunserver.h
+++ b/webrtc/p2p/base/stunserver.h
@@ -11,6 +11,8 @@
 #ifndef WEBRTC_P2P_BASE_STUNSERVER_H_
 #define WEBRTC_P2P_BASE_STUNSERVER_H_
 
+#include <memory>
+
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/asyncudpsocket.h"
 #include "webrtc/base/scoped_ptr.h"
@@ -58,7 +60,7 @@
                            StunMessage* response) const;
 
  private:
-  rtc::scoped_ptr<rtc::AsyncUDPSocket> socket_;
+  std::unique_ptr<rtc::AsyncUDPSocket> socket_;
 };
 
 }  // namespace cricket

webrtc/p2p/base/stunserver_unittest.cc

diff --git a/webrtc/p2p/base/stunserver_unittest.cc b/webrtc/p2p/base/stunserver_unittest.cc
index 973ab2a..e468447 100644
--- a/webrtc/p2p/base/stunserver_unittest.cc
+++ b/webrtc/p2p/base/stunserver_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 
 #include "webrtc/p2p/base/stunserver.h"
@@ -62,11 +63,11 @@
     return msg;
   }
  private:
-  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::Thread worker_;
-  rtc::scoped_ptr<StunServer> server_;
-  rtc::scoped_ptr<rtc::TestClient> client_;
+  std::unique_ptr<StunServer> server_;
+  std::unique_ptr<rtc::TestClient> client_;
 };
 
 // Disable for TSan v2, see

webrtc/p2p/base/tcpport.h

diff --git a/webrtc/p2p/base/tcpport.h b/webrtc/p2p/base/tcpport.h
index cfc6245..77bbd09 100644
--- a/webrtc/p2p/base/tcpport.h
+++ b/webrtc/p2p/base/tcpport.h
@@ -12,7 +12,9 @@
 #define WEBRTC_P2P_BASE_TCPPORT_H_
 
 #include <list>
+#include <memory>
 #include <string>
+
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/base/asyncpacketsocket.h"
 
@@ -164,7 +166,7 @@
                     const rtc::PacketTime& packet_time);
   void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
+  std::unique_ptr<rtc::AsyncPacketSocket> socket_;
   int error_;
   bool outgoing_;
 

webrtc/p2p/base/testrelayserver.h

diff --git a/webrtc/p2p/base/testrelayserver.h b/webrtc/p2p/base/testrelayserver.h
index 87cb9e5..ba64008 100644
--- a/webrtc/p2p/base/testrelayserver.h
+++ b/webrtc/p2p/base/testrelayserver.h
@@ -11,6 +11,8 @@
 #ifndef WEBRTC_P2P_BASE_TESTRELAYSERVER_H_
 #define WEBRTC_P2P_BASE_TESTRELAYSERVER_H_
 
+#include <memory>
+
 #include "webrtc/p2p/base/relayserver.h"
 #include "webrtc/base/asynctcpsocket.h"
 #include "webrtc/base/scoped_ptr.h"
@@ -90,10 +92,10 @@
   }
  private:
   cricket::RelayServer server_;
-  rtc::scoped_ptr<rtc::AsyncSocket> tcp_int_socket_;
-  rtc::scoped_ptr<rtc::AsyncSocket> tcp_ext_socket_;
-  rtc::scoped_ptr<rtc::AsyncSocket> ssl_int_socket_;
-  rtc::scoped_ptr<rtc::AsyncSocket> ssl_ext_socket_;
+  std::unique_ptr<rtc::AsyncSocket> tcp_int_socket_;
+  std::unique_ptr<rtc::AsyncSocket> tcp_ext_socket_;
+  std::unique_ptr<rtc::AsyncSocket> ssl_int_socket_;
+  std::unique_ptr<rtc::AsyncSocket> ssl_ext_socket_;
 };
 
 }  // namespace cricket

webrtc/p2p/base/transport_unittest.cc

diff --git a/webrtc/p2p/base/transport_unittest.cc b/webrtc/p2p/base/transport_unittest.cc
index 15bbe6e..658c143 100644
--- a/webrtc/p2p/base/transport_unittest.cc
+++ b/webrtc/p2p/base/transport_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/network.h"
@@ -50,7 +52,7 @@
   }
 
  protected:
-  rtc::scoped_ptr<FakeTransport> transport_;
+  std::unique_ptr<FakeTransport> transport_;
   FakeTransportChannel* channel_;
 };
 

webrtc/p2p/base/transportdescription.h

diff --git a/webrtc/p2p/base/transportdescription.h b/webrtc/p2p/base/transportdescription.h
index 003780b..d9cd524 100644
--- a/webrtc/p2p/base/transportdescription.h
+++ b/webrtc/p2p/base/transportdescription.h
@@ -12,6 +12,7 @@
 #define WEBRTC_P2P_BASE_TRANSPORTDESCRIPTION_H_
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -139,7 +140,7 @@
   IceMode ice_mode;
   ConnectionRole connection_role;
 
-  rtc::scoped_ptr<rtc::SSLFingerprint> identity_fingerprint;
+  std::unique_ptr<rtc::SSLFingerprint> identity_fingerprint;
 };
 
 }  // namespace cricket

webrtc/p2p/base/transportdescriptionfactory.cc

diff --git a/webrtc/p2p/base/transportdescriptionfactory.cc b/webrtc/p2p/base/transportdescriptionfactory.cc
index 1ddf55d..e57b7e3 100644
--- a/webrtc/p2p/base/transportdescriptionfactory.cc
+++ b/webrtc/p2p/base/transportdescriptionfactory.cc
@@ -10,6 +10,8 @@
 
 #include "webrtc/p2p/base/transportdescriptionfactory.h"
 
+#include <memory>
+
 #include "webrtc/p2p/base/transportdescription.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
@@ -25,7 +27,7 @@
 TransportDescription* TransportDescriptionFactory::CreateOffer(
     const TransportOptions& options,
     const TransportDescription* current_description) const {
-  rtc::scoped_ptr<TransportDescription> desc(new TransportDescription());
+  std::unique_ptr<TransportDescription> desc(new TransportDescription());
 
   // Generate the ICE credentials if we don't already have them.
   if (!current_description || options.ice_restart) {
@@ -59,7 +61,7 @@
     return NULL;
   }
 
-  rtc::scoped_ptr<TransportDescription> desc(new TransportDescription());
+  std::unique_ptr<TransportDescription> desc(new TransportDescription());
   // Generate the ICE credentials if we don't already have them or ice is
   // being restarted.
   if (!current_description || options.ice_restart) {

webrtc/p2p/base/turnport_unittest.cc

diff --git a/webrtc/p2p/base/turnport_unittest.cc b/webrtc/p2p/base/turnport_unittest.cc
index 2c93ead..56d4460 100644
--- a/webrtc/p2p/base/turnport_unittest.cc
+++ b/webrtc/p2p/base/turnport_unittest.cc
@@ -11,6 +11,8 @@
 #include <dirent.h>
 #endif
 
+#include <memory>
+
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/portallocator.h"
@@ -26,7 +28,6 @@
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.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/thread.h"
@@ -507,15 +508,15 @@
 
  protected:
   rtc::Thread* main_;
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<TurnPortTestVirtualSocketServer> ss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<TurnPortTestVirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
+  std::unique_ptr<rtc::AsyncPacketSocket> socket_;
   cricket::TestTurnServer turn_server_;
-  rtc::scoped_ptr<TurnPort> turn_port_;
-  rtc::scoped_ptr<UDPPort> udp_port_;
+  std::unique_ptr<TurnPort> turn_port_;
+  std::unique_ptr<UDPPort> udp_port_;
   bool turn_ready_;
   bool turn_error_;
   bool turn_unknown_address_;

webrtc/p2p/base/turnserver.h

diff --git a/webrtc/p2p/base/turnserver.h b/webrtc/p2p/base/turnserver.h
index e520a9e..c9eb803 100644
--- a/webrtc/p2p/base/turnserver.h
+++ b/webrtc/p2p/base/turnserver.h
@@ -13,6 +13,7 @@
 
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 
@@ -125,7 +126,7 @@
   TurnServer* server_;
   rtc::Thread* thread_;
   TurnServerConnection conn_;
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> external_socket_;
+  std::unique_ptr<rtc::AsyncPacketSocket> external_socket_;
   std::string key_;
   std::string transaction_id_;
   std::string username_;
@@ -269,8 +270,7 @@
 
   InternalSocketMap server_sockets_;
   ServerSocketMap server_listen_sockets_;
-  rtc::scoped_ptr<rtc::PacketSocketFactory>
-      external_socket_factory_;
+  std::unique_ptr<rtc::PacketSocketFactory> external_socket_factory_;
   rtc::SocketAddress external_addr_;
 
   AllocationMap allocations_;

webrtc/p2p/client/basicportallocator.h

diff --git a/webrtc/p2p/client/basicportallocator.h b/webrtc/p2p/client/basicportallocator.h
index ca1a23a..c66ae59 100644
--- a/webrtc/p2p/client/basicportallocator.h
+++ b/webrtc/p2p/client/basicportallocator.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_P2P_CLIENT_BASICPORTALLOCATOR_H_
 #define WEBRTC_P2P_CLIENT_BASICPORTALLOCATOR_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -185,7 +186,7 @@
 
   BasicPortAllocator* allocator_;
   rtc::Thread* network_thread_;
-  rtc::scoped_ptr<rtc::PacketSocketFactory> owned_socket_factory_;
+  std::unique_ptr<rtc::PacketSocketFactory> owned_socket_factory_;
   rtc::PacketSocketFactory* socket_factory_;
   bool allocation_started_;
   bool network_manager_started_;
@@ -320,7 +321,7 @@
   State state_;
   uint32_t flags_;
   ProtocolList protocols_;
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> udp_socket_;
+  std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_;
   // There will be only one udp port per AllocationSequence.
   UDPPort* udp_port_;
   std::vector<TurnPort*> turn_ports_;

webrtc/p2p/client/fakeportallocator.h

diff --git a/webrtc/p2p/client/fakeportallocator.h b/webrtc/p2p/client/fakeportallocator.h
index fb18826..d16c9b6 100644
--- a/webrtc/p2p/client/fakeportallocator.h
+++ b/webrtc/p2p/client/fakeportallocator.h
@@ -11,7 +11,9 @@
 #ifndef WEBRTC_P2P_CLIENT_FAKEPORTALLOCATOR_H_
 #define WEBRTC_P2P_CLIENT_FAKEPORTALLOCATOR_H_
 
+#include <memory>
 #include <string>
+
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/udpport.h"
@@ -133,7 +135,7 @@
   rtc::Thread* worker_thread_;
   rtc::PacketSocketFactory* factory_;
   rtc::Network network_;
-  rtc::scoped_ptr<cricket::Port> port_;
+  std::unique_ptr<cricket::Port> port_;
   bool running_;
   int port_config_count_;
 };
@@ -177,7 +179,7 @@
  private:
   rtc::Thread* worker_thread_;
   rtc::PacketSocketFactory* factory_;
-  rtc::scoped_ptr<rtc::BasicPacketSocketFactory> owned_factory_;
+  std::unique_ptr<rtc::BasicPacketSocketFactory> owned_factory_;
   ServerAddresses stun_servers_;
   std::vector<RelayServerConfig> turn_servers_;
 };

webrtc/p2p/client/portallocator_unittest.cc

diff --git a/webrtc/p2p/client/portallocator_unittest.cc b/webrtc/p2p/client/portallocator_unittest.cc
index a76900a..2181903 100644
--- a/webrtc/p2p/client/portallocator_unittest.cc
+++ b/webrtc/p2p/client/portallocator_unittest.cc
@@ -8,6 +8,8 @@
  *  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/p2pconstants.h"
 #include "webrtc/p2p/base/p2ptransportchannel.h"
@@ -370,19 +372,19 @@
     allocator().set_step_delay(cricket::kMinimumStepDelay);
   }
 
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
-  rtc::scoped_ptr<rtc::FirewallSocketServer> fss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
+  std::unique_ptr<rtc::FirewallSocketServer> fss_;
   rtc::SocketServerScope ss_scope_;
-  rtc::scoped_ptr<rtc::NATServer> nat_server_;
+  std::unique_ptr<rtc::NATServer> nat_server_;
   rtc::NATSocketFactory nat_factory_;
-  rtc::scoped_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_;
+  std::unique_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_;
   cricket::TestRelayServer relay_server_;
   cricket::TestTurnServer turn_server_;
   rtc::FakeNetworkManager network_manager_;
-  rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
-  rtc::scoped_ptr<cricket::PortAllocatorSession> session_;
+  std::unique_ptr<cricket::BasicPortAllocator> allocator_;
+  std::unique_ptr<cricket::PortAllocatorSession> session_;
   std::vector<cricket::PortInterface*> ports_;
   std::vector<cricket::Candidate> candidates_;
   bool candidate_allocation_done_;

webrtc/p2p/quic/quicconnectionhelper_unittest.cc

diff --git a/webrtc/p2p/quic/quicconnectionhelper_unittest.cc b/webrtc/p2p/quic/quicconnectionhelper_unittest.cc
index 1a7313c..b56ae8c 100644
--- a/webrtc/p2p/quic/quicconnectionhelper_unittest.cc
+++ b/webrtc/p2p/quic/quicconnectionhelper_unittest.cc
@@ -8,11 +8,12 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/p2p/quic/quicconnectionhelper.h"
 
 #include "net/quic/quic_time.h"
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 
 using cricket::QuicAlarm;
 using cricket::QuicConnectionHelper;
@@ -89,7 +90,7 @@
   // Used for setting clock time relative to alarm.
   MockClock clock_;
 
-  rtc::scoped_ptr<QuicAlarm> alarm_;
+  std::unique_ptr<QuicAlarm> alarm_;
 };
 
 // Test that the alarm is fired.

webrtc/p2p/quic/quicsession.cc

diff --git a/webrtc/p2p/quic/quicsession.cc b/webrtc/p2p/quic/quicsession.cc
index a70aa0b..7464c68 100644
--- a/webrtc/p2p/quic/quicsession.cc
+++ b/webrtc/p2p/quic/quicsession.cc
@@ -20,7 +20,7 @@
 
 namespace cricket {
 
-QuicSession::QuicSession(rtc::scoped_ptr<net::QuicConnection> connection,
+QuicSession::QuicSession(std::unique_ptr<net::QuicConnection> connection,
                          const net::QuicConfig& config)
     : net::QuicSession(connection.release(), config) {}
 

webrtc/p2p/quic/quicsession.h

diff --git a/webrtc/p2p/quic/quicsession.h b/webrtc/p2p/quic/quicsession.h
index e0ea296..a6da38a 100644
--- a/webrtc/p2p/quic/quicsession.h
+++ b/webrtc/p2p/quic/quicsession.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_P2P_QUIC_QUICSESSION_H_
 #define WEBRTC_P2P_QUIC_QUICSESSION_H_
 
+#include <memory>
 #include <string>
 
 #include "net/quic/quic_crypto_client_stream.h"
@@ -29,7 +30,7 @@
 // reading/writing of data using QUIC packets.
 class QuicSession : public net::QuicSession, public sigslot::has_slots<> {
  public:
-  QuicSession(rtc::scoped_ptr<net::QuicConnection> connection,
+  QuicSession(std::unique_ptr<net::QuicConnection> connection,
               const net::QuicConfig& config);
   ~QuicSession() override;
 
@@ -82,7 +83,7 @@
   virtual ReliableQuicStream* CreateDataStream(net::QuicStreamId id);
 
  private:
-  rtc::scoped_ptr<net::QuicCryptoStream> crypto_stream_;
+  std::unique_ptr<net::QuicCryptoStream> crypto_stream_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };

webrtc/p2p/quic/quicsession_unittest.cc

diff --git a/webrtc/p2p/quic/quicsession_unittest.cc b/webrtc/p2p/quic/quicsession_unittest.cc
index 04b7d1e..eae0a2b 100644
--- a/webrtc/p2p/quic/quicsession_unittest.cc
+++ b/webrtc/p2p/quic/quicsession_unittest.cc
@@ -10,6 +10,7 @@
 
 #include "webrtc/p2p/quic/quicsession.h"
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -117,7 +118,7 @@
       const std::string& signature,
       const net::ProofVerifyContext* verify_context,
       std::string* error_details,
-      scoped_ptr<net::ProofVerifyDetails>* verify_details,
+      std::unique_ptr<net::ProofVerifyDetails>* verify_details,
       net::ProofVerifierCallback* callback) override {
     return success_ ? net::QUIC_SUCCESS : net::QUIC_FAILURE;
   }
@@ -179,9 +180,9 @@
 // Wrapper for QuicSession and transport channel that stores incoming data.
 class QuicSessionForTest : public QuicSession {
  public:
-  QuicSessionForTest(rtc::scoped_ptr<net::QuicConnection> connection,
+  QuicSessionForTest(std::unique_ptr<net::QuicConnection> connection,
                      const net::QuicConfig& config,
-                     rtc::scoped_ptr<FakeTransportChannel> channel)
+                     std::unique_ptr<FakeTransportChannel> channel)
       : QuicSession(std::move(connection), config),
         channel_(std::move(channel)) {
     channel_->SignalReadPacket.connect(
@@ -219,7 +220,7 @@
 
  private:
   // Transports QUIC packets to/from peer.
-  rtc::scoped_ptr<FakeTransportChannel> channel_;
+  std::unique_ptr<FakeTransportChannel> channel_;
   // Stores data received by peer once it is sent from the other peer.
   std::string last_received_data_;
   // Handles incoming streams from sender.
@@ -235,8 +236,8 @@
   // Instantiates |client_peer_| and |server_peer_|.
   void CreateClientAndServerSessions();
 
-  rtc::scoped_ptr<QuicSessionForTest> CreateSession(
-      rtc::scoped_ptr<FakeTransportChannel> channel,
+  std::unique_ptr<QuicSessionForTest> CreateSession(
+      std::unique_ptr<FakeTransportChannel> channel,
       Perspective perspective);
 
   QuicCryptoClientStream* CreateCryptoClientStream(QuicSessionForTest* session,
@@ -244,7 +245,7 @@
   QuicCryptoServerStream* CreateCryptoServerStream(QuicSessionForTest* session,
                                                    bool handshake_success);
 
-  rtc::scoped_ptr<QuicConnection> CreateConnection(
+  std::unique_ptr<QuicConnection> CreateConnection(
       FakeTransportChannel* channel,
       Perspective perspective);
 
@@ -268,16 +269,16 @@
   QuicConfig config_;
   QuicClock clock_;
 
-  rtc::scoped_ptr<QuicSessionForTest> client_peer_;
-  rtc::scoped_ptr<QuicSessionForTest> server_peer_;
+  std::unique_ptr<QuicSessionForTest> client_peer_;
+  std::unique_ptr<QuicSessionForTest> server_peer_;
 };
 
 // Initializes "client peer" who begins crypto handshake and "server peer" who
 // establishes encryption with client.
 void QuicSessionTest::CreateClientAndServerSessions() {
-  rtc::scoped_ptr<FakeTransportChannel> channel1(
+  std::unique_ptr<FakeTransportChannel> channel1(
       new FakeTransportChannel("channel1", 0));
-  rtc::scoped_ptr<FakeTransportChannel> channel2(
+  std::unique_ptr<FakeTransportChannel> channel2(
       new FakeTransportChannel("channel2", 0));
 
   // Prevent channel1->OnReadPacket and channel2->OnReadPacket from calling
@@ -294,12 +295,12 @@
   server_peer_ = CreateSession(std::move(channel2), Perspective::IS_SERVER);
 }
 
-rtc::scoped_ptr<QuicSessionForTest> QuicSessionTest::CreateSession(
-    rtc::scoped_ptr<FakeTransportChannel> channel,
+std::unique_ptr<QuicSessionForTest> QuicSessionTest::CreateSession(
+    std::unique_ptr<FakeTransportChannel> channel,
     Perspective perspective) {
-  rtc::scoped_ptr<QuicConnection> quic_connection =
+  std::unique_ptr<QuicConnection> quic_connection =
       CreateConnection(channel.get(), perspective);
-  return rtc::scoped_ptr<QuicSessionForTest>(new QuicSessionForTest(
+  return std::unique_ptr<QuicSessionForTest>(new QuicSessionForTest(
       std::move(quic_connection), config_, std::move(channel)));
 }
 
@@ -326,7 +327,7 @@
   return new QuicCryptoServerStream(server_config, session);
 }
 
-rtc::scoped_ptr<QuicConnection> QuicSessionTest::CreateConnection(
+std::unique_ptr<QuicConnection> QuicSessionTest::CreateConnection(
     FakeTransportChannel* channel,
     Perspective perspective) {
   FakeQuicPacketWriter* writer = new FakeQuicPacketWriter(channel);
@@ -334,7 +335,7 @@
   IPAddress ip(0, 0, 0, 0);
   bool owns_writer = true;
 
-  return rtc::scoped_ptr<QuicConnection>(new QuicConnection(
+  return std::unique_ptr<QuicConnection>(new QuicConnection(
       0, net::IPEndPoint(ip, 0), &quic_helper_, writer, owns_writer,
       perspective, net::QuicSupportedVersions()));
 }

webrtc/p2p/quic/quictransportchannel.cc

diff --git a/webrtc/p2p/quic/quictransportchannel.cc b/webrtc/p2p/quic/quictransportchannel.cc
index 446fd42..5196ac0 100644
--- a/webrtc/p2p/quic/quictransportchannel.cc
+++ b/webrtc/p2p/quic/quictransportchannel.cc
@@ -110,7 +110,7 @@
       const std::string& signature,
       const net::ProofVerifyContext* verify_context,
       std::string* error_details,
-      scoped_ptr<net::ProofVerifyDetails>* verify_details,
+      std::unique_ptr<net::ProofVerifyDetails>* verify_details,
       net::ProofVerifierCallback* callback) override {
     LOG(LS_INFO) << "VerifyProof() ignoring credentials and returning success";
     return net::QUIC_SUCCESS;
@@ -435,7 +435,7 @@
                                      ? net::Perspective::IS_CLIENT
                                      : net::Perspective::IS_SERVER;
   bool owns_writer = false;
-  rtc::scoped_ptr<net::QuicConnection> connection(new net::QuicConnection(
+  std::unique_ptr<net::QuicConnection> connection(new net::QuicConnection(
       kConnectionId, kConnectionIpEndpoint, &helper_, this, owns_writer,
       perspective, net::QuicSupportedVersions()));
   quic_.reset(new QuicSession(std::move(connection), config_));

webrtc/p2p/quic/quictransportchannel.h

diff --git a/webrtc/p2p/quic/quictransportchannel.h b/webrtc/p2p/quic/quictransportchannel.h
index 49d786c..c9c253d 100644
--- a/webrtc/p2p/quic/quictransportchannel.h
+++ b/webrtc/p2p/quic/quictransportchannel.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_
 #define WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -117,7 +118,7 @@
                             size_t result_len) override;
   // TODO(mikescarlett): Remove this method once TransportChannel does not
   // require defining it.
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
       const override {
     return nullptr;
   }
@@ -277,7 +278,7 @@
   QuicTransportState quic_state_ = QUIC_TRANSPORT_NEW;
   // QUIC session which establishes the crypto handshake and converts data
   // to/from QUIC packets.
-  rtc::scoped_ptr<QuicSession> quic_;
+  std::unique_ptr<QuicSession> quic_;
   // Non-crypto config for |quic_|.
   net::QuicConfig config_;
   // Helper for net::QuicConnection that provides timing and
@@ -288,9 +289,9 @@
   // the handshake. This must be set before we start QUIC.
   rtc::Optional<rtc::SSLRole> ssl_role_;
   // Config for QUIC crypto client stream, used when |ssl_role_| is SSL_CLIENT.
-  rtc::scoped_ptr<net::QuicCryptoClientConfig> quic_crypto_client_config_;
+  std::unique_ptr<net::QuicCryptoClientConfig> quic_crypto_client_config_;
   // Config for QUIC crypto server stream, used when |ssl_role_| is SSL_SERVER.
-  rtc::scoped_ptr<net::QuicCryptoServerConfig> quic_crypto_server_config_;
+  std::unique_ptr<net::QuicCryptoServerConfig> quic_crypto_server_config_;
   // This peer's certificate.
   rtc::scoped_refptr<rtc::RTCCertificate> local_certificate_;
   // Fingerprint of the remote peer. This must be set before we start QUIC.

webrtc/p2p/quic/quictransportchannel_unittest.cc

diff --git a/webrtc/p2p/quic/quictransportchannel_unittest.cc b/webrtc/p2p/quic/quictransportchannel_unittest.cc
index c64aa40..45d3db8 100644
--- a/webrtc/p2p/quic/quictransportchannel_unittest.cc
+++ b/webrtc/p2p/quic/quictransportchannel_unittest.cc
@@ -10,13 +10,13 @@
 
 #include "webrtc/p2p/quic/quictransportchannel.h"
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 
@@ -103,7 +103,7 @@
     quic_channel_.SignalClosed.connect(this, &QuicTestPeer::OnClosed);
     ice_channel_.SetAsync(true);
     rtc::scoped_refptr<rtc::RTCCertificate> local_cert =
-        rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+        rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, rtc::KT_DEFAULT)));
     quic_channel_.SetLocalCertificate(local_cert);
     local_fingerprint_.reset(CreateFingerprint(local_cert.get()));
@@ -148,7 +148,7 @@
     if (!get_digest_algorithm || digest_algorithm.empty()) {
       return nullptr;
     }
-    rtc::scoped_ptr<rtc::SSLFingerprint> fingerprint(
+    std::unique_ptr<rtc::SSLFingerprint> fingerprint(
         rtc::SSLFingerprint::Create(digest_algorithm, cert->identity()));
     if (digest_algorithm != rtc::DIGEST_SHA_256) {
       return nullptr;
@@ -198,7 +198,7 @@
 
   QuicTransportChannel* quic_channel() { return &quic_channel_; }
 
-  rtc::scoped_ptr<rtc::SSLFingerprint>& local_fingerprint() {
+  std::unique_ptr<rtc::SSLFingerprint>& local_fingerprint() {
     return local_fingerprint_;
   }
 
@@ -228,7 +228,7 @@
   size_t bytes_received_;                 // Bytes received by QUIC channel.
   FailableTransportChannel ice_channel_;  // Simulates an ICE channel.
   QuicTransportChannel quic_channel_;     // QUIC channel to test.
-  rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint_;
+  std::unique_ptr<rtc::SSLFingerprint> local_fingerprint_;
   ReliableQuicStream* incoming_quic_stream_ = nullptr;
   bool signal_closed_emitted_ = false;
 };
@@ -258,9 +258,9 @@
     peer1_.quic_channel()->SetSslRole(peer1_ssl_role);
     peer2_.quic_channel()->SetSslRole(peer2_ssl_role);
 
-    rtc::scoped_ptr<rtc::SSLFingerprint>& peer1_fingerprint =
+    std::unique_ptr<rtc::SSLFingerprint>& peer1_fingerprint =
         peer1_.local_fingerprint();
-    rtc::scoped_ptr<rtc::SSLFingerprint>& peer2_fingerprint =
+    std::unique_ptr<rtc::SSLFingerprint>& peer2_fingerprint =
         peer2_.local_fingerprint();
 
     peer1_.quic_channel()->SetRemoteFingerprint(
@@ -464,7 +464,7 @@
 // Set the SSL role, then test that GetSslRole returns the same value.
 TEST_F(QuicTransportChannelTest, SetGetSslRole) {
   ASSERT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
-  rtc::scoped_ptr<rtc::SSLRole> role(new rtc::SSLRole());
+  std::unique_ptr<rtc::SSLRole> role(new rtc::SSLRole());
   ASSERT_TRUE(peer1_.quic_channel()->GetSslRole(role.get()));
   EXPECT_EQ(rtc::SSL_SERVER, *role);
 }

webrtc/p2p/quic/reliablequicstream_unittest.cc

diff --git a/webrtc/p2p/quic/reliablequicstream_unittest.cc b/webrtc/p2p/quic/reliablequicstream_unittest.cc
index b887589..9f55c91 100644
--- a/webrtc/p2p/quic/reliablequicstream_unittest.cc
+++ b/webrtc/p2p/quic/reliablequicstream_unittest.cc
@@ -10,6 +10,7 @@
 
 #include "webrtc/p2p/quic/reliablequicstream.h"
 
+#include <memory>
 #include <string>
 
 #include "net/base/ip_address_number.h"
@@ -181,8 +182,8 @@
   }
 
  protected:
-  rtc::scoped_ptr<ReliableQuicStream> stream_;
-  rtc::scoped_ptr<MockQuicSession> session_;
+  std::unique_ptr<ReliableQuicStream> stream_;
+  std::unique_ptr<MockQuicSession> session_;
 
   // Data written by the ReliableQuicStream.
   std::string write_buffer_;

webrtc/p2p/stunprober/main.cc

diff --git a/webrtc/p2p/stunprober/main.cc b/webrtc/p2p/stunprober/main.cc
index 9ef91e0..9d0fff8 100644
--- a/webrtc/p2p/stunprober/main.cc
+++ b/webrtc/p2p/stunprober/main.cc
@@ -14,13 +14,14 @@
 
 #include <iostream>
 #include <map>
+#include <memory>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/flags.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
@@ -119,9 +120,9 @@
   rtc::InitializeSSL();
   rtc::InitRandom(rtc::Time32());
   rtc::Thread* thread = rtc::ThreadManager::Instance()->WrapCurrentThread();
-  rtc::scoped_ptr<rtc::BasicPacketSocketFactory> socket_factory(
+  std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory(
       new rtc::BasicPacketSocketFactory());
-  rtc::scoped_ptr<rtc::BasicNetworkManager> network_manager(
+  std::unique_ptr<rtc::BasicNetworkManager> network_manager(
       new rtc::BasicNetworkManager());
   rtc::NetworkManager::NetworkList networks;
   network_manager->GetNetworks(&networks);

webrtc/p2p/stunprober/stunprober.cc

diff --git a/webrtc/p2p/stunprober/stunprober.cc b/webrtc/p2p/stunprober/stunprober.cc
index a54a843..41ec6b4 100644
--- a/webrtc/p2p/stunprober/stunprober.cc
+++ b/webrtc/p2p/stunprober/stunprober.cc
@@ -9,6 +9,7 @@
  */
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 
@@ -90,11 +91,11 @@
   StunProber* prober_;
 
   // The socket for this session.
-  rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
+  std::unique_ptr<rtc::AsyncPacketSocket> socket_;
 
   // Temporary SocketAddress and buffer for RecvFrom.
   rtc::SocketAddress addr_;
-  rtc::scoped_ptr<rtc::ByteBufferWriter> response_packet_;
+  std::unique_ptr<rtc::ByteBufferWriter> response_packet_;
 
   std::vector<Request*> requests_;
   std::vector<rtc::SocketAddress> server_ips_;
@@ -141,7 +142,7 @@
       rtc::CreateRandomString(cricket::kStunTransactionIdLength));
   message.SetType(cricket::STUN_BINDING_REQUEST);
 
-  rtc::scoped_ptr<rtc::ByteBufferWriter> request_packet(
+  std::unique_ptr<rtc::ByteBufferWriter> request_packet(
       new rtc::ByteBufferWriter(nullptr, kMaxUdpBufferSize));
   if (!message.Write(request_packet.get())) {
     prober_->ReportOnFinished(WRITE_FAILED);
@@ -345,7 +346,7 @@
 
   // Prepare all the sockets beforehand. All of them will bind to "any" address.
   while (sockets_.size() < total_socket_required()) {
-    rtc::scoped_ptr<rtc::AsyncPacketSocket> socket(
+    std::unique_ptr<rtc::AsyncPacketSocket> socket(
         socket_factory_->CreateUdpSocket(rtc::SocketAddress(INADDR_ANY, 0), 0,
                                          0));
     if (!socket) {

webrtc/p2p/stunprober/stunprober_unittest.cc

diff --git a/webrtc/p2p/stunprober/stunprober_unittest.cc b/webrtc/p2p/stunprober/stunprober_unittest.cc
index cdcc14a..f5ee4bf 100644
--- a/webrtc/p2p/stunprober/stunprober_unittest.cc
+++ b/webrtc/p2p/stunprober/stunprober_unittest.cc
@@ -8,13 +8,14 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/asyncresolverinterface.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
@@ -83,7 +84,7 @@
     rtc::NetworkManager::NetworkList networks;
     networks.push_back(&ipv4_network1);
 
-    rtc::scoped_ptr<rtc::BasicPacketSocketFactory> socket_factory(
+    std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory(
         new rtc::BasicPacketSocketFactory());
 
     // Set up the expected results for verification.
@@ -119,14 +120,14 @@
   }
 
   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::scoped_ptr<StunProber> prober;
+  std::unique_ptr<StunProber> prober;
   int result_ = 0;
   bool stopped_ = false;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_1_;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_2_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_1_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_2_;
 };
 
 TEST_F(StunProberTest, NonSharedMode) {