diff --git a/api/dtlsidentitystore.cc b/api/dtlsidentitystore.cc
index a1a45b8..a1105ed 100644
--- a/api/dtlsidentitystore.cc
+++ b/api/dtlsidentitystore.cc
@@ -51,7 +51,7 @@
  private:
   void GenerateIdentity_w() {
     LOG(LS_INFO) << "Generating identity, using keytype " << key_type_;
-    rtc::scoped_ptr<rtc::SSLIdentity> identity(
+    std::unique_ptr<rtc::SSLIdentity> identity(
         rtc::SSLIdentity::Generate(kIdentityName, key_type_));
 
     // Posting to |this| avoids touching |store_| on threads other than
@@ -186,7 +186,8 @@
 }
 
 void DtlsIdentityStoreImpl::OnIdentityGenerated(
-    rtc::KeyType key_type, rtc::scoped_ptr<rtc::SSLIdentity> identity) {
+    rtc::KeyType key_type,
+    std::unique_ptr<rtc::SSLIdentity> identity) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   RTC_DCHECK(request_info_[key_type].gen_in_progress_counts_);
diff --git a/api/dtlsidentitystore.h b/api/dtlsidentitystore.h
index af42292..5ded1f1 100644
--- a/api/dtlsidentitystore.h
+++ b/api/dtlsidentitystore.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_API_DTLSIDENTITYSTORE_H_
 #define WEBRTC_API_DTLSIDENTITYSTORE_H_
 
+#include <memory>
 #include <queue>
 #include <string>
 #include <utility>
@@ -19,7 +20,6 @@
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/base/refcount.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/thread.h"
@@ -39,9 +39,9 @@
   // TODO(hbos): Unify the OnSuccess method once Chrome code is updated.
   virtual void OnSuccess(const std::string& der_cert,
                          const std::string& der_private_key) = 0;
-  // |identity| is a scoped_ptr because rtc::SSLIdentity is not copyable and the
+  // |identity| is a unique_ptr because rtc::SSLIdentity is not copyable and the
   // client has to get the ownership of the object to make use of it.
-  virtual void OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity> identity) = 0;
+  virtual void OnSuccess(std::unique_ptr<rtc::SSLIdentity> identity) = 0;
 
  protected:
   virtual ~DtlsIdentityRequestObserver() {}
@@ -106,7 +106,7 @@
       rtc::KeyType key_type,
       const rtc::scoped_refptr<DtlsIdentityRequestObserver>& observer);
   void OnIdentityGenerated(rtc::KeyType key_type,
-                           rtc::scoped_ptr<rtc::SSLIdentity> identity);
+                           std::unique_ptr<rtc::SSLIdentity> identity);
 
   class WorkerTask;
   typedef rtc::ScopedMessageData<DtlsIdentityStoreImpl::WorkerTask>
@@ -115,11 +115,11 @@
   // A key type-identity pair.
   struct IdentityResult {
     IdentityResult(rtc::KeyType key_type,
-                   rtc::scoped_ptr<rtc::SSLIdentity> identity)
+                   std::unique_ptr<rtc::SSLIdentity> identity)
         : key_type_(key_type), identity_(std::move(identity)) {}
 
     rtc::KeyType key_type_;
-    rtc::scoped_ptr<rtc::SSLIdentity> identity_;
+    std::unique_ptr<rtc::SSLIdentity> identity_;
   };
 
   typedef rtc::ScopedMessageData<IdentityResult> IdentityResultMessageData;
@@ -139,7 +139,7 @@
     std::queue<rtc::scoped_refptr<DtlsIdentityRequestObserver>>
         request_observers_;
     size_t gen_in_progress_counts_;
-    rtc::scoped_ptr<rtc::SSLIdentity> free_identity_;
+    std::unique_ptr<rtc::SSLIdentity> free_identity_;
   };
 
   // One RequestInfo per KeyType. Only touch on the |signaling_thread_|.
diff --git a/api/dtlsidentitystore_unittest.cc b/api/dtlsidentitystore_unittest.cc
index 65428f2..31f0113 100644
--- a/api/dtlsidentitystore_unittest.cc
+++ b/api/dtlsidentitystore_unittest.cc
@@ -10,6 +10,8 @@
 
 #include "webrtc/api/dtlsidentitystore.h"
 
+#include <memory>
+
 #include "webrtc/api/webrtcsessiondescriptionfactory.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
@@ -34,7 +36,7 @@
     LOG(LS_WARNING) << "The string version of OnSuccess is called unexpectedly";
     EXPECT_TRUE(false);
   }
-  void OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity> identity) override {
+  void OnSuccess(std::unique_ptr<rtc::SSLIdentity> identity) override {
     EXPECT_FALSE(call_back_called_);
     call_back_called_ = true;
     last_request_success_ = true;
@@ -77,8 +79,8 @@
     rtc::CleanupSSL();
   }
 
-  rtc::scoped_ptr<rtc::Thread> worker_thread_;
-  rtc::scoped_ptr<DtlsIdentityStoreImpl> store_;
+  std::unique_ptr<rtc::Thread> worker_thread_;
+  std::unique_ptr<DtlsIdentityStoreImpl> store_;
   rtc::scoped_refptr<MockDtlsIdentityRequestObserver> observer_;
 };
 
diff --git a/api/java/jni/peerconnection_jni.cc b/api/java/jni/peerconnection_jni.cc
index fdd2d44..1a31885 100644
--- a/api/java/jni/peerconnection_jni.cc
+++ b/api/java/jni/peerconnection_jni.cc
@@ -40,6 +40,7 @@
 #define JNIEXPORT __attribute__((visibility("default")))
 
 #include <limits>
+#include <memory>
 #include <utility>
 
 #include "webrtc/api/androidvideocapturer.h"
@@ -1565,7 +1566,7 @@
 
   // Create ECDSA certificate.
   if (JavaKeyTypeToNativeType(jni, j_key_type) == rtc::KT_ECDSA) {
-    scoped_ptr<rtc::SSLIdentity> ssl_identity(
+    std::unique_ptr<rtc::SSLIdentity> ssl_identity(
         rtc::SSLIdentity::Generate(webrtc::kIdentityName, rtc::KT_ECDSA));
     if (ssl_identity.get()) {
       rtc_config.certificates.push_back(
diff --git a/api/objc/RTCConfiguration.mm b/api/objc/RTCConfiguration.mm
index 2d44d01..29c447f 100644
--- a/api/objc/RTCConfiguration.mm
+++ b/api/objc/RTCConfiguration.mm
@@ -10,6 +10,8 @@
 
 #import "RTCConfiguration.h"
 
+#include <memory>
+
 #include "webrtc/base/sslidentity.h"
 
 #import "webrtc/api/objc/RTCConfiguration+Private.h"
@@ -86,7 +88,7 @@
   nativeConfig.ice_backup_candidate_pair_ping_interval =
       _iceBackupCandidatePairPingInterval;
   if (_keyType == RTCEncryptionKeyTypeECDSA) {
-    rtc::scoped_ptr<rtc::SSLIdentity> identity(
+    std::unique_ptr<rtc::SSLIdentity> identity(
         rtc::SSLIdentity::Generate(webrtc::kIdentityName, rtc::KT_ECDSA));
     if (identity) {
       nativeConfig.certificates.push_back(
diff --git a/api/statscollector.cc b/api/statscollector.cc
index 38fb5fb..82c97cc 100644
--- a/api/statscollector.cc
+++ b/api/statscollector.cc
@@ -10,18 +10,16 @@
 
 #include "webrtc/api/statscollector.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/checks.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/timing.h"
 #include "webrtc/pc/channel.h"
 
-using rtc::scoped_ptr;
-
 namespace webrtc {
 namespace {
 
@@ -532,7 +530,7 @@
   if (!cert->GetSignatureDigestAlgorithm(&digest_algorithm))
     return nullptr;
 
-  rtc::scoped_ptr<rtc::SSLFingerprint> ssl_fingerprint(
+  std::unique_ptr<rtc::SSLFingerprint> ssl_fingerprint(
       rtc::SSLFingerprint::Create(digest_algorithm, cert));
 
   // SSLFingerprint::Create can fail if the algorithm returned by
@@ -574,7 +572,7 @@
   RTC_DCHECK(cert != NULL);
 
   StatsReport* issuer = nullptr;
-  rtc::scoped_ptr<rtc::SSLCertChain> chain = cert->GetChain();
+  std::unique_ptr<rtc::SSLCertChain> chain = cert->GetChain();
   if (chain) {
     // This loop runs in reverse, i.e. from root to leaf, so that each
     // certificate's issuer's report ID is known before the child certificate's
@@ -702,7 +700,7 @@
         local_cert_report_id = r->id();
     }
 
-    rtc::scoped_ptr<rtc::SSLCertificate> cert =
+    std::unique_ptr<rtc::SSLCertificate> cert =
         pc_->session()->GetRemoteSSLCertificate(
             transport_iter.second.transport_name);
     if (cert) {
diff --git a/api/statscollector_unittest.cc b/api/statscollector_unittest.cc
index 5873e73..8effb92 100644
--- a/api/statscollector_unittest.cc
+++ b/api/statscollector_unittest.cc
@@ -11,6 +11,7 @@
 #include <stdio.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/api/statscollector.h"
 
@@ -84,9 +85,9 @@
                     rtc::scoped_refptr<rtc::RTCCertificate>* certificate));
 
   // Workaround for gmock's inability to cope with move-only return values.
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
       const std::string& transport_name) override {
-    return rtc::scoped_ptr<rtc::SSLCertificate>(
+    return std::unique_ptr<rtc::SSLCertificate>(
         GetRemoteSSLCertificate_ReturnsRawPointer(transport_name));
   }
   MOCK_METHOD1(GetRemoteSSLCertificate_ReturnsRawPointer,
@@ -694,7 +695,7 @@
 
     // Fake certificate to report
     rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
-        rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::FakeSSLIdentity>(
+        rtc::RTCCertificate::Create(std::unique_ptr<rtc::FakeSSLIdentity>(
             new rtc::FakeSSLIdentity(local_cert))));
 
     // Configure MockWebRtcSession
diff --git a/api/test/fakedtlsidentitystore.h b/api/test/fakedtlsidentitystore.h
index 8bbffbf..89c4084 100644
--- a/api/test/fakedtlsidentitystore.h
+++ b/api/test/fakedtlsidentitystore.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_API_TEST_FAKEDTLSIDENTITYSERVICE_H_
 #define WEBRTC_API_TEST_FAKEDTLSIDENTITYSERVICE_H_
 
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -127,7 +128,7 @@
         rtc::kPemTypeRsaPrivateKey,
         reinterpret_cast<const unsigned char*>(key.data()),
         key.length());
-    rtc::scoped_ptr<rtc::SSLIdentity> identity(
+    std::unique_ptr<rtc::SSLIdentity> identity(
         rtc::SSLIdentity::FromPEMStrings(pem_key, pem_cert));
 
     return rtc::RTCCertificate::Create(std::move(identity));
diff --git a/api/webrtcsession.cc b/api/webrtcsession.cc
index f51d4cd..28d2f63 100644
--- a/api/webrtcsession.cc
+++ b/api/webrtcsession.cc
@@ -1039,7 +1039,7 @@
                                                     certificate);
 }
 
-rtc::scoped_ptr<rtc::SSLCertificate> WebRtcSession::GetRemoteSSLCertificate(
+std::unique_ptr<rtc::SSLCertificate> WebRtcSession::GetRemoteSSLCertificate(
     const std::string& transport_name) {
   ASSERT(signaling_thread()->IsCurrent());
   return transport_controller_->GetRemoteSSLCertificate(transport_name);
diff --git a/api/webrtcsession.h b/api/webrtcsession.h
index 752b20f..1444345 100644
--- a/api/webrtcsession.h
+++ b/api/webrtcsession.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_API_WEBRTCSESSION_H_
 #define WEBRTC_API_WEBRTCSESSION_H_
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -293,7 +294,7 @@
       rtc::scoped_refptr<rtc::RTCCertificate>* certificate);
 
   // Caller owns returned certificate
-  virtual rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
+  virtual std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
       const std::string& transport_name);
 
   cricket::DataChannelType data_channel_type() const;
diff --git a/api/webrtcsession_unittest.cc b/api/webrtcsession_unittest.cc
index feb1518..4cb6cc4 100644
--- a/api/webrtcsession_unittest.cc
+++ b/api/webrtcsession_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -692,7 +693,7 @@
         rtc::ToString(rtc::CreateRandomId());
     // Confirmed to work with KT_RSA and KT_ECDSA.
     tdesc_factory_->set_certificate(
-        rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+        rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(identity_name, rtc::KT_DEFAULT))));
     tdesc_factory_->set_secure(cricket::SEC_REQUIRED);
   }
diff --git a/api/webrtcsessiondescriptionfactory.cc b/api/webrtcsessiondescriptionfactory.cc
index 78840e2..584125f 100644
--- a/api/webrtcsessiondescriptionfactory.cc
+++ b/api/webrtcsessiondescriptionfactory.cc
@@ -82,13 +82,13 @@
       rtc::kPemTypeRsaPrivateKey,
       reinterpret_cast<const unsigned char*>(der_private_key.data()),
       der_private_key.length());
-  rtc::scoped_ptr<rtc::SSLIdentity> identity(
+  std::unique_ptr<rtc::SSLIdentity> identity(
       rtc::SSLIdentity::FromPEMStrings(pem_key, pem_cert));
   SignalCertificateReady(rtc::RTCCertificate::Create(std::move(identity)));
 }
 
 void WebRtcIdentityRequestObserver::OnSuccess(
-    rtc::scoped_ptr<rtc::SSLIdentity> identity) {
+    std::unique_ptr<rtc::SSLIdentity> identity) {
   SignalCertificateReady(rtc::RTCCertificate::Create(std::move(identity)));
 }
 
diff --git a/api/webrtcsessiondescriptionfactory.h b/api/webrtcsessiondescriptionfactory.h
index 71d083b..68d696a 100644
--- a/api/webrtcsessiondescriptionfactory.h
+++ b/api/webrtcsessiondescriptionfactory.h
@@ -11,6 +11,8 @@
 #ifndef WEBRTC_API_WEBRTCSESSIONDESCRIPTIONFACTORY_H_
 #define WEBRTC_API_WEBRTCSESSIONDESCRIPTIONFACTORY_H_
 
+#include <memory>
+
 #include "webrtc/api/dtlsidentitystore.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/base/messagehandler.h"
@@ -37,7 +39,7 @@
   void OnFailure(int error) override;
   void OnSuccess(const std::string& der_cert,
                  const std::string& der_private_key) override;
-  void OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity> identity) override;
+  void OnSuccess(std::unique_ptr<rtc::SSLIdentity> identity) override;
 
   sigslot::signal1<int> SignalRequestFailed;
   sigslot::signal1<const rtc::scoped_refptr<rtc::RTCCertificate>&>
diff --git a/base/asynctcpsocket.cc b/base/asynctcpsocket.cc
index 65ec0f2..120bcfb 100644
--- a/base/asynctcpsocket.cc
+++ b/base/asynctcpsocket.cc
@@ -13,6 +13,7 @@
 #include <string.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
@@ -44,7 +45,7 @@
     rtc::AsyncSocket* socket,
     const rtc::SocketAddress& bind_address,
     const rtc::SocketAddress& remote_address) {
-  rtc::scoped_ptr<rtc::AsyncSocket> owned_socket(socket);
+  std::unique_ptr<rtc::AsyncSocket> owned_socket(socket);
   if (socket->Bind(bind_address) < 0) {
     LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
     return NULL;
diff --git a/base/asynctcpsocket.h b/base/asynctcpsocket.h
index ea31493..af0410f 100644
--- a/base/asynctcpsocket.h
+++ b/base/asynctcpsocket.h
@@ -11,9 +11,10 @@
 #ifndef WEBRTC_BASE_ASYNCTCPSOCKET_H_
 #define WEBRTC_BASE_ASYNCTCPSOCKET_H_
 
+#include <memory>
+
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/buffer.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketfactory.h"
 
 namespace rtc {
@@ -70,7 +71,7 @@
   void OnWriteEvent(AsyncSocket* socket);
   void OnCloseEvent(AsyncSocket* socket, int error);
 
-  scoped_ptr<AsyncSocket> socket_;
+  std::unique_ptr<AsyncSocket> socket_;
   bool listen_;
   Buffer inbuf_;
   Buffer outbuf_;
diff --git a/base/asynctcpsocket_unittest.cc b/base/asynctcpsocket_unittest.cc
index b931758..592b61d 100644
--- a/base/asynctcpsocket_unittest.cc
+++ b/base/asynctcpsocket_unittest.cc
@@ -8,12 +8,12 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 
 #include "webrtc/base/asynctcpsocket.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 namespace rtc {
@@ -37,10 +37,10 @@
   }
 
  protected:
-  scoped_ptr<PhysicalSocketServer> pss_;
-  scoped_ptr<VirtualSocketServer> vss_;
+  std::unique_ptr<PhysicalSocketServer> pss_;
+  std::unique_ptr<VirtualSocketServer> vss_;
   AsyncSocket* socket_;
-  scoped_ptr<AsyncTCPSocket> tcp_socket_;
+  std::unique_ptr<AsyncTCPSocket> tcp_socket_;
   bool ready_to_send_;
 };
 
diff --git a/base/asyncudpsocket.cc b/base/asyncudpsocket.cc
index 4e80733..7eb2a0e 100644
--- a/base/asyncudpsocket.cc
+++ b/base/asyncudpsocket.cc
@@ -18,7 +18,7 @@
 AsyncUDPSocket* AsyncUDPSocket::Create(
     AsyncSocket* socket,
     const SocketAddress& bind_address) {
-  scoped_ptr<AsyncSocket> owned_socket(socket);
+  std::unique_ptr<AsyncSocket> owned_socket(socket);
   if (socket->Bind(bind_address) < 0) {
     LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
     return NULL;
diff --git a/base/asyncudpsocket.h b/base/asyncudpsocket.h
index 4b47007..aa6a904 100644
--- a/base/asyncudpsocket.h
+++ b/base/asyncudpsocket.h
@@ -11,8 +11,9 @@
 #ifndef WEBRTC_BASE_ASYNCUDPSOCKET_H_
 #define WEBRTC_BASE_ASYNCUDPSOCKET_H_
 
+#include <memory>
+
 #include "webrtc/base/asyncpacketsocket.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketfactory.h"
 
 namespace rtc {
@@ -56,7 +57,7 @@
   // Called when the underlying socket is ready to send.
   void OnWriteEvent(AsyncSocket* socket);
 
-  scoped_ptr<AsyncSocket> socket_;
+  std::unique_ptr<AsyncSocket> socket_;
   char* buf_;
   size_t size_;
 };
diff --git a/base/asyncudpsocket_unittest.cc b/base/asyncudpsocket_unittest.cc
index bd65940..9922005 100644
--- a/base/asyncudpsocket_unittest.cc
+++ b/base/asyncudpsocket_unittest.cc
@@ -8,12 +8,12 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 
 #include "webrtc/base/asyncudpsocket.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 namespace rtc {
@@ -37,10 +37,10 @@
   }
 
  protected:
-  scoped_ptr<PhysicalSocketServer> pss_;
-  scoped_ptr<VirtualSocketServer> vss_;
+  std::unique_ptr<PhysicalSocketServer> pss_;
+  std::unique_ptr<VirtualSocketServer> vss_;
   AsyncSocket* socket_;
-  scoped_ptr<AsyncUDPSocket> udp_socket_;
+  std::unique_ptr<AsyncUDPSocket> udp_socket_;
   bool ready_to_send_;
 };
 
diff --git a/base/criticalsection_unittest.cc b/base/criticalsection_unittest.cc
index a0e1033..d33afac 100644
--- a/base/criticalsection_unittest.cc
+++ b/base/criticalsection_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <set>
 #include <vector>
 
@@ -17,7 +18,6 @@
 #include "webrtc/base/event.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/platform_thread.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scopedptrcollection.h"
 #include "webrtc/base/thread.h"
 
@@ -226,8 +226,8 @@
 TEST(AtomicOpsTest, SimplePtr) {
   class Foo {};
   Foo* volatile foo = nullptr;
-  scoped_ptr<Foo> a(new Foo());
-  scoped_ptr<Foo> b(new Foo());
+  std::unique_ptr<Foo> a(new Foo());
+  std::unique_ptr<Foo> b(new Foo());
   // Reading the initial value should work as expected.
   EXPECT_TRUE(rtc::AtomicOps::AcquireLoadPtr(&foo) == nullptr);
   // Setting using compare and swap should work.
diff --git a/base/cryptstring.h b/base/cryptstring.h
index a6bae51..adaac2f 100644
--- a/base/cryptstring.h
+++ b/base/cryptstring.h
@@ -13,11 +13,11 @@
 
 #include <string.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/linked_ptr.h"
-#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
@@ -42,8 +42,8 @@
 };
 
 class CryptString {
-public:
- CryptString();
+ public:
+  CryptString();
   size_t GetLength() const { return impl_->GetLength(); }
   void CopyTo(char * dest, bool nullterminate) const { impl_->CopyTo(dest, nullterminate); }
   CryptString(const CryptString& other);
@@ -60,9 +60,9 @@
   void CopyRawTo(std::vector<unsigned char> * dest) const {
     return impl_->CopyRawTo(dest);
   }
-  
-private:
-  scoped_ptr<const CryptStringImpl> impl_;
+
+ private:
+  std::unique_ptr<const CryptStringImpl> impl_;
 };
 
 
diff --git a/base/dbus_unittest.cc b/base/dbus_unittest.cc
index 17752f1..38c507d 100644
--- a/base/dbus_unittest.cc
+++ b/base/dbus_unittest.cc
@@ -10,6 +10,8 @@
 
 #ifdef HAVE_DBUS_GLIB
 
+#include <memory>
+
 #include "webrtc/base/dbus.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/thread.h"
@@ -51,7 +53,7 @@
 
 TEST(DBusMonitorTest, StartStopStartStop) {
   DBusSigFilterTest filter;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor;
+  std::unique_ptr<rtc::DBusMonitor> monitor;
   monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor) {
     EXPECT_TRUE(monitor->AddFilter(&filter));
@@ -83,7 +85,7 @@
 // This test is to make sure that we capture the "NameAcquired" signal.
 TEST(DBusMonitorTest, ReceivedNameAcquiredSignal) {
   DBusSigFilterTest filter;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor;
+  std::unique_ptr<rtc::DBusMonitor> monitor;
   monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor) {
     EXPECT_TRUE(monitor->AddFilter(&filter));
@@ -100,12 +102,12 @@
 
 TEST(DBusMonitorTest, ConcurrentMonitors) {
   DBusSigFilterTest filter1;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor1;
+  std::unique_ptr<rtc::DBusMonitor> monitor1;
   monitor1.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor1) {
     EXPECT_TRUE(monitor1->AddFilter(&filter1));
     DBusSigFilterTest filter2;
-    rtc::scoped_ptr<rtc::DBusMonitor> monitor2;
+    std::unique_ptr<rtc::DBusMonitor> monitor2;
     monitor2.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
     EXPECT_TRUE(monitor2->AddFilter(&filter2));
 
@@ -129,7 +131,7 @@
 TEST(DBusMonitorTest, ConcurrentFilters) {
   DBusSigFilterTest filter1;
   DBusSigFilterTest filter2;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor;
+  std::unique_ptr<rtc::DBusMonitor> monitor;
   monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor) {
     EXPECT_TRUE(monitor->AddFilter(&filter1));
@@ -151,7 +153,7 @@
 TEST(DBusMonitorTest, NoAddFilterIfRunning) {
   DBusSigFilterTest filter1;
   DBusSigFilterTest filter2;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor;
+  std::unique_ptr<rtc::DBusMonitor> monitor;
   monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor) {
     EXPECT_TRUE(monitor->AddFilter(&filter1));
@@ -170,7 +172,7 @@
 TEST(DBusMonitorTest, AddFilterAfterStop) {
   DBusSigFilterTest filter1;
   DBusSigFilterTest filter2;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor;
+  std::unique_ptr<rtc::DBusMonitor> monitor;
   monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor) {
     EXPECT_TRUE(monitor->AddFilter(&filter1));
@@ -194,7 +196,7 @@
 
 TEST(DBusMonitorTest, StopRightAfterStart) {
   DBusSigFilterTest filter;
-  rtc::scoped_ptr<rtc::DBusMonitor> monitor;
+  std::unique_ptr<rtc::DBusMonitor> monitor;
   monitor.reset(rtc::DBusMonitor::Create(DBUS_BUS_SYSTEM));
   if (monitor) {
     EXPECT_TRUE(monitor->AddFilter(&filter));
diff --git a/base/diskcache.cc b/base/diskcache.cc
index a1fba6a..233d2ab 100644
--- a/base/diskcache.cc
+++ b/base/diskcache.cc
@@ -15,6 +15,8 @@
 #endif
 
 #include <algorithm>
+#include <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/diskcache.h"
@@ -123,7 +125,7 @@
     previous_size = entry->size;
   }
 
-  scoped_ptr<FileStream> file(new FileStream);
+  std::unique_ptr<FileStream> file(new FileStream);
   if (!file->Open(filename, "wb", NULL)) {
     LOG_F(LS_ERROR) << "Couldn't create cache file";
     return NULL;
@@ -161,7 +163,7 @@
   if (index >= entry->streams)
     return NULL;
 
-  scoped_ptr<FileStream> file(new FileStream);
+  std::unique_ptr<FileStream> file(new FileStream);
   if (!file->Open(IdToFilename(id, index), "rb", NULL))
     return NULL;
 
diff --git a/base/fakenetwork.h b/base/fakenetwork.h
index e3996e6..2dd2137 100644
--- a/base/fakenetwork.h
+++ b/base/fakenetwork.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_BASE_FAKENETWORK_H_
 #define WEBRTC_BASE_FAKENETWORK_H_
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -99,9 +100,9 @@
         prefix_length = kFakeIPv6NetworkPrefixLength;
       }
       IPAddress prefix = TruncateIP(it->first.ipaddr(), prefix_length);
-      scoped_ptr<Network> net(new Network(it->first.hostname(),
-                                          it->first.hostname(), prefix,
-                                          prefix_length, it->second));
+      std::unique_ptr<Network> net(new Network(it->first.hostname(),
+                                               it->first.hostname(), prefix,
+                                               prefix_length, it->second));
       net->set_default_local_address_provider(this);
       net->AddIP(it->first.ipaddr());
       networks.push_back(net.release());
diff --git a/base/fakesslidentity.h b/base/fakesslidentity.h
index 47ff86d..6640b02 100644
--- a/base/fakesslidentity.h
+++ b/base/fakesslidentity.h
@@ -12,6 +12,7 @@
 #define WEBRTC_BASE_FAKESSLIDENTITY_H_
 
 #include <algorithm>
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/common.h"
@@ -68,12 +69,12 @@
                                        digest, size);
     return (*length != 0);
   }
-  virtual rtc::scoped_ptr<SSLCertChain> GetChain() const {
+  virtual std::unique_ptr<SSLCertChain> GetChain() const {
     if (certs_.empty())
       return nullptr;
     std::vector<SSLCertificate*> new_certs(certs_.size());
     std::transform(certs_.begin(), certs_.end(), new_certs.begin(), DupCert);
-    rtc::scoped_ptr<SSLCertChain> chain(new SSLCertChain(new_certs));
+    std::unique_ptr<SSLCertChain> chain(new SSLCertChain(new_certs));
     std::for_each(new_certs.begin(), new_certs.end(), DeleteCert);
     return chain;
   }
diff --git a/base/filerotatingstream.h b/base/filerotatingstream.h
index 9e8e35d..a8522ff 100644
--- a/base/filerotatingstream.h
+++ b/base/filerotatingstream.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_BASE_FILEROTATINGSTREAM_H_
 #define WEBRTC_BASE_FILEROTATINGSTREAM_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -110,7 +111,7 @@
   const Mode mode_;
 
   // FileStream is used to write to the current file.
-  scoped_ptr<FileStream> file_stream_;
+  std::unique_ptr<FileStream> file_stream_;
   // Convenience storage for file names so we don't generate them over and over.
   std::vector<std::string> file_names_;
   size_t max_file_size_;
diff --git a/base/filerotatingstream_unittest.cc b/base/filerotatingstream_unittest.cc
index 09438f8..bac2a3a 100644
--- a/base/filerotatingstream_unittest.cc
+++ b/base/filerotatingstream_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/filerotatingstream.h"
@@ -57,13 +59,13 @@
                         const size_t expected_length,
                         const std::string& dir_path,
                         const char* file_prefix) {
-    scoped_ptr<FileRotatingStream> stream;
+    std::unique_ptr<FileRotatingStream> stream;
     stream.reset(new FileRotatingStream(dir_path, file_prefix));
     ASSERT_TRUE(stream->Open());
     size_t read = 0;
     size_t stream_size = 0;
     EXPECT_TRUE(stream->GetSize(&stream_size));
-    scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
+    std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     EXPECT_EQ(SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
@@ -74,8 +76,8 @@
   void VerifyFileContents(const char* expected_contents,
                           const size_t expected_length,
                           const std::string& file_path) {
-    scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
-    scoped_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
+    std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
+    std::unique_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
     EXPECT_TRUE(stream);
     if (!stream) {
       return;
@@ -88,7 +90,7 @@
     EXPECT_EQ(file_size, expected_length);
   }
 
-  scoped_ptr<FileRotatingStream> stream_;
+  std::unique_ptr<FileRotatingStream> stream_;
   std::string dir_path_;
 };
 
@@ -114,7 +116,7 @@
   WriteAndFlush("a", 0);
 
   std::string logfile_path = stream_->GetFilePath(0);
-  scoped_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
+  std::unique_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
   size_t file_size = 0;
   EXPECT_TRUE(stream->GetSize(&file_size));
   EXPECT_EQ(0u, file_size);
@@ -215,13 +217,13 @@
   void VerifyStreamRead(const char* expected_contents,
                         const size_t expected_length,
                         const std::string& dir_path) {
-    scoped_ptr<CallSessionFileRotatingStream> stream(
+    std::unique_ptr<CallSessionFileRotatingStream> stream(
         new CallSessionFileRotatingStream(dir_path));
     ASSERT_TRUE(stream->Open());
     size_t read = 0;
     size_t stream_size = 0;
     EXPECT_TRUE(stream->GetSize(&stream_size));
-    scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
+    std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     EXPECT_EQ(SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
@@ -229,7 +231,7 @@
     EXPECT_EQ(stream_size, read);
   }
 
-  scoped_ptr<CallSessionFileRotatingStream> stream_;
+  std::unique_ptr<CallSessionFileRotatingStream> stream_;
   std::string dir_path_;
 };
 
@@ -266,7 +268,7 @@
 
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 8; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
@@ -275,7 +277,7 @@
 
   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
-  scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1, 2, 6, 7};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
@@ -293,7 +295,7 @@
        6 * 1024 * 1024);
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 2; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
@@ -302,7 +304,7 @@
 
   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
-  scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
diff --git a/base/fileutils.h b/base/fileutils.h
index bf02571..a59e97e 100644
--- a/base/fileutils.h
+++ b/base/fileutils.h
@@ -24,7 +24,6 @@
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/platform_file.h"
-#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
diff --git a/base/fileutils_unittest.cc b/base/fileutils_unittest.cc
index 6e98e14..51396ca 100644
--- a/base/fileutils_unittest.cc
+++ b/base/fileutils_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/pathutils.h"
@@ -74,7 +76,7 @@
   EXPECT_FALSE(Filesystem::CreatePrivateFile(path));
 
   // Verify that we have permission to open the file for reading and writing.
-  scoped_ptr<FileStream> fs(Filesystem::OpenFile(path, "wb"));
+  std::unique_ptr<FileStream> fs(Filesystem::OpenFile(path, "wb"));
   EXPECT_TRUE(fs.get() != NULL);
   // Have to close the file on Windows before it will let us delete it.
   fs.reset();
diff --git a/base/helpers.cc b/base/helpers.cc
index 1ad5d0e..0a39ee9 100644
--- a/base/helpers.cc
+++ b/base/helpers.cc
@@ -11,6 +11,7 @@
 #include "webrtc/base/helpers.h"
 
 #include <limits>
+#include <memory>
 
 #if defined(FEATURE_ENABLE_SSL)
 #include "webrtc/base/sslconfig.h"
@@ -28,7 +29,6 @@
 #include "webrtc/base/base64.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/timeutils.h"
 
 // Protect against max macro inclusion.
@@ -181,8 +181,8 @@
 
 // This round about way of creating a global RNG is to safe-guard against
 // indeterminant static initialization order.
-scoped_ptr<RandomGenerator>& GetGlobalRng() {
-  RTC_DEFINE_STATIC_LOCAL(scoped_ptr<RandomGenerator>, global_rng,
+std::unique_ptr<RandomGenerator>& GetGlobalRng() {
+  RTC_DEFINE_STATIC_LOCAL(std::unique_ptr<RandomGenerator>, global_rng,
                           (new SecureRandomGenerator()));
   return global_rng;
 }
@@ -223,7 +223,7 @@
                         const char* table, int table_size,
                         std::string* str) {
   str->clear();
-  scoped_ptr<uint8_t[]> bytes(new uint8_t[len]);
+  std::unique_ptr<uint8_t[]> bytes(new uint8_t[len]);
   if (!Rng().Generate(bytes.get(), len)) {
     LOG(LS_ERROR) << "Failed to generate random string!";
     return false;
@@ -250,7 +250,7 @@
 // Where 'x' is a hex digit, and 'y' is 8, 9, a or b.
 std::string CreateRandomUuid() {
   std::string str;
-  scoped_ptr<uint8_t[]> bytes(new uint8_t[31]);
+  std::unique_ptr<uint8_t[]> bytes(new uint8_t[31]);
   if (!Rng().Generate(bytes.get(), 31)) {
     LOG(LS_ERROR) << "Failed to generate random string!";
     return str;
diff --git a/base/httpbase.cc b/base/httpbase.cc
index 81ca4cc..efdc8af 100644
--- a/base/httpbase.cc
+++ b/base/httpbase.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
@@ -271,9 +272,8 @@
     // When the method returns, we restore the old document.  Ideally, we would
     // pass our StreamInterface* to DoReceiveLoop, but due to the callbacks
     // of HttpParser, we would still need to store the pointer temporarily.
-    scoped_ptr<StreamInterface>
-        stream(new BlockingMemoryStream(reinterpret_cast<char*>(buffer),
-                                        buffer_len));
+    std::unique_ptr<StreamInterface> stream(
+        new BlockingMemoryStream(reinterpret_cast<char*>(buffer), buffer_len));
 
     // Replace the existing document with our wrapped buffer.
     base_->data_->document.swap(stream);
diff --git a/base/httpclient.cc b/base/httpclient.cc
index e078334..a458590 100644
--- a/base/httpclient.cc
+++ b/base/httpclient.cc
@@ -10,6 +10,7 @@
 
 #include <time.h>
 #include <algorithm>
+#include <memory>
 #include "webrtc/base/asyncsocket.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/diskcache.h"
@@ -17,7 +18,6 @@
 #include "webrtc/base/httpcommon-inl.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/pathutils.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketstream.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
@@ -466,7 +466,8 @@
     return false;
   }
 
-  scoped_ptr<StreamInterface> stream(cache_->WriteResource(id, kCacheBody));
+  std::unique_ptr<StreamInterface> stream(
+      cache_->WriteResource(id, kCacheBody));
   if (!stream) {
     LOG_F(LS_ERROR) << "Couldn't open body cache";
     return false;
@@ -485,7 +486,8 @@
 }
 
 HttpError HttpClient::WriteCacheHeaders(const std::string& id) {
-  scoped_ptr<StreamInterface> stream(cache_->WriteResource(id, kCacheHeader));
+  std::unique_ptr<StreamInterface> stream(
+      cache_->WriteResource(id, kCacheHeader));
   if (!stream) {
     LOG_F(LS_ERROR) << "Couldn't open header cache";
     return HE_CACHE;
@@ -563,7 +565,8 @@
 }
 
 HttpError HttpClient::ReadCacheHeaders(const std::string& id, bool override) {
-  scoped_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheHeader));
+  std::unique_ptr<StreamInterface> stream(
+      cache_->ReadResource(id, kCacheHeader));
   if (!stream) {
     return HE_CACHE;
   }
@@ -586,7 +589,7 @@
   HttpError error = HE_NONE;
 
   size_t data_size;
-  scoped_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheBody));
+  std::unique_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheBody));
   if (!stream || !stream->GetAvailable(&data_size)) {
     LOG_F(LS_ERROR) << "Unavailable cache body";
     error = HE_CACHE;
@@ -599,7 +602,7 @@
       && response().document) {
     // Allocate on heap to not explode the stack.
     const int array_size = 1024 * 64;
-    scoped_ptr<char[]> buffer(new char[array_size]);
+    std::unique_ptr<char[]> buffer(new char[array_size]);
     StreamResult result = Flow(stream.get(), buffer.get(), array_size,
                                response().document.get());
     if (SR_SUCCESS != result) {
diff --git a/base/httpclient.h b/base/httpclient.h
index e7d2c5c..0c19d2e 100644
--- a/base/httpclient.h
+++ b/base/httpclient.h
@@ -11,11 +11,12 @@
 #ifndef WEBRTC_BASE_HTTPCLIENT_H__
 #define WEBRTC_BASE_HTTPCLIENT_H__
 
+#include <memory>
+
 #include "webrtc/base/common.h"
 #include "webrtc/base/httpbase.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/proxyinfo.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/socketpool.h"
@@ -172,7 +173,7 @@
   size_t retries_, attempt_, redirects_;
   RedirectAction redirect_action_;
   UriForm uri_form_;
-  scoped_ptr<HttpAuthContext> context_;
+  std::unique_ptr<HttpAuthContext> context_;
   DiskCache* cache_;
   CacheState cache_state_;
   AsyncResolverInterface* resolver_;
diff --git a/base/httpcommon.h b/base/httpcommon.h
index addc1bc..3450b58 100644
--- a/base/httpcommon.h
+++ b/base/httpcommon.h
@@ -12,11 +12,11 @@
 #define WEBRTC_BASE_HTTPCOMMON_H__
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/common.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/stream.h"
 
@@ -292,7 +292,7 @@
   typedef HeaderMap::iterator iterator;
 
   HttpVersion version;
-  scoped_ptr<StreamInterface> document;
+  std::unique_ptr<StreamInterface> document;
 
   HttpData();
 
diff --git a/base/httpserver.h b/base/httpserver.h
index 30c8f4c..c322e81 100644
--- a/base/httpserver.h
+++ b/base/httpserver.h
@@ -12,6 +12,8 @@
 #define WEBRTC_BASE_HTTPSERVER_H__
 
 #include <map>
+#include <memory>
+
 #include "webrtc/base/httpbase.h"
 
 namespace rtc {
@@ -127,7 +129,7 @@
   void OnConnectionClosed(HttpServer* server, int connection_id,
                           StreamInterface* stream);
 
-  scoped_ptr<AsyncSocket> listener_;
+  std::unique_ptr<AsyncSocket> listener_;
 };
 
 //////////////////////////////////////////////////////////////////////
diff --git a/base/linux.h b/base/linux.h
index ba73b85..b69de3b 100644
--- a/base/linux.h
+++ b/base/linux.h
@@ -14,9 +14,9 @@
 #if defined(WEBRTC_LINUX)
 #include <string>
 #include <map>
+#include <memory>
 #include <vector>
 
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stream.h"
 
 namespace rtc {
@@ -51,7 +51,7 @@
   virtual bool ParseLine(std::string* key, std::string* value);
 
  private:
-  scoped_ptr<StreamInterface> instream_;
+  std::unique_ptr<StreamInterface> instream_;
 };
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/base/logging.cc b/base/logging.cc
index 8f7d33c..6265668 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -42,7 +42,6 @@
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/platform_thread.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
diff --git a/base/logsinks.h b/base/logsinks.h
index eabf056..e75120e 100644
--- a/base/logsinks.h
+++ b/base/logsinks.h
@@ -11,12 +11,12 @@
 #ifndef WEBRTC_BASE_FILE_ROTATING_LOG_SINK_H_
 #define WEBRTC_BASE_FILE_ROTATING_LOG_SINK_H_
 
+#include <memory>
 #include <string>
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/filerotatingstream.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
@@ -46,7 +46,7 @@
   explicit FileRotatingLogSink(FileRotatingStream* stream);
 
  private:
-  scoped_ptr<FileRotatingStream> stream_;
+  std::unique_ptr<FileRotatingStream> stream_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(FileRotatingLogSink);
 };
diff --git a/base/maccocoasocketserver_unittest.mm b/base/maccocoasocketserver_unittest.mm
index 5401ffb..3d9e4da 100644
--- a/base/maccocoasocketserver_unittest.mm
+++ b/base/maccocoasocketserver_unittest.mm
@@ -9,7 +9,6 @@
  */
 
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/maccocoasocketserver.h"
 
diff --git a/base/macifaddrs_converter.cc b/base/macifaddrs_converter.cc
index 0916cb5..2ad070e 100644
--- a/base/macifaddrs_converter.cc
+++ b/base/macifaddrs_converter.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
@@ -15,7 +17,6 @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/ifaddrs_converter.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 
 #if !defined(WEBRTC_IOS)
 #include <net/if_media.h>
@@ -269,7 +270,7 @@
   }
 
  private:
-  rtc::scoped_ptr<IPv6AttributesGetter> ip_attribute_getter_;
+  std::unique_ptr<IPv6AttributesGetter> ip_attribute_getter_;
 };
 
 }  // namespace
diff --git a/base/macsocketserver_unittest.cc b/base/macsocketserver_unittest.cc
index ecb9a70..87cfe07 100644
--- a/base/macsocketserver_unittest.cc
+++ b/base/macsocketserver_unittest.cc
@@ -8,8 +8,9 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket_unittest.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/macsocketserver.h"
@@ -98,7 +99,7 @@
   virtual MacBaseSocketServer* CreateSocketServer() {
     return new MacCFSocketServer();
   };
-  rtc::scoped_ptr<MacBaseSocketServer> server_;
+  std::unique_ptr<MacBaseSocketServer> server_;
   SocketServerScope scope_;
 };
 
diff --git a/base/macutils.cc b/base/macutils.cc
index 7b1ff47..74b4919 100644
--- a/base/macutils.cc
+++ b/base/macutils.cc
@@ -8,12 +8,12 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <sstream>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/macutils.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringutils.h"
 
 namespace rtc {
@@ -26,7 +26,7 @@
   }
   size_t maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str16),
                                                     kCFStringEncodingUTF8) + 1;
-  scoped_ptr<char[]> buffer(new char[maxlen]);
+  std::unique_ptr<char[]> buffer(new char[maxlen]);
   if (!buffer || !CFStringGetCString(str16, buffer.get(), maxlen,
                                      kCFStringEncodingUTF8)) {
     return false;
diff --git a/base/messagedigest.cc b/base/messagedigest.cc
index 0c2b4a1..c08cab4 100644
--- a/base/messagedigest.cc
+++ b/base/messagedigest.cc
@@ -10,6 +10,8 @@
 
 #include "webrtc/base/messagedigest.h"
 
+#include <memory>
+
 #include <string.h>
 
 #include "webrtc/base/basictypes.h"
@@ -20,7 +22,6 @@
 #include "webrtc/base/md5digest.h"
 #include "webrtc/base/sha1digest.h"
 #endif
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 
 namespace rtc {
@@ -75,14 +76,14 @@
 
 size_t ComputeDigest(const std::string& alg, const void* input, size_t in_len,
                      void* output, size_t out_len) {
-  scoped_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
+  std::unique_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
   return (digest) ?
       ComputeDigest(digest.get(), input, in_len, output, out_len) :
       0;
 }
 
 std::string ComputeDigest(MessageDigest* digest, const std::string& input) {
-  scoped_ptr<char[]> output(new char[digest->Size()]);
+  std::unique_ptr<char[]> output(new char[digest->Size()]);
   ComputeDigest(digest, input.data(), input.size(),
                 output.get(), digest->Size());
   return hex_encode(output.get(), digest->Size());
@@ -90,7 +91,7 @@
 
 bool ComputeDigest(const std::string& alg, const std::string& input,
                    std::string* output) {
-  scoped_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
+  std::unique_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
   if (!digest) {
     return false;
   }
@@ -117,7 +118,7 @@
   }
   // Copy the key to a block-sized buffer to simplify padding.
   // If the key is longer than a block, hash it and use the result instead.
-  scoped_ptr<uint8_t[]> new_key(new uint8_t[block_len]);
+  std::unique_ptr<uint8_t[]> new_key(new uint8_t[block_len]);
   if (key_len > block_len) {
     ComputeDigest(digest, key, key_len, new_key.get(), block_len);
     memset(new_key.get() + digest->Size(), 0, block_len - digest->Size());
@@ -126,14 +127,14 @@
     memset(new_key.get() + key_len, 0, block_len - key_len);
   }
   // Set up the padding from the key, salting appropriately for each padding.
-  scoped_ptr<uint8_t[]> o_pad(new uint8_t[block_len]);
-  scoped_ptr<uint8_t[]> i_pad(new uint8_t[block_len]);
+  std::unique_ptr<uint8_t[]> o_pad(new uint8_t[block_len]);
+  std::unique_ptr<uint8_t[]> i_pad(new uint8_t[block_len]);
   for (size_t i = 0; i < block_len; ++i) {
     o_pad[i] = 0x5c ^ new_key[i];
     i_pad[i] = 0x36 ^ new_key[i];
   }
   // Inner hash; hash the inner padding, and then the input buffer.
-  scoped_ptr<uint8_t[]> inner(new uint8_t[digest->Size()]);
+  std::unique_ptr<uint8_t[]> inner(new uint8_t[digest->Size()]);
   digest->Update(i_pad.get(), block_len);
   digest->Update(input, in_len);
   digest->Finish(inner.get(), digest->Size());
@@ -146,7 +147,7 @@
 size_t ComputeHmac(const std::string& alg, const void* key, size_t key_len,
                    const void* input, size_t in_len,
                    void* output, size_t out_len) {
-  scoped_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
+  std::unique_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
   if (!digest) {
     return 0;
   }
@@ -156,7 +157,7 @@
 
 std::string ComputeHmac(MessageDigest* digest, const std::string& key,
                         const std::string& input) {
-  scoped_ptr<char[]> output(new char[digest->Size()]);
+  std::unique_ptr<char[]> output(new char[digest->Size()]);
   ComputeHmac(digest, key.data(), key.size(),
               input.data(), input.size(), output.get(), digest->Size());
   return hex_encode(output.get(), digest->Size());
@@ -164,7 +165,7 @@
 
 bool ComputeHmac(const std::string& alg, const std::string& key,
                  const std::string& input, std::string* output) {
-  scoped_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
+  std::unique_ptr<MessageDigest> digest(MessageDigestFactory::Create(alg));
   if (!digest) {
     return false;
   }
diff --git a/base/messagehandler.h b/base/messagehandler.h
index 90563e4..2d964df 100644
--- a/base/messagehandler.h
+++ b/base/messagehandler.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_BASE_MESSAGEHANDLER_H_
 #define WEBRTC_BASE_MESSAGEHANDLER_H_
 
+#include <memory>
 #include <utility>
 
 #include "webrtc/base/constructormagic.h"
diff --git a/base/messagequeue.h b/base/messagequeue.h
index efc479c..d323283 100644
--- a/base/messagequeue.h
+++ b/base/messagequeue.h
@@ -15,6 +15,7 @@
 
 #include <algorithm>
 #include <list>
+#include <memory>
 #include <queue>
 #include <vector>
 
@@ -22,7 +23,6 @@
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/messagehandler.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/sharedexclusivelock.h"
 #include "webrtc/base/sigslot.h"
@@ -89,10 +89,11 @@
 class ScopedMessageData : public MessageData {
  public:
   explicit ScopedMessageData(T* data) : data_(data) { }
-  const scoped_ptr<T>& data() const { return data_; }
-  scoped_ptr<T>& data() { return data_; }
+  const std::unique_ptr<T>& data() const { return data_; }
+  std::unique_ptr<T>& data() { return data_; }
+
  private:
-  scoped_ptr<T> data_;
+  std::unique_ptr<T> data_;
 };
 
 // Like ScopedMessageData, but for reference counted pointers.
@@ -278,7 +279,7 @@
   // The SocketServer is not owned by MessageQueue.
   SocketServer* ss_ GUARDED_BY(ss_lock_);
   // If a server isn't supplied in the constructor, use this one.
-  scoped_ptr<SocketServer> default_ss_;
+  std::unique_ptr<SocketServer> default_ss_;
   SharedExclusiveLock ss_lock_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(MessageQueue);
diff --git a/base/multipart_unittest.cc b/base/multipart_unittest.cc
index 9db316b..627d1c6 100644
--- a/base/multipart_unittest.cc
+++ b/base/multipart_unittest.cc
@@ -8,13 +8,13 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/pathutils.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/multipart.h"
 
 namespace rtc {
@@ -61,7 +61,7 @@
   EXPECT_TRUE(multipart.GetSize(&size));
   EXPECT_EQ(part_size, size);
 
-  rtc::scoped_ptr<rtc::MemoryStream> stream(
+  std::unique_ptr<rtc::MemoryStream> stream(
       new rtc::MemoryStream(kTestStreamContent));
   size_t stream_size = 0;
   EXPECT_TRUE(stream->GetSize(&stream_size));
diff --git a/base/nat_unittest.cc b/base/nat_unittest.cc
index 8be1be9..ca72c93 100644
--- a/base/nat_unittest.cc
+++ b/base/nat_unittest.cc
@@ -9,6 +9,7 @@
  */
 
 #include <algorithm>
+#include <memory>
 #include <string>
 
 #include "webrtc/base/gunit.h"
@@ -178,11 +179,11 @@
   // The physical NAT tests require connectivity to the selected ip from the
   // internal address used for the NAT. Things like firewalls can break that, so
   // check to see if it's worth even trying with this ip.
-  scoped_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
-  scoped_ptr<AsyncSocket> client(pss->CreateAsyncSocket(src.family(),
-                                                        SOCK_DGRAM));
-  scoped_ptr<AsyncSocket> server(pss->CreateAsyncSocket(src.family(),
-                                                        SOCK_DGRAM));
+  std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
+  std::unique_ptr<AsyncSocket> client(
+      pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
+  std::unique_ptr<AsyncSocket> server(
+      pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
   if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 ||
       server->Bind(SocketAddress(dst, 0)) != 0) {
     return false;
@@ -244,8 +245,8 @@
       SocketAddress(ext_addr2)
   };
 
-  scoped_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
-  scoped_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
+  std::unique_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
+  std::unique_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
 
   TestBindings(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
   TestFilters(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
@@ -274,16 +275,16 @@
   IPAddress GetNextIP(int af) { return VirtualSocketServer::GetNextIP(af); }
 
  private:
-  scoped_ptr<SocketServer> ss_;
+  std::unique_ptr<SocketServer> ss_;
 };
 
 }  // namespace
 
 void TestVirtualInternal(int family) {
-  scoped_ptr<TestVirtualSocketServer> int_vss(new TestVirtualSocketServer(
-      new PhysicalSocketServer()));
-  scoped_ptr<TestVirtualSocketServer> ext_vss(new TestVirtualSocketServer(
-      new PhysicalSocketServer()));
+  std::unique_ptr<TestVirtualSocketServer> int_vss(
+      new TestVirtualSocketServer(new PhysicalSocketServer()));
+  std::unique_ptr<TestVirtualSocketServer> ext_vss(
+      new TestVirtualSocketServer(new PhysicalSocketServer()));
 
   SocketAddress int_addr;
   SocketAddress ext_addrs[4];
@@ -351,15 +352,15 @@
   bool connected_;
   PhysicalSocketServer* int_pss_;
   PhysicalSocketServer* ext_pss_;
-  rtc::scoped_ptr<TestVirtualSocketServer> int_vss_;
-  rtc::scoped_ptr<TestVirtualSocketServer> ext_vss_;
-  rtc::scoped_ptr<Thread> int_thread_;
-  rtc::scoped_ptr<Thread> ext_thread_;
-  rtc::scoped_ptr<NATServer> nat_;
-  rtc::scoped_ptr<NATSocketFactory> natsf_;
-  rtc::scoped_ptr<AsyncSocket> client_;
-  rtc::scoped_ptr<AsyncSocket> server_;
-  rtc::scoped_ptr<AsyncSocket> accepted_;
+  std::unique_ptr<TestVirtualSocketServer> int_vss_;
+  std::unique_ptr<TestVirtualSocketServer> ext_vss_;
+  std::unique_ptr<Thread> int_thread_;
+  std::unique_ptr<Thread> ext_thread_;
+  std::unique_ptr<NATServer> nat_;
+  std::unique_ptr<NATSocketFactory> natsf_;
+  std::unique_ptr<AsyncSocket> client_;
+  std::unique_ptr<AsyncSocket> server_;
+  std::unique_ptr<AsyncSocket> accepted_;
 };
 
 TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
@@ -377,8 +378,8 @@
   EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress());
   EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr());
 
-  rtc::scoped_ptr<rtc::TestClient> in(CreateTCPTestClient(client_.release()));
-  rtc::scoped_ptr<rtc::TestClient> out(
+  std::unique_ptr<rtc::TestClient> in(CreateTCPTestClient(client_.release()));
+  std::unique_ptr<rtc::TestClient> out(
       CreateTCPTestClient(accepted_.release()));
 
   const char* buf = "test_packet";
diff --git a/base/natserver.cc b/base/natserver.cc
index b071e01..222d270 100644
--- a/base/natserver.cc
+++ b/base/natserver.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/natsocketfactory.h"
 #include "webrtc/base/natserver.h"
 #include "webrtc/base/logging.h"
@@ -195,7 +197,7 @@
 
   // Forward this packet to the internal address.
   // First prepend the address in a quasi-STUN format.
-  scoped_ptr<char[]> real_buf(new char[size + kNATEncodedIPv6AddressSize]);
+  std::unique_ptr<char[]> real_buf(new char[size + kNATEncodedIPv6AddressSize]);
   size_t addrlength = PackAddressForNAT(real_buf.get(),
                                         size + kNATEncodedIPv6AddressSize,
                                         remote_addr);
diff --git a/base/natsocketfactory.cc b/base/natsocketfactory.cc
index 0abd2a1..985748c 100644
--- a/base/natsocketfactory.cc
+++ b/base/natsocketfactory.cc
@@ -141,7 +141,7 @@
       return socket_->SendTo(data, size, addr);
     }
     // This array will be too large for IPv4 packets, but only by 12 bytes.
-    scoped_ptr<char[]> buf(new char[size + kNATEncodedIPv6AddressSize]);
+    std::unique_ptr<char[]> buf(new char[size + kNATEncodedIPv6AddressSize]);
     size_t addrlength = PackAddressForNAT(buf.get(),
                                           size + kNATEncodedIPv6AddressSize,
                                           addr);
diff --git a/base/natsocketfactory.h b/base/natsocketfactory.h
index 9ca0739..82c2a87 100644
--- a/base/natsocketfactory.h
+++ b/base/natsocketfactory.h
@@ -13,6 +13,7 @@
 
 #include <string>
 #include <map>
+#include <memory>
 #include <set>
 
 #include "webrtc/base/natserver.h"
@@ -116,8 +117,8 @@
 
    private:
     NATSocketServer* server_;
-    scoped_ptr<SocketFactory> internal_factory_;
-    scoped_ptr<NATServer> nat_server_;
+    std::unique_ptr<SocketFactory> internal_factory_;
+    std::unique_ptr<NATServer> nat_server_;
     TranslatorMap nats_;
     std::set<SocketAddress> clients_;
   };
diff --git a/base/nethelpers.cc b/base/nethelpers.cc
index 0c7cce6..d901528 100644
--- a/base/nethelpers.cc
+++ b/base/nethelpers.cc
@@ -10,6 +10,8 @@
 
 #include "webrtc/base/nethelpers.h"
 
+#include <memory>
+
 #if defined(WEBRTC_WIN)
 #include <ws2spi.h>
 #include <ws2tcpip.h>
@@ -127,7 +129,7 @@
     return false;
   }
   DWORD protbuff_size = 4096;
-  scoped_ptr<char[]> protocols;
+  std::unique_ptr<char[]> protocols;
   LPWSAPROTOCOL_INFOW protocol_infos = NULL;
   int requested_protocols[2] = {AF_INET6, 0};
 
diff --git a/base/network.cc b/base/network.cc
index c9ad181..b6caaa8 100644
--- a/base/network.cc
+++ b/base/network.cc
@@ -32,10 +32,10 @@
 #include <stdio.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/networkmonitor.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket.h"  // includes something that makes windows happy
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringencode.h"
@@ -471,9 +471,9 @@
       }
 #endif
       // TODO(phoglund): Need to recognize other types as well.
-      scoped_ptr<Network> network(new Network(cursor->ifa_name,
-                                              cursor->ifa_name, prefix,
-                                              prefix_length, adapter_type));
+      std::unique_ptr<Network> network(
+          new Network(cursor->ifa_name, cursor->ifa_name, prefix, prefix_length,
+                      adapter_type));
       network->set_default_local_address_provider(this);
       network->set_scope_id(scope_id);
       network->AddIP(ip);
@@ -497,7 +497,7 @@
     return false;
   }
 
-  rtc::scoped_ptr<IfAddrsConverter> ifaddrs_converter(CreateIfAddrsConverter());
+  std::unique_ptr<IfAddrsConverter> ifaddrs_converter(CreateIfAddrsConverter());
   ConvertIfAddrs(interfaces, ifaddrs_converter.get(), include_ignored,
                  networks);
 
@@ -553,7 +553,7 @@
   NetworkMap current_networks;
   // MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses.
   size_t buffer_size = 16384;
-  scoped_ptr<char[]> adapter_info(new char[buffer_size]);
+  std::unique_ptr<char[]> adapter_info(new char[buffer_size]);
   PIP_ADAPTER_ADDRESSES adapter_addrs =
       reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
   int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST |
@@ -589,7 +589,7 @@
 
         IPAddress ip;
         int scope_id = 0;
-        scoped_ptr<Network> network;
+        std::unique_ptr<Network> network;
         switch (address->Address.lpSockaddr->sa_family) {
           case AF_INET: {
             sockaddr_in* v4_addr =
@@ -628,8 +628,8 @@
             // TODO(phoglund): Need to recognize other types as well.
             adapter_type = ADAPTER_TYPE_LOOPBACK;
           }
-          scoped_ptr<Network> network(new Network(name, description, prefix,
-                                                  prefix_length, adapter_type));
+          std::unique_ptr<Network> network(new Network(
+              name, description, prefix, prefix_length, adapter_type));
           network->set_default_local_address_provider(this);
           network->set_scope_id(scope_id);
           network->AddIP(ip);
@@ -792,7 +792,7 @@
   ASSERT(thread_->socketserver() != nullptr);
   ASSERT(family == AF_INET || family == AF_INET6);
 
-  scoped_ptr<AsyncSocket> socket(
+  std::unique_ptr<AsyncSocket> socket(
       thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
   if (!socket) {
     LOG_ERR(LERROR) << "Socket creation failed";
diff --git a/base/network.h b/base/network.h
index 7c328ff..a41da4a 100644
--- a/base/network.h
+++ b/base/network.h
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -20,7 +21,6 @@
 #include "webrtc/base/ipaddress.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/messagehandler.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
 
 #if defined(WEBRTC_POSIX)
@@ -170,8 +170,8 @@
   NetworkMap networks_map_;
   bool ipv6_enabled_;
 
-  rtc::scoped_ptr<rtc::Network> ipv4_any_address_network_;
-  rtc::scoped_ptr<rtc::Network> ipv6_any_address_network_;
+  std::unique_ptr<rtc::Network> ipv4_any_address_network_;
+  std::unique_ptr<rtc::Network> ipv6_any_address_network_;
 
   IPAddress default_local_ipv4_address_;
   IPAddress default_local_ipv6_address_;
@@ -254,7 +254,7 @@
   int start_count_;
   std::vector<std::string> network_ignore_list_;
   bool ignore_non_default_routes_;
-  scoped_ptr<NetworkMonitorInterface> network_monitor_;
+  std::unique_ptr<NetworkMonitorInterface> network_monitor_;
 };
 
 // Represents a Unix-type network interface, with a name and single address.
diff --git a/base/network_unittest.cc b/base/network_unittest.cc
index d365477..f3193e2 100644
--- a/base/network_unittest.cc
+++ b/base/network_unittest.cc
@@ -12,6 +12,7 @@
 
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/networkmonitor.h"
+#include <memory>
 #include <vector>
 #if defined(WEBRTC_POSIX)
 #include <sys/types.h>
@@ -108,7 +109,7 @@
                                  bool include_ignored,
                                  NetworkManager::NetworkList* networks) {
     // Use the base IfAddrsConverter for test cases.
-    rtc::scoped_ptr<IfAddrsConverter> ifaddrs_converter(new IfAddrsConverter());
+    std::unique_ptr<IfAddrsConverter> ifaddrs_converter(new IfAddrsConverter());
     network_manager.ConvertIfAddrs(interfaces, ifaddrs_converter.get(),
                                    include_ignored, networks);
   }
diff --git a/base/networkmonitor.h b/base/networkmonitor.h
index 35ab2b1..5459cd6 100644
--- a/base/networkmonitor.h
+++ b/base/networkmonitor.h
@@ -12,7 +12,6 @@
 #define WEBRTC_BASE_NETWORKMONITOR_H_
 
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/thread.h"
 
diff --git a/base/onetimeevent.h b/base/onetimeevent.h
index 9708b4b..240cf14 100644
--- a/base/onetimeevent.h
+++ b/base/onetimeevent.h
@@ -11,7 +11,6 @@
 #ifndef WEBRTC_BASE_ONETIMEEVENT_H_
 #define WEBRTC_BASE_ONETIMEEVENT_H_
 
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/typedefs.h"
 
diff --git a/base/opensslidentity.cc b/base/opensslidentity.cc
index 9c2112e..ec9c007 100644
--- a/base/opensslidentity.cc
+++ b/base/opensslidentity.cc
@@ -12,6 +12,8 @@
 
 #include "webrtc/base/opensslidentity.h"
 
+#include <memory>
+
 // Must be included first before openssl headers.
 #include "webrtc/base/win32.h"  // NOLINT
 
@@ -280,7 +282,7 @@
   return true;
 }
 
-rtc::scoped_ptr<SSLCertChain> OpenSSLCertificate::GetChain() const {
+std::unique_ptr<SSLCertChain> OpenSSLCertificate::GetChain() const {
   // Chains are not yet supported when using OpenSSL.
   // OpenSSLStreamAdapter::SSLVerifyCallback currently requires the remote
   // certificate to be self-signed.
@@ -430,7 +432,7 @@
 SSLIdentity* OpenSSLIdentity::FromPEMStrings(
     const std::string& private_key,
     const std::string& certificate) {
-  scoped_ptr<OpenSSLCertificate> cert(
+  std::unique_ptr<OpenSSLCertificate> cert(
       OpenSSLCertificate::FromPEMString(certificate));
   if (!cert) {
     LOG(LS_ERROR) << "Failed to create OpenSSLCertificate from PEM string.";
diff --git a/base/opensslidentity.h b/base/opensslidentity.h
index df49508..332da18 100644
--- a/base/opensslidentity.h
+++ b/base/opensslidentity.h
@@ -14,10 +14,10 @@
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 
+#include <memory>
 #include <string>
 
 #include "webrtc/base/common.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 
 typedef struct ssl_ctx_st SSL_CTX;
@@ -85,7 +85,7 @@
                             size_t* length);
 
   bool GetSignatureDigestAlgorithm(std::string* algorithm) const override;
-  rtc::scoped_ptr<SSLCertChain> GetChain() const override;
+  std::unique_ptr<SSLCertChain> GetChain() const override;
 
   int64_t CertificateExpirationTime() const override;
 
@@ -120,8 +120,8 @@
 
   static OpenSSLIdentity* GenerateInternal(const SSLIdentityParams& params);
 
-  scoped_ptr<OpenSSLKeyPair> key_pair_;
-  scoped_ptr<OpenSSLCertificate> certificate_;
+  std::unique_ptr<OpenSSLKeyPair> key_pair_;
+  std::unique_ptr<OpenSSLCertificate> certificate_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(OpenSSLIdentity);
 };
diff --git a/base/opensslstreamadapter.cc b/base/opensslstreamadapter.cc
index b09c2a5..abdf5e4 100644
--- a/base/opensslstreamadapter.cc
+++ b/base/opensslstreamadapter.cc
@@ -22,6 +22,7 @@
 #include <openssl/dtls1.h>
 #endif
 
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/common.h"
@@ -293,9 +294,9 @@
   role_ = role;
 }
 
-rtc::scoped_ptr<SSLCertificate> OpenSSLStreamAdapter::GetPeerCertificate()
+std::unique_ptr<SSLCertificate> OpenSSLStreamAdapter::GetPeerCertificate()
     const {
-  return peer_certificate_ ? rtc::scoped_ptr<SSLCertificate>(
+  return peer_certificate_ ? std::unique_ptr<SSLCertificate>(
                                  peer_certificate_->GetReference())
                            : nullptr;
 }
diff --git a/base/opensslstreamadapter.h b/base/opensslstreamadapter.h
index 463c8f2..1e90bac 100644
--- a/base/opensslstreamadapter.h
+++ b/base/opensslstreamadapter.h
@@ -12,6 +12,7 @@
 #define WEBRTC_BASE_OPENSSLSTREAMADAPTER_H__
 
 #include <string>
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/buffer.h"
@@ -69,7 +70,7 @@
                                 const unsigned char* digest_val,
                                 size_t digest_len) override;
 
-  rtc::scoped_ptr<SSLCertificate> GetPeerCertificate() const override;
+  std::unique_ptr<SSLCertificate> GetPeerCertificate() const override;
 
   int StartSSLWithServer(const char* server_name) override;
   int StartSSLWithPeer() override;
@@ -184,13 +185,13 @@
   SSL_CTX* ssl_ctx_;
 
   // Our key and certificate, mostly useful in peer-to-peer mode.
-  scoped_ptr<OpenSSLIdentity> identity_;
+  std::unique_ptr<OpenSSLIdentity> identity_;
   // in traditional mode, the server name that the server's certificate
   // must specify. Empty in peer-to-peer mode.
   std::string ssl_server_name_;
   // The certificate that the peer must present or did present. Initially
   // null in traditional mode, until the connection is established.
-  scoped_ptr<OpenSSLCertificate> peer_certificate_;
+  std::unique_ptr<OpenSSLCertificate> peer_certificate_;
   // In peer-to-peer mode, the digest of the certificate that
   // the peer must present.
   Buffer peer_certificate_digest_value_;
diff --git a/base/optional_unittest.cc b/base/optional_unittest.cc
index 8ddbeba..af82b92 100644
--- a/base/optional_unittest.cc
+++ b/base/optional_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <sstream>
 #include <string>
 #include <utility>
@@ -64,8 +65,8 @@
   }
   void Foo() { Log("Foo()"); }
   void Foo() const { Log("Foo() const"); }
-  static rtc::scoped_ptr<std::vector<std::string>> Setup() {
-    rtc::scoped_ptr<std::vector<std::string>> s(new std::vector<std::string>);
+  static std::unique_ptr<std::vector<std::string>> Setup() {
+    std::unique_ptr<std::vector<std::string>> s(new std::vector<std::string>);
     g_log = s.get();
     g_next_id = 0;
     return s;
diff --git a/base/optionsfile_unittest.cc b/base/optionsfile_unittest.cc
index bcfb3ef..f22a2f1 100644
--- a/base/optionsfile_unittest.cc
+++ b/base/optionsfile_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/optionsfile.h"
@@ -51,7 +53,7 @@
     store_.reset(new OptionsFile(test_file_));
   }
 
-  rtc::scoped_ptr<OptionsFile> store_;
+  std::unique_ptr<OptionsFile> store_;
 
  private:
   std::string test_file_;
diff --git a/base/physicalsocketserver.h b/base/physicalsocketserver.h
index 583306c..f5867d2 100644
--- a/base/physicalsocketserver.h
+++ b/base/physicalsocketserver.h
@@ -11,11 +11,11 @@
 #ifndef WEBRTC_BASE_PHYSICALSOCKETSERVER_H__
 #define WEBRTC_BASE_PHYSICALSOCKETSERVER_H__
 
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/asyncfile.h"
 #include "webrtc/base/nethelpers.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketserver.h"
 #include "webrtc/base/criticalsection.h"
 
@@ -104,7 +104,7 @@
 #if defined(WEBRTC_POSIX)
   static bool InstallSignal(int signum, void (*handler)(int));
 
-  scoped_ptr<PosixSignalDispatcher> signal_dispatcher_;
+  std::unique_ptr<PosixSignalDispatcher> signal_dispatcher_;
 #endif
   DispatcherList dispatchers_;
   IteratorList iterators_;
diff --git a/base/physicalsocketserver_unittest.cc b/base/physicalsocketserver_unittest.cc
index c53441d..a04362d 100644
--- a/base/physicalsocketserver_unittest.cc
+++ b/base/physicalsocketserver_unittest.cc
@@ -8,13 +8,13 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <signal.h>
 #include <stdarg.h>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket_unittest.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
@@ -100,7 +100,7 @@
   void ConnectInternalAcceptError(const IPAddress& loopback);
   void WritableAfterPartialWrite(const IPAddress& loopback);
 
-  rtc::scoped_ptr<FakePhysicalSocketServer> server_;
+  std::unique_ptr<FakePhysicalSocketServer> server_;
   SocketServerScope scope_;
   bool fail_accept_;
   int max_send_size_;
@@ -172,20 +172,20 @@
   SocketAddress accept_addr;
 
   // Create two clients.
-  scoped_ptr<AsyncSocket> client1(server_->CreateAsyncSocket(loopback.family(),
-                                                             SOCK_STREAM));
+  std::unique_ptr<AsyncSocket> client1(
+      server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client1.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client1->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client1->GetLocalAddress().ipaddr());
 
-  scoped_ptr<AsyncSocket> client2(server_->CreateAsyncSocket(loopback.family(),
-                                                             SOCK_STREAM));
+  std::unique_ptr<AsyncSocket> client2(
+      server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client2.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client2->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client2->GetLocalAddress().ipaddr());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -211,7 +211,7 @@
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
   // Simulate "::accept" returning an error.
   SetFailAccept(true);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   EXPECT_FALSE(accepted);
   ASSERT_TRUE(accept_addr.IsNil());
 
@@ -233,7 +233,7 @@
   // Server has pending connection, try to accept it (will succeed).
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
   SetFailAccept(false);
-  scoped_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted2);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr);
@@ -515,7 +515,7 @@
   static std::vector<int> signals_received_;
   static Thread *signaled_thread_;
 
-  scoped_ptr<PhysicalSocketServer> ss_;
+  std::unique_ptr<PhysicalSocketServer> ss_;
 };
 
 std::vector<int> PosixSignalDeliveryTest::signals_received_;
@@ -583,8 +583,8 @@
   // Start a new thread that raises it. It will have to be delivered to that
   // thread. Our implementation should safely handle it and dispatch
   // RecordSignal() on this thread.
-  scoped_ptr<Thread> thread(new Thread());
-  scoped_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
+  std::unique_ptr<Thread> thread(new Thread());
+  std::unique_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
   thread->Start(runnable.get());
   EXPECT_TRUE(ss_->Wait(1500, true));
   EXPECT_TRUE(ExpectSignal(SIGTERM));
diff --git a/base/platform_thread.h b/base/platform_thread.h
index 8c2161b..d74aec2 100644
--- a/base/platform_thread.h
+++ b/base/platform_thread.h
@@ -16,7 +16,6 @@
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/platform_thread_types.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_checker.h"
 
 namespace rtc {
diff --git a/base/platform_thread_unittest.cc b/base/platform_thread_unittest.cc
index d06a738..847946a 100644
--- a/base/platform_thread_unittest.cc
+++ b/base/platform_thread_unittest.cc
@@ -11,7 +11,6 @@
 #include "webrtc/base/platform_thread.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 
 namespace rtc {
diff --git a/base/proxy_unittest.cc b/base/proxy_unittest.cc
index d8a523f..4dba0dd 100644
--- a/base/proxy_unittest.cc
+++ b/base/proxy_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/base/autodetectproxy.h"
 #include "webrtc/base/gunit.h"
@@ -67,10 +68,10 @@
   }
 
  private:
-  rtc::scoped_ptr<rtc::SocketServer> ss_;
-  rtc::scoped_ptr<rtc::SocksProxyServer> socks_;
+  std::unique_ptr<rtc::SocketServer> ss_;
+  std::unique_ptr<rtc::SocksProxyServer> socks_;
   // TODO: Make this a real HTTPS proxy server.
-  rtc::scoped_ptr<rtc::HttpListenServer> https_;
+  std::unique_ptr<rtc::HttpListenServer> https_;
 };
 
 // Tests whether we can use a SOCKS5 proxy to connect to a server.
diff --git a/base/proxydetect.cc b/base/proxydetect.cc
index abb8f0a..10e7a02 100644
--- a/base/proxydetect.cc
+++ b/base/proxydetect.cc
@@ -29,6 +29,7 @@
 #endif
 
 #include <map>
+#include <memory>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/fileutils.h"
@@ -430,7 +431,7 @@
   // Note: we are looking for the first entry with "Default=1", or the last
   // entry in the file
   path.SetFilename("profiles.ini");
-  scoped_ptr<FileStream> fs(Filesystem::OpenFile(path, "r"));
+  std::unique_ptr<FileStream> fs(Filesystem::OpenFile(path, "r"));
   if (!fs) {
     return false;
   }
@@ -495,7 +496,7 @@
 bool ReadFirefoxPrefs(const Pathname& filename,
                       const char * prefix,
                       StringMap* settings) {
-  scoped_ptr<FileStream> fs(Filesystem::OpenFile(filename, "r"));
+  std::unique_ptr<FileStream> fs(Filesystem::OpenFile(filename, "r"));
   if (!fs) {
     LOG(LS_ERROR) << "Failed to open file: " << filename.pathname();
     return false;
diff --git a/base/proxyserver.h b/base/proxyserver.h
index adb26ae..5dfa37c 100644
--- a/base/proxyserver.h
+++ b/base/proxyserver.h
@@ -12,6 +12,7 @@
 #define WEBRTC_BASE_PROXYSERVER_H_
 
 #include <list>
+#include <memory>
 #include "webrtc/base/asyncsocket.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/socketaddress.h"
@@ -50,8 +51,8 @@
   void Destroy();
 
   static const int kBufferSize = 4096;
-  scoped_ptr<AsyncProxyServerSocket> int_socket_;
-  scoped_ptr<AsyncSocket> ext_socket_;
+  std::unique_ptr<AsyncProxyServerSocket> int_socket_;
+  std::unique_ptr<AsyncSocket> ext_socket_;
   bool connected_;
   FifoBuffer out_buffer_;
   FifoBuffer in_buffer_;
@@ -76,7 +77,7 @@
   typedef std::list<ProxyBinding*> BindingList;
   SocketFactory* ext_factory_;
   SocketAddress ext_ip_;
-  scoped_ptr<AsyncSocket> server_socket_;
+  std::unique_ptr<AsyncSocket> server_socket_;
   BindingList bindings_;
   RTC_DISALLOW_COPY_AND_ASSIGN(ProxyServer);
 };
diff --git a/base/rate_statistics.h b/base/rate_statistics.h
index 21f6ce6..aea8d79 100644
--- a/base/rate_statistics.h
+++ b/base/rate_statistics.h
@@ -11,7 +11,8 @@
 #ifndef WEBRTC_BASE_RATE_STATISTICS_H_
 #define WEBRTC_BASE_RATE_STATISTICS_H_
 
-#include "webrtc/base/scoped_ptr.h"
+#include <memory>
+
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
@@ -34,7 +35,7 @@
   // Counters are kept in buckets (circular buffer), with one bucket
   // per millisecond.
   const int num_buckets_;
-  rtc::scoped_ptr<size_t[]> buckets_;
+  std::unique_ptr<size_t[]> buckets_;
 
   // Total count recorded in buckets.
   size_t accumulated_count_;
diff --git a/base/referencecountedsingletonfactory.h b/base/referencecountedsingletonfactory.h
index f955986..1a41695 100644
--- a/base/referencecountedsingletonfactory.h
+++ b/base/referencecountedsingletonfactory.h
@@ -11,10 +11,11 @@
 #ifndef WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
 #define WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
 
+#include <memory>
+
 #include "webrtc/base/common.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
@@ -41,11 +42,11 @@
  protected:
   // Must be implemented in a sub-class. The sub-class may choose whether or not
   // to cache the instance across lifetimes by either reset()'ing or not
-  // reset()'ing the scoped_ptr in CleanupInstance().
+  // reset()'ing the unique_ptr in CleanupInstance().
   virtual bool SetupInstance() = 0;
   virtual void CleanupInstance() = 0;
 
-  scoped_ptr<Interface> instance_;
+  std::unique_ptr<Interface> instance_;
 
  private:
   Interface* GetInstance() {
diff --git a/base/rtccertificate.cc b/base/rtccertificate.cc
index 7b764bd..70959ee 100644
--- a/base/rtccertificate.cc
+++ b/base/rtccertificate.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/rtccertificate.h"
 
 #include "webrtc/base/checks.h"
@@ -15,7 +17,7 @@
 namespace rtc {
 
 scoped_refptr<RTCCertificate> RTCCertificate::Create(
-    scoped_ptr<SSLIdentity> identity) {
+    std::unique_ptr<SSLIdentity> identity) {
   return new RefCountedObject<RTCCertificate>(identity.release());
 }
 
diff --git a/base/rtccertificate.h b/base/rtccertificate.h
index 600739b..3d4f36e 100644
--- a/base/rtccertificate.h
+++ b/base/rtccertificate.h
@@ -11,9 +11,10 @@
 #ifndef WEBRTC_BASE_RTCCERTIFICATE_H_
 #define WEBRTC_BASE_RTCCERTIFICATE_H_
 
+#include <memory>
+
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/refcount.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/sslidentity.h"
 
@@ -25,7 +26,8 @@
 class RTCCertificate : public RefCountInterface {
  public:
   // Takes ownership of |identity|.
-  static scoped_refptr<RTCCertificate> Create(scoped_ptr<SSLIdentity> identity);
+  static scoped_refptr<RTCCertificate> Create(
+      std::unique_ptr<SSLIdentity> identity);
 
   // Returns the expiration time in ms relative to epoch, 1970-01-01T00:00:00Z.
   uint64_t Expires() const;
@@ -47,7 +49,7 @@
  private:
   // The SSLIdentity is the owner of the SSLCertificate. To protect our
   // ssl_certificate() we take ownership of |identity_|.
-  scoped_ptr<SSLIdentity> identity_;
+  std::unique_ptr<SSLIdentity> identity_;
 };
 
 }  // namespace rtc
diff --git a/base/rtccertificate_unittests.cc b/base/rtccertificate_unittests.cc
index 84c8544..7795fe7 100644
--- a/base/rtccertificate_unittests.cc
+++ b/base/rtccertificate_unittests.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <utility>
 
 #include "webrtc/base/checks.h"
@@ -16,7 +17,6 @@
 #include "webrtc/base/logging.h"
 #include "webrtc/base/rtccertificate.h"
 #include "webrtc/base/safe_conversions.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
@@ -77,7 +77,7 @@
     // is fast to generate.
     params.key_params = KeyParams::ECDSA();
 
-    scoped_ptr<SSLIdentity> identity(SSLIdentity::GenerateForTest(params));
+    std::unique_ptr<SSLIdentity> identity(SSLIdentity::GenerateForTest(params));
     return RTCCertificate::Create(std::move(identity));
   }
 };
@@ -85,7 +85,7 @@
 TEST_F(RTCCertificateTest, NewCertificateNotExpired) {
   // Generate a real certificate without specifying the expiration time.
   // Certificate type doesn't matter, using ECDSA because it's fast to generate.
-  scoped_ptr<SSLIdentity> identity(
+  std::unique_ptr<SSLIdentity> identity(
       SSLIdentity::Generate(kTestCertCommonName, KeyParams::ECDSA()));
   scoped_refptr<RTCCertificate> certificate =
       RTCCertificate::Create(std::move(identity));
diff --git a/base/rtccertificategenerator.cc b/base/rtccertificategenerator.cc
index d4572b0..f0d72e7 100644
--- a/base/rtccertificategenerator.cc
+++ b/base/rtccertificategenerator.cc
@@ -11,6 +11,7 @@
 #include "webrtc/base/rtccertificategenerator.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/sslidentity.h"
@@ -124,7 +125,7 @@
   }
   if (!identity)
     return nullptr;
-  scoped_ptr<SSLIdentity> identity_sptr(identity);
+  std::unique_ptr<SSLIdentity> identity_sptr(identity);
   return RTCCertificate::Create(std::move(identity_sptr));
 }
 
diff --git a/base/rtccertificategenerator_unittest.cc b/base/rtccertificategenerator_unittest.cc
index 162a2d5..750839c 100644
--- a/base/rtccertificategenerator_unittest.cc
+++ b/base/rtccertificategenerator_unittest.cc
@@ -10,11 +10,12 @@
 
 #include "webrtc/base/rtccertificategenerator.h"
 
+#include <memory>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/optional.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
@@ -59,8 +60,8 @@
 
  protected:
   Thread* const signaling_thread_;
-  scoped_ptr<Thread> worker_thread_;
-  scoped_ptr<RTCCertificateGenerator> generator_;
+  std::unique_ptr<Thread> worker_thread_;
+  std::unique_ptr<RTCCertificateGenerator> generator_;
   scoped_refptr<RTCCertificate> certificate_;
   bool generate_async_completed_;
 };
diff --git a/base/scopedptrcollection_unittest.cc b/base/scopedptrcollection_unittest.cc
index 933173e..267b110 100644
--- a/base/scopedptrcollection_unittest.cc
+++ b/base/scopedptrcollection_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/scopedptrcollection.h"
 #include "webrtc/base/gunit.h"
 
@@ -41,7 +43,7 @@
   }
 
   int num_instances_;
-  scoped_ptr<ScopedPtrCollection<InstanceCounter> > collection_;
+  std::unique_ptr<ScopedPtrCollection<InstanceCounter> > collection_;
 };
 
 TEST_F(ScopedPtrCollectionTest, PushBack) {
diff --git a/base/sharedexclusivelock_unittest.cc b/base/sharedexclusivelock_unittest.cc
index 9b64ed7..bf75b31 100644
--- a/base/sharedexclusivelock_unittest.cc
+++ b/base/sharedexclusivelock_unittest.cc
@@ -8,11 +8,12 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/common.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/messagequeue.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sharedexclusivelock.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
@@ -42,7 +43,7 @@
   int waiting_time_in_ms() const { return waiting_time_in_ms_; }
 
  protected:
-  scoped_ptr<Thread> worker_thread_;
+  std::unique_ptr<Thread> worker_thread_;
   SharedExclusiveLock* shared_exclusive_lock_;
   int waiting_time_in_ms_;
   int* value_;
@@ -127,7 +128,7 @@
   }
 
  protected:
-  scoped_ptr<SharedExclusiveLock> shared_exclusive_lock_;
+  std::unique_ptr<SharedExclusiveLock> shared_exclusive_lock_;
   int value_;
 };
 
diff --git a/base/signalthread_unittest.cc b/base/signalthread_unittest.cc
index a583aef..22d65b6 100644
--- a/base/signalthread_unittest.cc
+++ b/base/signalthread_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/signalthread.h"
 #include "webrtc/base/thread.h"
@@ -135,7 +137,7 @@
 // when shutting down the process.
 TEST_F(SignalThreadTest, OwnerThreadGoesAway) {
   {
-    scoped_ptr<OwnerThread> owner(new OwnerThread(this));
+    std::unique_ptr<OwnerThread> owner(new OwnerThread(this));
     main_thread_ = owner.get();
     owner->Start();
     while (!owner->has_run()) {
diff --git a/base/socket_unittest.cc b/base/socket_unittest.cc
index d1369e2..5f6de42 100644
--- a/base/socket_unittest.cc
+++ b/base/socket_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/socket_unittest.h"
 
 #include "webrtc/base/arraysize.h"
@@ -198,14 +200,14 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(loopback.family(),
-                                                        SOCK_STREAM));
+  std::unique_ptr<AsyncSocket> client(
+      ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client->GetLocalAddress().ipaddr());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -229,7 +231,7 @@
 
   // Server has pending connection, accept it.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
@@ -253,12 +255,12 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -278,7 +280,7 @@
 
   // Server has pending connection, accept it.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
@@ -301,12 +303,12 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -334,12 +336,12 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -372,13 +374,13 @@
 
 void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Create a client and put in to CS_CLOSED state.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, client->Close());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
@@ -391,13 +393,13 @@
 void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
   // Create server and listen.
   testing::StreamSink sink;
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
   // Create client, connect.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
@@ -408,7 +410,7 @@
   // Accept the original connection.
   SocketAddress accept_addr;
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   EXPECT_FALSE(accept_addr.IsNil());
 
@@ -435,12 +437,12 @@
   testing::StreamSink sink;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -464,12 +466,12 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -483,7 +485,7 @@
   client->Close();
 
   // The connection should still be able to be accepted.
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
@@ -502,12 +504,12 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -518,7 +520,7 @@
 
   // Accept connection.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
 
@@ -576,13 +578,13 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -593,7 +595,7 @@
 
   // Accept connection.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
 
@@ -630,9 +632,9 @@
   SocketAddress accept_addr;
 
   // Create & connect server and client sockets.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   sink.Monitor(server.get());
@@ -642,7 +644,7 @@
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
 
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
@@ -663,7 +665,7 @@
   EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
 
   // Shouldn't signal when blocked in a thread Send, where process_io is false.
-  scoped_ptr<Thread> thread(new Thread());
+  std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   Sleeper sleeper;
   TypedMessageData<AsyncSocket*> data(client.get());
@@ -681,12 +683,12 @@
   SocketAddress accept_addr;
 
   // Create receiving client.
-  scoped_ptr<AsyncSocket> receiver(
+  std::unique_ptr<AsyncSocket> receiver(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(receiver.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -697,7 +699,7 @@
 
   // Accept connection which will be used for sending.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> sender(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> sender(server->Accept(&accept_addr));
   ASSERT_TRUE(sender);
   sink.Monitor(sender.get());
 
@@ -809,12 +811,12 @@
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -825,7 +827,7 @@
 
   // Accept connection.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
 
@@ -887,9 +889,9 @@
   delete socket;
 
   // Test send/receive behavior.
-  scoped_ptr<TestClient> client1(
+  std::unique_ptr<TestClient> client1(
       new TestClient(AsyncUDPSocket::Create(ss_, addr1)));
-  scoped_ptr<TestClient> client2(
+  std::unique_ptr<TestClient> client2(
       new TestClient(AsyncUDPSocket::Create(ss_, empty)));
 
   SocketAddress addr2;
@@ -928,10 +930,10 @@
   SocketAddress test_addr(dest, 2345);
 
   // Test send
-  scoped_ptr<TestClient> client(
+  std::unique_ptr<TestClient> client(
       new TestClient(AsyncUDPSocket::Create(ss_, empty)));
   int test_packet_size = 1200;
-  rtc::scoped_ptr<char[]> test_packet(new char[test_packet_size]);
+  std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
   // Init the test packet just to avoid memcheck warning.
   memset(test_packet.get(), 0, test_packet_size);
   // Set the send buffer size to the same size as the test packet to have a
@@ -965,7 +967,7 @@
 }
 
 void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
-  rtc::scoped_ptr<AsyncSocket> socket(
+  std::unique_ptr<AsyncSocket> socket(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
   socket->Bind(SocketAddress(loopback, 0));
 
@@ -1000,9 +1002,8 @@
   // Skip the esimate MTU test for IPv6 for now.
   if (loopback.family() != AF_INET6) {
     // Try estimating MTU.
-    rtc::scoped_ptr<AsyncSocket>
-        mtu_socket(
-            ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
+    std::unique_ptr<AsyncSocket> mtu_socket(
+        ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
     mtu_socket->Bind(SocketAddress(loopback, 0));
     uint16_t mtu;
     // should fail until we connect
diff --git a/base/ssladapter_unittest.cc b/base/ssladapter_unittest.cc
index 7869b6e..16e5c2e 100644
--- a/base/ssladapter_unittest.cc
+++ b/base/ssladapter_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/base/gunit.h"
@@ -123,7 +124,7 @@
  private:
   const rtc::SSLMode ssl_mode_;
 
-  rtc::scoped_ptr<rtc::SSLAdapter> ssl_adapter_;
+  std::unique_ptr<rtc::SSLAdapter> ssl_adapter_;
 
   std::string data_;
 };
@@ -259,10 +260,10 @@
 
   const rtc::SSLMode ssl_mode_;
 
-  rtc::scoped_ptr<rtc::AsyncSocket> server_socket_;
-  rtc::scoped_ptr<rtc::SSLStreamAdapter> ssl_stream_adapter_;
+  std::unique_ptr<rtc::AsyncSocket> server_socket_;
+  std::unique_ptr<rtc::SSLStreamAdapter> ssl_stream_adapter_;
 
-  rtc::scoped_ptr<rtc::SSLIdentity> ssl_identity_;
+  std::unique_ptr<rtc::SSLIdentity> ssl_identity_;
 
   std::string data_;
 };
@@ -339,8 +340,8 @@
 
   const rtc::SocketServerScope ss_scope_;
 
-  rtc::scoped_ptr<SSLAdapterTestDummyServer> server_;
-  rtc::scoped_ptr<SSLAdapterTestDummyClient> client_;
+  std::unique_ptr<SSLAdapterTestDummyServer> server_;
+  std::unique_ptr<SSLAdapterTestDummyClient> client_;
 
   int handshake_wait_;
 };
diff --git a/base/sslidentity.h b/base/sslidentity.h
index 77c9e18..af0149b 100644
--- a/base/sslidentity.h
+++ b/base/sslidentity.h
@@ -14,12 +14,12 @@
 #define WEBRTC_BASE_SSLIDENTITY_H_
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/messagedigest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
@@ -53,7 +53,7 @@
 
   // Provides the cert chain, or null. The chain includes a copy of each
   // certificate, excluding the leaf.
-  virtual rtc::scoped_ptr<SSLCertChain> GetChain() const = 0;
+  virtual std::unique_ptr<SSLCertChain> GetChain() const = 0;
 
   // Returns a PEM encoded string representation of the certificate.
   virtual std::string ToPEMString() const = 0;
diff --git a/base/sslidentity_unittest.cc b/base/sslidentity_unittest.cc
index f110f76..e108b7d 100644
--- a/base/sslidentity_unittest.cc
+++ b/base/sslidentity_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/base/gunit.h"
@@ -174,11 +175,11 @@
   }
 
  private:
-  rtc::scoped_ptr<SSLIdentity> identity_rsa1_;
-  rtc::scoped_ptr<SSLIdentity> identity_rsa2_;
-  rtc::scoped_ptr<SSLIdentity> identity_ecdsa1_;
-  rtc::scoped_ptr<SSLIdentity> identity_ecdsa2_;
-  rtc::scoped_ptr<rtc::SSLCertificate> test_cert_;
+  std::unique_ptr<SSLIdentity> identity_rsa1_;
+  std::unique_ptr<SSLIdentity> identity_rsa2_;
+  std::unique_ptr<SSLIdentity> identity_ecdsa1_;
+  std::unique_ptr<SSLIdentity> identity_ecdsa2_;
+  std::unique_ptr<rtc::SSLCertificate> test_cert_;
 };
 
 TEST_F(SSLIdentityTest, FixedDigestSHA1) {
@@ -251,7 +252,7 @@
       "UD0A8qfhfDM+LK6rPAnCsVN0NRDY3jvd6rzix9M=\n"
       "-----END CERTIFICATE-----\n";
 
-  rtc::scoped_ptr<SSLIdentity> identity(
+  std::unique_ptr<SSLIdentity> identity(
       SSLIdentity::FromPEMStrings(kRSA_PRIVATE_KEY_PEM, kCERT_PEM));
   EXPECT_TRUE(identity);
   EXPECT_EQ(kCERT_PEM, identity->certificate().ToPEMString());
@@ -278,7 +279,7 @@
       "GWP/PwIgJynB4AUDsPT0DWmethOXYijB5sY5UPd9DvgmiS/Mr6s=\n"
       "-----END CERTIFICATE-----\n";
 
-  rtc::scoped_ptr<SSLIdentity> identity(
+  std::unique_ptr<SSLIdentity> identity(
       SSLIdentity::FromPEMStrings(kRSA_PRIVATE_KEY_PEM, kCERT_PEM));
   EXPECT_TRUE(identity);
   EXPECT_EQ(kCERT_PEM, identity->certificate().ToPEMString());
diff --git a/base/sslsocketfactory.cc b/base/sslsocketfactory.cc
index d6ec56f..7ab58fd 100644
--- a/base/sslsocketfactory.cc
+++ b/base/sslsocketfactory.cc
@@ -8,10 +8,11 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
+
 #include "webrtc/base/autodetectproxy.h"
 #include "webrtc/base/httpcommon.h"
 #include "webrtc/base/httpcommon-inl.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslsocketfactory.h"
@@ -167,7 +168,7 @@
   }
 
   if (!hostname_.empty()) {
-    rtc::scoped_ptr<SSLAdapter> ssl_adapter(SSLAdapter::Create(socket));
+    std::unique_ptr<SSLAdapter> ssl_adapter(SSLAdapter::Create(socket));
     if (!ssl_adapter) {
       LOG_F(LS_ERROR) << "SSL unavailable";
       delete socket;
diff --git a/base/sslstreamadapter.h b/base/sslstreamadapter.h
index 9a94462..c5045f1 100644
--- a/base/sslstreamadapter.h
+++ b/base/sslstreamadapter.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_BASE_SSLSTREAMADAPTER_H_
 #define WEBRTC_BASE_SSLSTREAMADAPTER_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -159,7 +160,7 @@
   // Retrieves the peer's X.509 certificate, if a connection has been
   // established. It returns the transmitted over SSL, including the entire
   // chain.
-  virtual rtc::scoped_ptr<SSLCertificate> GetPeerCertificate() const = 0;
+  virtual std::unique_ptr<SSLCertificate> GetPeerCertificate() const = 0;
 
   // Retrieves the IANA registration id of the cipher suite used for the
   // connection (e.g. 0x2F for "TLS_RSA_WITH_AES_128_CBC_SHA").
diff --git a/base/sslstreamadapter_unittest.cc b/base/sslstreamadapter_unittest.cc
index 8d5b275..ac9fef9 100644
--- a/base/sslstreamadapter_unittest.cc
+++ b/base/sslstreamadapter_unittest.cc
@@ -10,13 +10,13 @@
 
 
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <string>
 
 #include "webrtc/base/bufferqueue.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslconfig.h"
 #include "webrtc/base/sslidentity.h"
@@ -474,7 +474,7 @@
       return server_ssl_->GetDtlsSrtpCryptoSuite(retval);
   }
 
-  rtc::scoped_ptr<rtc::SSLCertificate> GetPeerCertificate(bool client) {
+  std::unique_ptr<rtc::SSLCertificate> GetPeerCertificate(bool client) {
     if (client)
       return client_ssl_->GetPeerCertificate();
     else
@@ -526,8 +526,8 @@
   rtc::KeyParams server_key_type_;
   SSLDummyStreamBase *client_stream_;  // freed by client_ssl_ destructor
   SSLDummyStreamBase *server_stream_;  // freed by server_ssl_ destructor
-  rtc::scoped_ptr<rtc::SSLStreamAdapter> client_ssl_;
-  rtc::scoped_ptr<rtc::SSLStreamAdapter> server_ssl_;
+  std::unique_ptr<rtc::SSLStreamAdapter> client_ssl_;
+  std::unique_ptr<rtc::SSLStreamAdapter> server_ssl_;
   rtc::SSLIdentity *client_identity_;  // freed by client_ssl_ destructor
   rtc::SSLIdentity *server_identity_;  // freed by server_ssl_ destructor
   int delay_;
@@ -1043,7 +1043,7 @@
   TestHandshake();
 
   // The client should have a peer certificate after the handshake.
-  rtc::scoped_ptr<rtc::SSLCertificate> client_peer_cert =
+  std::unique_ptr<rtc::SSLCertificate> client_peer_cert =
       GetPeerCertificate(true);
   ASSERT_TRUE(client_peer_cert);
 
@@ -1055,7 +1055,7 @@
   ASSERT_FALSE(client_peer_cert->GetChain());
 
   // The server should have a peer certificate after the handshake.
-  rtc::scoped_ptr<rtc::SSLCertificate> server_peer_cert =
+  std::unique_ptr<rtc::SSLCertificate> server_peer_cert =
       GetPeerCertificate(false);
   ASSERT_TRUE(server_peer_cert);
 
diff --git a/base/stream.h b/base/stream.h
index e624df5..2d76ee2 100644
--- a/base/stream.h
+++ b/base/stream.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_BASE_STREAM_H_
 #define WEBRTC_BASE_STREAM_H_
 
+#include <memory>
 #include <stdio.h>
 
 #include "webrtc/base/basictypes.h"
@@ -19,7 +20,6 @@
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/messagequeue.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
 
 namespace rtc {
@@ -334,7 +334,7 @@
                      int* error) override;
 
  private:
-  scoped_ptr<StreamInterface> tap_;
+  std::unique_ptr<StreamInterface> tap_;
   StreamResult tap_result_;
   int tap_error_;
   RTC_DISALLOW_COPY_AND_ASSIGN(StreamTap);
@@ -554,7 +554,7 @@
   // keeps the opened/closed state of the stream
   StreamState state_ GUARDED_BY(crit_);
   // the allocated buffer
-  scoped_ptr<char[]> buffer_ GUARDED_BY(crit_);
+  std::unique_ptr<char[]> buffer_ GUARDED_BY(crit_);
   // size of the allocated buffer
   size_t buffer_length_ GUARDED_BY(crit_);
   // amount of readable data in the buffer
diff --git a/base/task.h b/base/task.h
index 28702e4..b2a6067 100644
--- a/base/task.h
+++ b/base/task.h
@@ -13,7 +13,6 @@
 
 #include <string>
 #include "webrtc/base/basictypes.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/taskparent.h"
 
diff --git a/base/taskparent.h b/base/taskparent.h
index 41008fa..3c0b81c 100644
--- a/base/taskparent.h
+++ b/base/taskparent.h
@@ -11,10 +11,11 @@
 #ifndef WEBRTC_BASE_TASKPARENT_H__
 #define WEBRTC_BASE_TASKPARENT_H__
 
+#include <memory>
 #include <set>
 
 #include "webrtc/base/basictypes.h"
-#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/constructormagic.h"
 
 namespace rtc {
 
@@ -52,7 +53,7 @@
   TaskRunner *runner_;
   bool child_error_;
   typedef std::set<Task *> ChildSet;
-  scoped_ptr<ChildSet> children_;
+  std::unique_ptr<ChildSet> children_;
   RTC_DISALLOW_COPY_AND_ASSIGN(TaskParent);
 };
 
diff --git a/base/taskrunner.cc b/base/taskrunner.cc
index c50c9f8..73916a0 100644
--- a/base/taskrunner.cc
+++ b/base/taskrunner.cc
@@ -13,7 +13,6 @@
 #include "webrtc/base/taskrunner.h"
 
 #include "webrtc/base/common.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/task.h"
 #include "webrtc/base/logging.h"
 
diff --git a/base/testechoserver.h b/base/testechoserver.h
index 51d7d53..e87a63f 100644
--- a/base/testechoserver.h
+++ b/base/testechoserver.h
@@ -12,6 +12,7 @@
 #define WEBRTC_BASE_TESTECHOSERVER_H_
 
 #include <list>
+#include <memory>
 #include "webrtc/base/asynctcpsocket.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/sigslot.h"
@@ -63,7 +64,7 @@
   }
 
   typedef std::list<AsyncTCPSocket*> ClientList;
-  scoped_ptr<AsyncSocket> server_socket_;
+  std::unique_ptr<AsyncSocket> server_socket_;
   ClientList client_sockets_;
   RTC_DISALLOW_COPY_AND_ASSIGN(TestEchoServer);
 };
diff --git a/base/testutils.h b/base/testutils.h
index 6e7e22a..e5e571b 100644
--- a/base/testutils.h
+++ b/base/testutils.h
@@ -24,6 +24,7 @@
 
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <vector>
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/asyncsocket.h"
@@ -371,7 +372,7 @@
   void OnCloseEvent(AsyncSocket* socket, int error) {
   }
 
-  scoped_ptr<AsyncSocket> socket_;
+  std::unique_ptr<AsyncSocket> socket_;
   Buffer send_buffer_, recv_buffer_;
 };
 
@@ -414,7 +415,7 @@
     clients_.push_back(new SocketTestClient(accepted));
   }
 
-  scoped_ptr<AsyncSocket> socket_;
+  std::unique_ptr<AsyncSocket> socket_;
   std::vector<SocketTestClient*> clients_;
 };
 
diff --git a/base/thread_checker_unittest.cc b/base/thread_checker_unittest.cc
index 3381900..8fcaa7a 100644
--- a/base/thread_checker_unittest.cc
+++ b/base/thread_checker_unittest.cc
@@ -10,11 +10,12 @@
 
 // Borrowed from Chromium's src/base/threading/thread_checker_unittest.cc.
 
+#include <memory>
+
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/thread_checker.h"
-#include "webrtc/base/scoped_ptr.h"
 
 // Duplicated from base/threading/thread_checker.h so that we can be
 // good citizens there and undef the macro.
@@ -91,7 +92,7 @@
   }
 
  private:
-  scoped_ptr<ThreadCheckerClass> thread_checker_class_;
+  std::unique_ptr<ThreadCheckerClass> thread_checker_class_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(DeleteThreadCheckerClassOnThread);
 };
@@ -99,7 +100,7 @@
 }  // namespace
 
 TEST(ThreadCheckerTest, CallsAllowedOnSameThread) {
-  scoped_ptr<ThreadCheckerClass> thread_checker_class(
+  std::unique_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // Verify that DoStuff doesn't assert.
@@ -110,7 +111,7 @@
 }
 
 TEST(ThreadCheckerTest, DestructorAllowedOnDifferentThread) {
-  scoped_ptr<ThreadCheckerClass> thread_checker_class(
+  std::unique_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // Verify that the destructor doesn't assert
@@ -123,7 +124,7 @@
 }
 
 TEST(ThreadCheckerTest, DetachFromThread) {
-  scoped_ptr<ThreadCheckerClass> thread_checker_class(
+  std::unique_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // Verify that DoStuff doesn't assert when called on a different thread after
@@ -138,7 +139,7 @@
 #if GTEST_HAS_DEATH_TEST || !ENABLE_THREAD_CHECKER
 
 void ThreadCheckerClass::MethodOnDifferentThreadImpl() {
-  scoped_ptr<ThreadCheckerClass> thread_checker_class(
+  std::unique_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // DoStuff should assert in debug builds only when called on a
@@ -162,7 +163,7 @@
 #endif  // ENABLE_THREAD_CHECKER
 
 void ThreadCheckerClass::DetachThenCallFromDifferentThreadImpl() {
-  scoped_ptr<ThreadCheckerClass> thread_checker_class(
+  std::unique_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // DoStuff doesn't assert when called on a different thread
diff --git a/base/thread_unittest.cc b/base/thread_unittest.cc
index 7889e29..d733058 100644
--- a/base/thread_unittest.cc
+++ b/base/thread_unittest.cc
@@ -589,17 +589,18 @@
 
 // Functor for creating an invoker.
 struct CreateInvoker {
-  CreateInvoker(scoped_ptr<GuardedAsyncInvoker>* invoker) : invoker_(invoker) {}
+  CreateInvoker(std::unique_ptr<GuardedAsyncInvoker>* invoker)
+      : invoker_(invoker) {}
   void operator()() { invoker_->reset(new GuardedAsyncInvoker()); }
-  scoped_ptr<GuardedAsyncInvoker>* invoker_;
+  std::unique_ptr<GuardedAsyncInvoker>* invoker_;
 };
 
 // Test that we can call AsyncInvoke<void>() after the thread died.
 TEST_F(GuardedAsyncInvokeTest, KillThreadFireAndForget) {
   // Create and start the thread.
-  scoped_ptr<Thread> thread(new Thread());
+  std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
-  scoped_ptr<GuardedAsyncInvoker> invoker;
+  std::unique_ptr<GuardedAsyncInvoker> invoker;
   // Create the invoker on |thread|.
   thread->Invoke<void>(CreateInvoker(&invoker));
   // Kill |thread|.
@@ -615,9 +616,9 @@
 // Test that we can call AsyncInvoke with callback after the thread died.
 TEST_F(GuardedAsyncInvokeTest, KillThreadWithCallback) {
   // Create and start the thread.
-  scoped_ptr<Thread> thread(new Thread());
+  std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
-  scoped_ptr<GuardedAsyncInvoker> invoker;
+  std::unique_ptr<GuardedAsyncInvoker> invoker;
   // Create the invoker on |thread|.
   thread->Invoke<void>(CreateInvoker(&invoker));
   // Kill |thread|.
diff --git a/base/virtualsocket_unittest.cc b/base/virtualsocket_unittest.cc
index 2cd2b5e..bdbf06a 100644
--- a/base/virtualsocket_unittest.cc
+++ b/base/virtualsocket_unittest.cc
@@ -14,6 +14,8 @@
 #include <netinet/in.h>
 #endif
 
+#include <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/gunit.h"
@@ -63,7 +65,7 @@
   }
 
   Thread* thread;
-  scoped_ptr<AsyncUDPSocket> socket;
+  std::unique_ptr<AsyncUDPSocket> socket;
   rtc::PacketOptions options;
   bool done;
   uint32_t rate;  // bytes per second
@@ -123,7 +125,7 @@
   }
 
   Thread* thread;
-  scoped_ptr<AsyncUDPSocket> socket;
+  std::unique_ptr<AsyncUDPSocket> socket;
   uint32_t bandwidth;
   bool done;
   size_t count;
@@ -345,11 +347,11 @@
         EmptySocketAddressWithFamily(initial_addr.family());
 
     // Create client and server
-    scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(initial_addr.family(),
-                                                          SOCK_STREAM));
+    std::unique_ptr<AsyncSocket> client(
+        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(client.get());
-    scoped_ptr<AsyncSocket> server(ss_->CreateAsyncSocket(initial_addr.family(),
-                                                          SOCK_STREAM));
+    std::unique_ptr<AsyncSocket> server(
+        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(server.get());
 
     // Initiate connect
@@ -406,7 +408,7 @@
 
     // Server accepts connection
     EXPECT_TRUE(sink.Check(server.get(), testing::SSE_READ));
-    scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+    std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
     ASSERT_TRUE(NULL != accepted.get());
     sink.Monitor(accepted.get());
 
@@ -435,9 +437,8 @@
     a->Bind(initial_addr);
     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
 
-
-    scoped_ptr<AsyncSocket> b(ss_->CreateAsyncSocket(initial_addr.family(),
-                                                     SOCK_STREAM));
+    std::unique_ptr<AsyncSocket> b(
+        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(b.get());
     b->Bind(initial_addr);
     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
diff --git a/base/virtualsocketserver.cc b/base/virtualsocketserver.cc
index c6d402f..f5b7db7 100644
--- a/base/virtualsocketserver.cc
+++ b/base/virtualsocketserver.cc
@@ -15,6 +15,7 @@
 
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/checks.h"
@@ -771,7 +772,7 @@
   VirtualSocket* recipient = LookupBinding(remote_addr);
   if (!recipient) {
     // Make a fake recipient for address family checking.
-    scoped_ptr<VirtualSocket> dummy_socket(
+    std::unique_ptr<VirtualSocket> dummy_socket(
         CreateSocketInternal(AF_INET, SOCK_DGRAM));
     dummy_socket->SetLocalAddress(remote_addr);
     if (!CanInteractWith(socket, dummy_socket.get())) {
diff --git a/base/win32filesystem.cc b/base/win32filesystem.cc
index b731974..8457403 100644
--- a/base/win32filesystem.cc
+++ b/base/win32filesystem.cc
@@ -15,10 +15,11 @@
 #include <shlobj.h>
 #include <tchar.h>
 
+#include <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/pathutils.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringutils.h"
 
@@ -95,7 +96,7 @@
                               &token_user_size);
 
   // Get the TOKEN_USER structure.
-  scoped_ptr<char[]> token_user_bytes(new char[token_user_size]);
+  std::unique_ptr<char[]> token_user_bytes(new char[token_user_size]);
   PTOKEN_USER token_user = reinterpret_cast<PTOKEN_USER>(
       token_user_bytes.get());
   memset(token_user, 0, token_user_size);
@@ -121,7 +122,7 @@
       GetLengthSid(token_user->User.Sid);
 
   // Allocate it.
-  scoped_ptr<char[]> acl_bytes(new char[acl_size]);
+  std::unique_ptr<char[]> acl_bytes(new char[acl_size]);
   PACL acl = reinterpret_cast<PACL>(acl_bytes.get());
   memset(acl, 0, acl_size);
   if (!::InitializeAcl(acl, acl_size, ACL_REVISION)) {
@@ -425,7 +426,7 @@
 Pathname Win32Filesystem::GetCurrentDirectory() {
   Pathname cwd;
   int path_len = 0;
-  scoped_ptr<wchar_t[]> path;
+  std::unique_ptr<wchar_t[]> path;
   do {
     int needed = ::GetCurrentDirectory(path_len, path.get());
     if (needed == 0) {
diff --git a/base/win32regkey.cc b/base/win32regkey.cc
index c53386f..447086a 100644
--- a/base/win32regkey.cc
+++ b/base/win32regkey.cc
@@ -21,9 +21,10 @@
 
 #include <shlwapi.h>
 
+#include <memory>
+
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
@@ -146,7 +147,7 @@
   byte* buffer_raw = nullptr;
   HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
                                     REG_BINARY, &buffer_raw, &byte_count);
-  scoped_ptr<byte[]> buffer(buffer_raw);
+  std::unique_ptr<byte[]> buffer(buffer_raw);
   if (SUCCEEDED(hr)) {
     ASSERT(byte_count == sizeof(*value));
     if (byte_count == sizeof(*value)) {
@@ -166,7 +167,7 @@
   byte* buffer_raw = nullptr;
   HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
                                     REG_BINARY, &buffer_raw, &byte_count);
-  scoped_ptr<byte[]> buffer(buffer_raw);
+  std::unique_ptr<byte[]> buffer(buffer_raw);
   if (SUCCEEDED(hr)) {
     ASSERT(byte_count == sizeof(*value));
     if (byte_count == sizeof(*value)) {
@@ -193,7 +194,7 @@
 
   wchar_t* buffer_raw = nullptr;
   HRESULT hr = RegKey::GetValue(full_key_name, value_name, &buffer_raw);
-  scoped_ptr<wchar_t[]> buffer(buffer_raw);
+  std::unique_ptr<wchar_t[]> buffer(buffer_raw);
   if (SUCCEEDED(hr)) {
     value->assign(buffer.get());
   }
diff --git a/base/windowpicker_unittest.cc b/base/windowpicker_unittest.cc
index edd01bc..a125832 100644
--- a/base/windowpicker_unittest.cc
+++ b/base/windowpicker_unittest.cc
@@ -7,6 +7,8 @@
  *  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/base/gunit.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/window.h"
@@ -25,7 +27,7 @@
     LOG(LS_INFO) << "skipping test: window capturing is not supported with "
                  << "current configuration.";
   }
-  rtc::scoped_ptr<rtc::WindowPicker> picker(
+  std::unique_ptr<rtc::WindowPicker> picker(
       rtc::WindowPickerFactory::CreateWindowPicker());
   EXPECT_TRUE(picker->Init());
   rtc::WindowDescriptionList descriptions;
@@ -40,7 +42,7 @@
     LOG(LS_INFO) << "skipping test: window capturing is not supported with "
                  << "current configuration.";
   }
-  rtc::scoped_ptr<rtc::WindowPicker> picker(
+  std::unique_ptr<rtc::WindowPicker> picker(
       rtc::WindowPickerFactory::CreateWindowPicker());
   EXPECT_TRUE(picker->Init());
   rtc::DesktopDescriptionList descriptions;
diff --git a/base/x11windowpicker.h b/base/x11windowpicker.h
index 501adf5..d741759 100644
--- a/base/x11windowpicker.h
+++ b/base/x11windowpicker.h
@@ -11,8 +11,9 @@
 #ifndef WEBRTC_BASE_LINUXWINDOWPICKER_H_
 #define WEBRTC_BASE_LINUXWINDOWPICKER_H_
 
+#include <memory>
+
 #include "webrtc/base/basictypes.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/windowpicker.h"
 
 // Avoid include <X11/Xlib.h>.
@@ -44,7 +45,7 @@
   uint8_t* GetDesktopThumbnail(const DesktopId& id, int width, int height);
 
  private:
-  scoped_ptr<XWindowEnumerator> enumerator_;
+  std::unique_ptr<XWindowEnumerator> enumerator_;
 };
 
 }  // namespace rtc
diff --git a/p2p/base/dtlstransportchannel.cc b/p2p/base/dtlstransportchannel.cc
index 88a1192..f9baa37 100644
--- a/p2p/base/dtlstransportchannel.cc
+++ b/p2p/base/dtlstransportchannel.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <utility>
 
 #include "webrtc/p2p/base/dtlstransportchannel.h"
@@ -250,7 +251,7 @@
   return true;
 }
 
-rtc::scoped_ptr<rtc::SSLCertificate>
+std::unique_ptr<rtc::SSLCertificate>
 DtlsTransportChannelWrapper::GetRemoteSSLCertificate() const {
   if (!dtls_) {
     return nullptr;
diff --git a/p2p/base/dtlstransportchannel.h b/p2p/base/dtlstransportchannel.h
index b6c3cfd..08dd04c 100644
--- a/p2p/base/dtlstransportchannel.h
+++ b/p2p/base/dtlstransportchannel.h
@@ -11,13 +11,13 @@
 #ifndef WEBRTC_P2P_BASE_DTLSTRANSPORTCHANNEL_H_
 #define WEBRTC_P2P_BASE_DTLSTRANSPORTCHANNEL_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/bufferqueue.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stream.h"
 
@@ -137,7 +137,7 @@
 
   // Once DTLS has been established, this method retrieves the certificate in
   // use by the remote peer, for use in external identity verification.
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate() const override;
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate() const override;
 
   // Once DTLS has established (i.e., this channel is writable), this method
   // extracts the keys negotiated during the DTLS handshake, for use in external
@@ -226,7 +226,7 @@
   rtc::Thread* worker_thread_;  // Everything should occur on this thread.
   // Underlying channel, not owned by this class.
   TransportChannelImpl* const channel_;
-  rtc::scoped_ptr<rtc::SSLStreamAdapter> dtls_;  // The DTLS stream
+  std::unique_ptr<rtc::SSLStreamAdapter> dtls_;  // The DTLS stream
   StreamInterfaceChannel* downward_;  // Wrapper for channel_, owned by dtls_.
   std::vector<int> srtp_ciphers_;     // SRTP ciphers to use with DTLS.
   bool dtls_active_ = false;
diff --git a/p2p/base/dtlstransportchannel_unittest.cc b/p2p/base/dtlstransportchannel_unittest.cc
index 7643016..2c97ac6 100644
--- a/p2p/base/dtlstransportchannel_unittest.cc
+++ b/p2p/base/dtlstransportchannel_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <set>
 
 #include "webrtc/p2p/base/dtlstransport.h"
@@ -16,7 +17,6 @@
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/sslstreamadapter.h"
@@ -54,7 +54,7 @@
         received_dtls_server_hello_(false) {}
   void CreateCertificate(rtc::KeyType key_type) {
     certificate_ =
-        rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+        rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, key_type)));
   }
   const rtc::scoped_refptr<rtc::RTCCertificate>& certificate() {
@@ -122,8 +122,8 @@
                  ConnectionRole local_role,
                  ConnectionRole remote_role,
                  int flags) {
-    rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint;
-    rtc::scoped_ptr<rtc::SSLFingerprint> remote_fingerprint;
+    std::unique_ptr<rtc::SSLFingerprint> local_fingerprint;
+    std::unique_ptr<rtc::SSLFingerprint> remote_fingerprint;
     if (local_cert) {
       std::string digest_algorithm;
       ASSERT_TRUE(local_cert->ssl_certificate().GetSignatureDigestAlgorithm(
@@ -248,7 +248,7 @@
 
   void SendPackets(size_t channel, size_t size, size_t count, bool srtp) {
     ASSERT(channel < channels_.size());
-    rtc::scoped_ptr<char[]> packet(new char[size]);
+    std::unique_ptr<char[]> packet(new char[size]);
     size_t sent = 0;
     do {
       // Fill the packet with a known value and a sequence number to check
@@ -272,7 +272,7 @@
 
   int SendInvalidSrtpPacket(size_t channel, size_t size) {
     ASSERT(channel < channels_.size());
-    rtc::scoped_ptr<char[]> packet(new char[size]);
+    std::unique_ptr<char[]> packet(new char[size]);
     // Fill the packet with 0 to form an invalid SRTP packet.
     memset(packet.get(), 0, size);
 
@@ -379,7 +379,7 @@
  private:
   std::string name_;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
-  rtc::scoped_ptr<cricket::FakeTransport> transport_;
+  std::unique_ptr<cricket::FakeTransport> transport_;
   std::vector<cricket::DtlsTransportChannelWrapper*> channels_;
   size_t packet_size_;
   std::set<int> received_;
@@ -846,8 +846,8 @@
 
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2;
-  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert1;
-  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert2;
+  std::unique_ptr<rtc::SSLCertificate> remote_cert1;
+  std::unique_ptr<rtc::SSLCertificate> remote_cert2;
 
   // After negotiation, each side has a distinct local certificate, but still no
   // remote certificate, because connection has not yet occurred.
@@ -875,12 +875,12 @@
             certificate2->ssl_certificate().ToPEMString());
 
   // Each side's remote certificate is the other side's local certificate.
-  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert1 =
+  std::unique_ptr<rtc::SSLCertificate> remote_cert1 =
       client1_.transport()->GetRemoteSSLCertificate();
   ASSERT_TRUE(remote_cert1);
   ASSERT_EQ(remote_cert1->ToPEMString(),
             certificate2->ssl_certificate().ToPEMString());
-  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert2 =
+  std::unique_ptr<rtc::SSLCertificate> remote_cert2 =
       client2_.transport()->GetRemoteSSLCertificate();
   ASSERT_TRUE(remote_cert2);
   ASSERT_EQ(remote_cert2->ToPEMString(),
diff --git a/p2p/base/faketransportcontroller.h b/p2p/base/faketransportcontroller.h
index 394e6dd..c099c8c 100644
--- a/p2p/base/faketransportcontroller.h
+++ b/p2p/base/faketransportcontroller.h
@@ -12,6 +12,7 @@
 #define WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -260,9 +261,9 @@
     return local_cert_;
   }
 
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
       const override {
-    return remote_cert_ ? rtc::scoped_ptr<rtc::SSLCertificate>(
+    return remote_cert_ ? std::unique_ptr<rtc::SSLCertificate>(
                               remote_cert_->GetReference())
                         : nullptr;
   }
diff --git a/p2p/base/p2ptransportchannel.h b/p2p/base/p2ptransportchannel.h
index 4a53d75..56f3555 100644
--- a/p2p/base/p2ptransportchannel.h
+++ b/p2p/base/p2ptransportchannel.h
@@ -144,7 +144,7 @@
     return nullptr;
   }
 
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
       const override {
     return nullptr;
   }
diff --git a/p2p/base/packetsocketfactory.h b/p2p/base/packetsocketfactory.h
index 5403724..290d9ca 100644
--- a/p2p/base/packetsocketfactory.h
+++ b/p2p/base/packetsocketfactory.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_P2P_BASE_PACKETSOCKETFACTORY_H_
 #define WEBRTC_P2P_BASE_PACKETSOCKETFACTORY_H_
 
+#include "webrtc/base/constructormagic.h"
 #include "webrtc/base/proxyinfo.h"
 
 namespace rtc {
diff --git a/p2p/base/transport.cc b/p2p/base/transport.cc
index f523502..89f05e8 100644
--- a/p2p/base/transport.cc
+++ b/p2p/base/transport.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <utility>  // for std::pair
 
 #include "webrtc/p2p/base/transport.h"
@@ -77,7 +78,7 @@
   }
 }
 
-rtc::scoped_ptr<rtc::SSLCertificate> Transport::GetRemoteSSLCertificate() {
+std::unique_ptr<rtc::SSLCertificate> Transport::GetRemoteSSLCertificate() {
   if (channels_.empty()) {
     return nullptr;
   }
diff --git a/p2p/base/transport.h b/p2p/base/transport.h
index 8b30127..559d437 100644
--- a/p2p/base/transport.h
+++ b/p2p/base/transport.h
@@ -26,6 +26,7 @@
 #define WEBRTC_P2P_BASE_TRANSPORT_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 #include "webrtc/p2p/base/candidate.h"
@@ -214,7 +215,7 @@
   }
 
   // Get a copy of the remote certificate in use by the specified channel.
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate();
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate();
 
   // Create, destroy, and lookup the channels of this type by their components.
   TransportChannelImpl* CreateChannel(int component);
@@ -333,8 +334,8 @@
   uint64_t tiebreaker_ = 0;
   IceMode remote_ice_mode_ = ICEMODE_FULL;
   IceConfig ice_config_;
-  rtc::scoped_ptr<TransportDescription> local_description_;
-  rtc::scoped_ptr<TransportDescription> remote_description_;
+  std::unique_ptr<TransportDescription> local_description_;
+  std::unique_ptr<TransportDescription> remote_description_;
   bool local_description_set_ = false;
   bool remote_description_set_ = false;
 
diff --git a/p2p/base/transportchannel.h b/p2p/base/transportchannel.h
index 24f90e3..333ca87 100644
--- a/p2p/base/transportchannel.h
+++ b/p2p/base/transportchannel.h
@@ -11,6 +11,7 @@
 #ifndef WEBRTC_P2P_BASE_TRANSPORTCHANNEL_H_
 #define WEBRTC_P2P_BASE_TRANSPORTCHANNEL_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -130,7 +131,7 @@
   GetLocalCertificate() const = 0;
 
   // Gets a copy of the remote side's SSL certificate.
-  virtual rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+  virtual std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
       const = 0;
 
   // Allows key material to be extracted for external encryption.
diff --git a/p2p/base/transportcontroller.cc b/p2p/base/transportcontroller.cc
index 708c60f..24f6481 100644
--- a/p2p/base/transportcontroller.cc
+++ b/p2p/base/transportcontroller.cc
@@ -11,6 +11,7 @@
 #include "webrtc/p2p/base/transportcontroller.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
@@ -86,10 +87,10 @@
                 transport_name, certificate));
 }
 
-rtc::scoped_ptr<rtc::SSLCertificate>
+std::unique_ptr<rtc::SSLCertificate>
 TransportController::GetRemoteSSLCertificate(
     const std::string& transport_name) {
-  return worker_thread_->Invoke<rtc::scoped_ptr<rtc::SSLCertificate>>(rtc::Bind(
+  return worker_thread_->Invoke<std::unique_ptr<rtc::SSLCertificate>>(rtc::Bind(
       &TransportController::GetRemoteSSLCertificate_w, this, transport_name));
 }
 
@@ -394,7 +395,7 @@
   return t->GetLocalCertificate(certificate);
 }
 
-rtc::scoped_ptr<rtc::SSLCertificate>
+std::unique_ptr<rtc::SSLCertificate>
 TransportController::GetRemoteSSLCertificate_w(
     const std::string& transport_name) {
   RTC_DCHECK(worker_thread_->IsCurrent());
diff --git a/p2p/base/transportcontroller.h b/p2p/base/transportcontroller.h
index 9d06823..8cb5986 100644
--- a/p2p/base/transportcontroller.h
+++ b/p2p/base/transportcontroller.h
@@ -12,6 +12,7 @@
 #define WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -59,7 +60,7 @@
       const std::string& transport_name,
       rtc::scoped_refptr<rtc::RTCCertificate>* certificate);
   // Caller owns returned certificate
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
       const std::string& transport_name);
   bool SetLocalTransportDescription(const std::string& transport_name,
                                     const TransportDescription& tdesc,
@@ -166,7 +167,7 @@
   bool GetLocalCertificate_w(
       const std::string& transport_name,
       rtc::scoped_refptr<rtc::RTCCertificate>* certificate);
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate_w(
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate_w(
       const std::string& transport_name);
   bool SetLocalTransportDescription_w(const std::string& transport_name,
                                       const TransportDescription& tdesc,
diff --git a/p2p/base/transportcontroller_unittest.cc b/p2p/base/transportcontroller_unittest.cc
index c90fd70..e8e6f5f 100644
--- a/p2p/base/transportcontroller_unittest.cc
+++ b/p2p/base/transportcontroller_unittest.cc
@@ -9,11 +9,11 @@
  */
 
 #include <map>
+#include <memory>
 
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/p2p/base/dtlstransportchannel.h"
@@ -177,8 +177,8 @@
     ++candidates_signal_count_;
   }
 
-  rtc::scoped_ptr<rtc::Thread> worker_thread_;  // Not used for most tests.
-  rtc::scoped_ptr<TransportControllerForTest> transport_controller_;
+  std::unique_ptr<rtc::Thread> worker_thread_;  // Not used for most tests.
+  std::unique_ptr<TransportControllerForTest> transport_controller_;
 
   // Information received from signals from transport controller.
   IceConnectionState connection_state_ = cricket::kIceConnectionConnecting;
@@ -269,10 +269,10 @@
 
 TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1 =
-      rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+      rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session1", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2 =
-      rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+      rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session2", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> returned_certificate;
 
@@ -308,7 +308,7 @@
   ASSERT_NE(nullptr, channel);
 
   channel->SetRemoteSSLCertificate(&fake_certificate);
-  rtc::scoped_ptr<rtc::SSLCertificate> returned_certificate =
+  std::unique_ptr<rtc::SSLCertificate> returned_certificate =
       transport_controller_->GetRemoteSSLCertificate("audio");
   EXPECT_TRUE(returned_certificate);
   EXPECT_EQ(fake_certificate.ToPEMString(),
diff --git a/p2p/base/transportdescriptionfactory_unittest.cc b/p2p/base/transportdescriptionfactory_unittest.cc
index 765c607..38675ba 100644
--- a/p2p/base/transportdescriptionfactory_unittest.cc
+++ b/p2p/base/transportdescriptionfactory_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -18,7 +19,6 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/ssladapter.h"
 
-using rtc::scoped_ptr;
 using cricket::TransportDescriptionFactory;
 using cricket::TransportDescription;
 using cricket::TransportOptions;
@@ -26,10 +26,10 @@
 class TransportDescriptionFactoryTest : public testing::Test {
  public:
   TransportDescriptionFactoryTest()
-      : cert1_(rtc::RTCCertificate::Create(
-            scoped_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("User1")))),
-        cert2_(rtc::RTCCertificate::Create(
-            scoped_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("User2")))) {}
+      : cert1_(rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
+            new rtc::FakeSSLIdentity("User1")))),
+        cert2_(rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
+            new rtc::FakeSSLIdentity("User2")))) {}
 
   void CheckDesc(const TransportDescription* desc,
                  const std::string& opt, const std::string& ice_ufrag,
@@ -71,22 +71,20 @@
 
     cricket::TransportOptions options;
     // The initial offer / answer exchange.
-    rtc::scoped_ptr<TransportDescription> offer(f1_.CreateOffer(
-        options, NULL));
-    rtc::scoped_ptr<TransportDescription> answer(
-        f2_.CreateAnswer(offer.get(),
-                         options, NULL));
+    std::unique_ptr<TransportDescription> offer(f1_.CreateOffer(options, NULL));
+    std::unique_ptr<TransportDescription> answer(
+        f2_.CreateAnswer(offer.get(), options, NULL));
 
     // Create an updated offer where we restart ice.
     options.ice_restart = true;
-    rtc::scoped_ptr<TransportDescription> restart_offer(f1_.CreateOffer(
-        options, offer.get()));
+    std::unique_ptr<TransportDescription> restart_offer(
+        f1_.CreateOffer(options, offer.get()));
 
     VerifyUfragAndPasswordChanged(dtls, offer.get(), restart_offer.get());
 
     // Create a new answer. The transport ufrag and password is changed since
     // |options.ice_restart == true|
-    rtc::scoped_ptr<TransportDescription> restart_answer(
+    std::unique_ptr<TransportDescription> restart_answer(
         f2_.CreateAnswer(restart_offer.get(), options, answer.get()));
     ASSERT_TRUE(restart_answer.get() != NULL);
 
@@ -120,8 +118,8 @@
 };
 
 TEST_F(TransportDescriptionFactoryTest, TestOfferDefault) {
-  scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
-      TransportOptions(), NULL));
+  std::unique_ptr<TransportDescription> desc(
+      f1_.CreateOffer(TransportOptions(), NULL));
   CheckDesc(desc.get(), "", "", "", "");
 }
 
@@ -131,8 +129,8 @@
   std::string digest_alg;
   ASSERT_TRUE(cert1_->ssl_certificate().GetSignatureDigestAlgorithm(
       &digest_alg));
-  scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
-      TransportOptions(), NULL));
+  std::unique_ptr<TransportDescription> desc(
+      f1_.CreateOffer(TransportOptions(), NULL));
   CheckDesc(desc.get(), "", "", "", digest_alg);
   // Ensure it also works with SEC_REQUIRED.
   f1_.set_secure(cricket::SEC_REQUIRED);
@@ -143,8 +141,8 @@
 // Test generating an offer with DTLS fails with no identity.
 TEST_F(TransportDescriptionFactoryTest, TestOfferDtlsWithNoIdentity) {
   f1_.set_secure(cricket::SEC_ENABLED);
-  scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
-      TransportOptions(), NULL));
+  std::unique_ptr<TransportDescription> desc(
+      f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(desc.get() == NULL);
 }
 
@@ -156,21 +154,21 @@
   std::string digest_alg;
   ASSERT_TRUE(cert1_->ssl_certificate().GetSignatureDigestAlgorithm(
       &digest_alg));
-  scoped_ptr<TransportDescription> old_desc(f1_.CreateOffer(
-      TransportOptions(), NULL));
+  std::unique_ptr<TransportDescription> old_desc(
+      f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(old_desc.get() != NULL);
-  scoped_ptr<TransportDescription> desc(
+  std::unique_ptr<TransportDescription> desc(
       f1_.CreateOffer(TransportOptions(), old_desc.get()));
   CheckDesc(desc.get(), "",
             old_desc->ice_ufrag, old_desc->ice_pwd, digest_alg);
 }
 
 TEST_F(TransportDescriptionFactoryTest, TestAnswerDefault) {
-  scoped_ptr<TransportDescription> offer(f1_.CreateOffer(
-      TransportOptions(), NULL));
+  std::unique_ptr<TransportDescription> offer(
+      f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  scoped_ptr<TransportDescription> desc(f2_.CreateAnswer(
-      offer.get(), TransportOptions(), NULL));
+  std::unique_ptr<TransportDescription> desc(
+      f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), "", "", "", "");
   desc.reset(f2_.CreateAnswer(offer.get(), TransportOptions(),
                               NULL));
@@ -179,15 +177,14 @@
 
 // Test that we can update an answer properly; ICE credentials shouldn't change.
 TEST_F(TransportDescriptionFactoryTest, TestReanswer) {
-  scoped_ptr<TransportDescription> offer(
+  std::unique_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  scoped_ptr<TransportDescription> old_desc(
+  std::unique_ptr<TransportDescription> old_desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   ASSERT_TRUE(old_desc.get() != NULL);
-  scoped_ptr<TransportDescription> desc(
-      f2_.CreateAnswer(offer.get(), TransportOptions(),
-                       old_desc.get()));
+  std::unique_ptr<TransportDescription> desc(
+      f2_.CreateAnswer(offer.get(), TransportOptions(), old_desc.get()));
   ASSERT_TRUE(desc.get() != NULL);
   CheckDesc(desc.get(), "",
             old_desc->ice_ufrag, old_desc->ice_pwd, "");
@@ -197,10 +194,10 @@
 TEST_F(TransportDescriptionFactoryTest, TestAnswerDtlsToNoDtls) {
   f1_.set_secure(cricket::SEC_ENABLED);
   f1_.set_certificate(cert1_);
-  scoped_ptr<TransportDescription> offer(
+  std::unique_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  scoped_ptr<TransportDescription> desc(
+  std::unique_ptr<TransportDescription> desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), "", "", "", "");
 }
@@ -210,10 +207,10 @@
 TEST_F(TransportDescriptionFactoryTest, TestAnswerNoDtlsToDtls) {
   f2_.set_secure(cricket::SEC_ENABLED);
   f2_.set_certificate(cert2_);
-  scoped_ptr<TransportDescription> offer(
+  std::unique_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  scoped_ptr<TransportDescription> desc(
+  std::unique_ptr<TransportDescription> desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), "", "", "", "");
   f2_.set_secure(cricket::SEC_REQUIRED);
@@ -236,10 +233,10 @@
   ASSERT_TRUE(cert2_->ssl_certificate().GetSignatureDigestAlgorithm(
       &digest_alg2));
 
-  scoped_ptr<TransportDescription> offer(
+  std::unique_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  scoped_ptr<TransportDescription> desc(
+  std::unique_ptr<TransportDescription> desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), "", "", "", digest_alg2);
   f2_.set_secure(cricket::SEC_REQUIRED);
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 867b5b3..6039065 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -162,13 +162,13 @@
     if (flags1 & DTLS) {
       // Confirmed to work with KT_RSA and KT_ECDSA.
       transport_controller1_.SetLocalCertificate(
-          rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+          rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
               rtc::SSLIdentity::Generate("session1", rtc::KT_DEFAULT))));
     }
     if (flags2 & DTLS) {
       // Confirmed to work with KT_RSA and KT_ECDSA.
       transport_controller2_.SetLocalCertificate(
-          rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+          rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
               rtc::SSLIdentity::Generate("session2", rtc::KT_DEFAULT))));
     }
 
@@ -981,7 +981,7 @@
     uint16_t local_net_id = 1;
     uint16_t remote_net_id = 2;
     int last_packet_id = 100;
-    rtc::scoped_ptr<cricket::CandidatePairInterface> candidate_pair(
+    std::unique_ptr<cricket::CandidatePairInterface> candidate_pair(
         transport_controller1_.CreateFakeCandidatePair(
             local_address, local_net_id, remote_address, remote_net_id));
     transport_channel1->SignalSelectedCandidatePairChanged(
diff --git a/pc/mediasession_unittest.cc b/pc/mediasession_unittest.cc
index aac6eac..2747502 100644
--- a/pc/mediasession_unittest.cc
+++ b/pc/mediasession_unittest.cc
@@ -212,9 +212,9 @@
     f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2));
     f2_.set_data_codecs(MAKE_VECTOR(kDataCodecs2));
     tdf1_.set_certificate(rtc::RTCCertificate::Create(
-        rtc::scoped_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id1"))));
+        std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id1"))));
     tdf2_.set_certificate(rtc::RTCCertificate::Create(
-        rtc::scoped_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id2"))));
+        std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id2"))));
   }
 
   // Create a video StreamParamsVec object with:
diff --git a/system_wrappers/source/event_timer_posix.h b/system_wrappers/source/event_timer_posix.h
index af3715e..599eb55 100644
--- a/system_wrappers/source/event_timer_posix.h
+++ b/system_wrappers/source/event_timer_posix.h
@@ -13,6 +13,8 @@
 
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 
+#include <memory>
+
 #include <pthread.h>
 #include <time.h>
 
@@ -49,9 +51,9 @@
   pthread_mutex_t mutex_;
   bool event_set_;
 
-  // TODO(pbos): Remove scoped_ptr and use PlatformThread directly.
-  rtc::scoped_ptr<rtc::PlatformThread> timer_thread_;
-  rtc::scoped_ptr<EventTimerPosix> timer_event_;
+  // TODO(pbos): Remove unique_ptr and use PlatformThread directly.
+  std::unique_ptr<rtc::PlatformThread> timer_thread_;
+  std::unique_ptr<EventTimerPosix> timer_event_;
   timespec       created_at_;
 
   bool          periodic_;