Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/peerconnectioninterface_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "webrtc/api/audiotrack.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/mediastream.h"
 #include "webrtc/api/mediastreaminterface.h"
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/rtpreceiverinterface.h"
 #include "webrtc/api/rtpsenderinterface.h"
 #include "webrtc/api/streamcollection.h"
 #ifdef WEBRTC_ANDROID
 #include "webrtc/api/test/androidtestinitializer.h"
 #endif
 #include "webrtc/api/test/fakeconstraints.h"
 #include "webrtc/api/test/fakedtlsidentitystore.h"
 #include "webrtc/api/test/fakevideotracksource.h"
 #include "webrtc/api/test/mockpeerconnectionobservers.h"
 #include "webrtc/api/test/testsdpstrings.h"
 #include "webrtc/api/videocapturertracksource.h"
 #include "webrtc/api/videotrack.h"
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/media/base/fakevideocapturer.h"
 #include "webrtc/media/sctp/sctpdataengine.h"
 #include "webrtc/p2p/client/fakeportallocator.h"
 #include "webrtc/pc/mediasession.h"
 
 static const char kStreamLabel1[] = "local_stream_1";
@@ skipping 186 matching lines @@
 static const char kSdpStringMs1Video1[] =
     "a=ssrc:4 cname:stream1\r\n"
     "a=ssrc:4 msid:stream1 videotrack1\r\n";
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(feature())) {                               \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
-using rtc::scoped_ptr;
 using rtc::scoped_refptr;
 using ::testing::Exactly;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrack;
 using webrtc::AudioTrackInterface;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInterface;
 using webrtc::FakeConstraints;
 using webrtc::IceCandidateInterface;
 using webrtc::MediaConstraintsInterface;
@@ skipping 244 matching lines @@
     return "";
   }
   std::string GetLastRemovedStreamLabel() {
     if (last_removed_stream_.get())
       return last_removed_stream_->label();
     return "";
   }
 
   scoped_refptr<PeerConnectionInterface> pc_;
   PeerConnectionInterface::SignalingState state_;
-  scoped_ptr<IceCandidateInterface> last_candidate_;
+  std::unique_ptr<IceCandidateInterface> last_candidate_;
   scoped_refptr<DataChannelInterface> last_datachannel_;
   rtc::scoped_refptr<StreamCollection> remote_streams_;
   bool renegotiation_needed_ = false;
   bool ice_complete_ = false;
 
  private:
   scoped_refptr<MediaStreamInterface> last_added_stream_;
   scoped_refptr<MediaStreamInterface> last_removed_stream_;
 };
 
@@ skipping 26 matching lines @@
                             const std::string& password,
                             webrtc::MediaConstraintsInterface* constraints) {
     PeerConnectionInterface::RTCConfiguration config;
     PeerConnectionInterface::IceServer server;
     if (!uri.empty()) {
       server.uri = uri;
       server.password = password;
       config.servers.push_back(server);
     }
 
-    rtc::scoped_ptr<cricket::FakePortAllocator> port_allocator(
+    std::unique_ptr<cricket::FakePortAllocator> port_allocator(
         new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr));
     port_allocator_ = port_allocator.get();
 
     // DTLS does not work in a loopback call, so is disabled for most of the
     // tests in this file. We only create a FakeIdentityService if the test
     // explicitly sets the constraint.
     FakeConstraints default_constraints;
     if (!constraints) {
       constraints = &default_constraints;
 
       default_constraints.AddMandatory(
           webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, false);
     }
 
-    scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store;
+    std::unique_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store;
     bool dtls;
     if (FindConstraint(constraints,
                        webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                        &dtls,
                        nullptr) && dtls) {
       dtls_identity_store.reset(new FakeDtlsIdentityStore());
     }
     pc_ = pc_factory_->CreatePeerConnection(
         config, constraints, std::move(port_allocator),
         std::move(dtls_identity_store), &observer_);
@@ skipping 81 matching lines @@
     scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(
             video_track_label,
             pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
-  bool DoCreateOfferAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
+  bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
                            bool offer,
                            MediaConstraintsInterface* constraints) {
     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (offer) {
       pc_->CreateOffer(observer, constraints);
     } else {
       pc_->CreateAnswer(observer, constraints);
     }
     EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
     desc->reset(observer->release_desc());
     return observer->result();
   }
 
-  bool DoCreateOffer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
+  bool DoCreateOffer(std::unique_ptr<SessionDescriptionInterface>* desc,
                      MediaConstraintsInterface* constraints) {
     return DoCreateOfferAnswer(desc, true, constraints);
   }
 
-  bool DoCreateAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
+  bool DoCreateAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
                       MediaConstraintsInterface* constraints) {
     return DoCreateOfferAnswer(desc, false, constraints);
   }
 
   bool DoSetSessionDescription(SessionDescriptionInterface* desc, bool local) {
     rtc::scoped_refptr<MockSetSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockSetSessionDescriptionObserver>());
     if (local) {
       pc_->SetLocalDescription(observer, desc);
@@ skipping 40 matching lines @@
     ASSERT_TRUE(desc != NULL);
     EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
 
     desc = cricket::GetFirstVideoContentDescription(
         pc_->remote_description()->description());
     ASSERT_TRUE(desc != NULL);
     EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
   }
 
   void CreateOfferAsRemoteDescription() {
-    rtc::scoped_ptr<SessionDescriptionInterface> offer;
+    std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     SessionDescriptionInterface* remote_offer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                          sdp, NULL);
     EXPECT_TRUE(DoSetRemoteDescription(remote_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAndSetRemoteOffer(const std::string& sdp) {
     SessionDescriptionInterface* remote_offer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                          sdp, nullptr);
     EXPECT_TRUE(DoSetRemoteDescription(remote_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAnswerAsLocalDescription() {
-    scoped_ptr<SessionDescriptionInterface> answer;
+    std::unique_ptr<SessionDescriptionInterface> answer;
     ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
 
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
     // receiving. Not all parameters are serialized to SDP.
     // Since CreatePrAnswerAsLocalDescription serialize/deserialize
     // the SessionDescription, it is necessary to do that here to in order to
     // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
     // https://code.google.com/p/webrtc/issues/detail?id=1356
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     SessionDescriptionInterface* new_answer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer,
                                          sdp, NULL);
     EXPECT_TRUE(DoSetLocalDescription(new_answer));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   void CreatePrAnswerAsLocalDescription() {
-    scoped_ptr<SessionDescriptionInterface> answer;
+    std::unique_ptr<SessionDescriptionInterface> answer;
     ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
 
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     SessionDescriptionInterface* pr_answer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kPrAnswer,
                                          sdp, NULL);
     EXPECT_TRUE(DoSetLocalDescription(pr_answer));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
   }
 
   void CreateOfferReceiveAnswer() {
     CreateOfferAsLocalDescription();
     std::string sdp;
     EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
     CreateAnswerAsRemoteDescription(sdp);
   }
 
   void CreateOfferAsLocalDescription() {
-    rtc::scoped_ptr<SessionDescriptionInterface> offer;
+    std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
     // receiving. Not all parameters are serialized to SDP.
     // Since CreatePrAnswerAsLocalDescription serialize/deserialize
     // the SessionDescription, it is necessary to do that here to in order to
     // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
     // https://code.google.com/p/webrtc/issues/detail?id=1356
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
@@ skipping 49 matching lines @@
     EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
     SetSsrcToZero(&sdp);
     CreateAnswerAsRemoteDescription(sdp);
   }
 
   // This function creates a MediaStream with label kStreams[0] and
   // |number_of_audio_tracks| and |number_of_video_tracks| tracks and the
   // corresponding SessionDescriptionInterface. The SessionDescriptionInterface
   // is returned and the MediaStream is stored in
   // |reference_collection_|
-  rtc::scoped_ptr<SessionDescriptionInterface>
+  std::unique_ptr<SessionDescriptionInterface>
   CreateSessionDescriptionAndReference(size_t number_of_audio_tracks,
                                        size_t number_of_video_tracks) {
     EXPECT_LE(number_of_audio_tracks, 2u);
     EXPECT_LE(number_of_video_tracks, 2u);
 
     reference_collection_ = StreamCollection::Create();
     std::string sdp_ms1 = std::string(kSdpStringInit);
 
     std::string mediastream_label = kStreams[0];
 
@@ skipping 14 matching lines @@
     if (number_of_video_tracks > 0) {
       sdp_ms1 += std::string(kSdpStringVideo);
       sdp_ms1 += std::string(kSdpStringMs1Video0);
       AddVideoTrack(kVideoTracks[0], stream);
     }
     if (number_of_video_tracks > 1) {
       sdp_ms1 += kSdpStringMs1Video1;
       AddVideoTrack(kVideoTracks[1], stream);
     }
 
-    return rtc::scoped_ptr<SessionDescriptionInterface>(
+    return std::unique_ptr<SessionDescriptionInterface>(
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                          sdp_ms1, nullptr));
   }
 
   void AddAudioTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         webrtc::AudioTrack::Create(track_id, nullptr));
     ASSERT_TRUE(stream->AddTrack(audio_track));
   }
@@ skipping 44 matching lines @@
 
   // Remove the first stream.
   pc_->RemoveStream(pc_->local_streams()->at(0));
   EXPECT_EQ(0u, pc_->local_streams()->count());
 }
 
 // Test that the created offer includes streams we added.
 TEST_F(PeerConnectionInterfaceTest, AddedStreamsPresentInOffer) {
   CreatePeerConnection();
   AddAudioVideoStream(kStreamLabel1, "audio_track", "video_track");
-  scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::ContentInfo* audio_content =
       cricket::GetFirstAudioContent(offer->description());
   const cricket::AudioContentDescription* audio_desc =
       static_cast<const cricket::AudioContentDescription*>(
           audio_content->description);
   EXPECT_TRUE(
       ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track"));
 
@@ skipping 54 matching lines @@
   auto audio_sender = pc_->AddTrack(audio_track, stream_list);
   auto video_sender = pc_->AddTrack(video_track, stream_list);
   EXPECT_EQ(kStreamLabel1, audio_sender->stream_id());
   EXPECT_EQ("audio_track", audio_sender->id());
   EXPECT_EQ(audio_track, audio_sender->track());
   EXPECT_EQ(kStreamLabel1, video_sender->stream_id());
   EXPECT_EQ("video_track", video_sender->id());
   EXPECT_EQ(video_track, video_sender->track());
 
   // Now create an offer and check for the senders.
-  scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::ContentInfo* audio_content =
       cricket::GetFirstAudioContent(offer->description());
   const cricket::AudioContentDescription* audio_desc =
       static_cast<const cricket::AudioContentDescription*>(
           audio_content->description);
   EXPECT_TRUE(
       ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track"));
 
@@ skipping 117 matching lines @@
   CreateOfferReceiveAnswer();
   EXPECT_EQ(0u, pc_->remote_streams()->count());
 }
 
 // Test that candidates are generated and that we can parse our own candidates.
 TEST_F(PeerConnectionInterfaceTest, IceCandidates) {
   CreatePeerConnection();
 
   EXPECT_FALSE(pc_->AddIceCandidate(observer_.last_candidate_.get()));
   // SetRemoteDescription takes ownership of offer.
-  rtc::scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   AddVideoStream(kStreamLabel1);
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
   EXPECT_TRUE(DoSetRemoteDescription(offer.release()));
 
   // SetLocalDescription takes ownership of answer.
-  rtc::scoped_ptr<SessionDescriptionInterface> answer;
+  std::unique_ptr<SessionDescriptionInterface> answer;
   EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
   EXPECT_TRUE(DoSetLocalDescription(answer.release()));
 
   EXPECT_TRUE_WAIT(observer_.last_candidate_.get() != NULL, kTimeout);
   EXPECT_TRUE_WAIT(observer_.ice_complete_, kTimeout);
 
   EXPECT_TRUE(pc_->AddIceCandidate(observer_.last_candidate_.get()));
 }
 
 // Test that CreateOffer and CreateAnswer will fail if the track labels are
 // not unique.
 TEST_F(PeerConnectionInterfaceTest, CreateOfferAnswerWithInvalidStream) {
   CreatePeerConnection();
   // Create a regular offer for the CreateAnswer test later.
-  rtc::scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
   EXPECT_TRUE(offer);
   offer.reset();
 
   // Create a local stream with audio&video tracks having same label.
   AddAudioVideoStream(kStreamLabel1, "track_label", "track_label");
 
   // Test CreateOffer
   EXPECT_FALSE(DoCreateOffer(&offer, nullptr));
 
   // Test CreateAnswer
-  rtc::scoped_ptr<SessionDescriptionInterface> answer;
+  std::unique_ptr<SessionDescriptionInterface> answer;
   EXPECT_FALSE(DoCreateAnswer(&answer, nullptr));
 }
 
 // Test that we will get different SSRCs for each tracks in the offer and answer
 // we created.
 TEST_F(PeerConnectionInterfaceTest, SsrcInOfferAnswer) {
   CreatePeerConnection();
   // Create a local stream with audio&video tracks having different labels.
   AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
 
   // Test CreateOffer
-  scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
   int audio_ssrc = 0;
   int video_ssrc = 0;
   EXPECT_TRUE(GetFirstSsrc(GetFirstAudioContent(offer->description()),
                            &audio_ssrc));
   EXPECT_TRUE(GetFirstSsrc(GetFirstVideoContent(offer->description()),
                            &video_ssrc));
   EXPECT_NE(audio_ssrc, video_ssrc);
 
   // Test CreateAnswer
   EXPECT_TRUE(DoSetRemoteDescription(offer.release()));
-  scoped_ptr<SessionDescriptionInterface> answer;
+  std::unique_ptr<SessionDescriptionInterface> answer;
   ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
   audio_ssrc = 0;
   video_ssrc = 0;
   EXPECT_TRUE(GetFirstSsrc(GetFirstAudioContent(answer->description()),
                            &audio_ssrc));
   EXPECT_TRUE(GetFirstSsrc(GetFirstVideoContent(answer->description()),
                            &video_ssrc));
   EXPECT_NE(audio_ssrc, video_ssrc);
 }
 
 // Test that it's possible to call AddTrack on a MediaStream after adding
 // the stream to a PeerConnection.
 // TODO(deadbeef): Remove this test once this behavior is no longer supported.
 TEST_F(PeerConnectionInterfaceTest, AddTrackAfterAddStream) {
   CreatePeerConnection();
   // Create audio stream and add to PeerConnection.
   AddVoiceStream(kStreamLabel1);
   MediaStreamInterface* stream = pc_->local_streams()->at(0);
 
   // Add video track to the audio-only stream.
   scoped_refptr<VideoTrackInterface> video_track(pc_factory_->CreateVideoTrack(
       "video_label",
       pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   stream->AddTrack(video_track.get());
 
-  scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   EXPECT_TRUE(video_desc != nullptr);
 }
 
 // Test that it's possible to call RemoveTrack on a MediaStream after adding
 // the stream to a PeerConnection.
 // TODO(deadbeef): Remove this test once this behavior is no longer supported.
 TEST_F(PeerConnectionInterfaceTest, RemoveTrackAfterAddStream) {
   CreatePeerConnection();
   // Create audio/video stream and add to PeerConnection.
   AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
   MediaStreamInterface* stream = pc_->local_streams()->at(0);
 
   // Remove the video track.
   stream->RemoveTrack(stream->GetVideoTracks()[0]);
 
-  scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   EXPECT_TRUE(video_desc == nullptr);
 }
 
 // Test creating a sender with a stream ID, and ensure the ID is populated
 // in the offer.
 TEST_F(PeerConnectionInterfaceTest, CreateSenderWithStream) {
   CreatePeerConnection();
   pc_->CreateSender("video", kStreamLabel1);
 
-  scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   ASSERT_TRUE(video_desc != nullptr);
   ASSERT_EQ(1u, video_desc->streams().size());
   EXPECT_EQ(kStreamLabel1, video_desc->streams()[0].sync_label);
 }
 
 // Test that we can specify a certain track that we want statistics about.
@@ skipping 42 matching lines @@
 // This test setup two RTP data channels in loop back.
 TEST_F(PeerConnectionInterfaceTest, TestDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
   scoped_refptr<DataChannelInterface> data1  =
       pc_->CreateDataChannel("test1", NULL);
   scoped_refptr<DataChannelInterface> data2  =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
-  rtc::scoped_ptr<MockDataChannelObserver> observer1(
+  std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
-  rtc::scoped_ptr<MockDataChannelObserver> observer2(
+  std::unique_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   EXPECT_EQ(DataChannelInterface::kConnecting, data1->state());
   EXPECT_EQ(DataChannelInterface::kConnecting, data2->state());
   std::string data_to_send1 = "testing testing";
   std::string data_to_send2 = "testing something else";
   EXPECT_FALSE(data1->Send(DataBuffer(data_to_send1)));
 
   CreateOfferReceiveAnswer();
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
@@ skipping 24 matching lines @@
 // fail.
 TEST_F(PeerConnectionInterfaceTest, TestSendBinaryOnRtpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
   scoped_refptr<DataChannelInterface> data1  =
       pc_->CreateDataChannel("test1", NULL);
   scoped_refptr<DataChannelInterface> data2  =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
-  rtc::scoped_ptr<MockDataChannelObserver> observer1(
+  std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
-  rtc::scoped_ptr<MockDataChannelObserver> observer2(
+  std::unique_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   EXPECT_EQ(DataChannelInterface::kConnecting, data1->state());
   EXPECT_EQ(DataChannelInterface::kConnecting, data2->state());
 
   CreateOfferReceiveAnswer();
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
   EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout);
 
   EXPECT_EQ(DataChannelInterface::kOpen, data1->state());
   EXPECT_EQ(DataChannelInterface::kOpen, data2->state());
 
   rtc::CopyOnWriteBuffer buffer("test", 4);
   EXPECT_FALSE(data1->Send(DataBuffer(buffer, true)));
 }
 
 // This test setup a RTP data channels in loop back and test that a channel is
 // opened even if the remote end answer with a zero SSRC.
 TEST_F(PeerConnectionInterfaceTest, TestSendOnlyDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
   scoped_refptr<DataChannelInterface> data1  =
       pc_->CreateDataChannel("test1", NULL);
-  rtc::scoped_ptr<MockDataChannelObserver> observer1(
+  std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
 
   CreateOfferReceiveAnswerWithoutSsrc();
 
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
 
   data1->Close();
   EXPECT_EQ(DataChannelInterface::kClosing, data1->state());
   CreateOfferReceiveAnswerWithoutSsrc();
   EXPECT_EQ(DataChannelInterface::kClosed, data1->state());
@@ skipping 194 matching lines @@
 TEST_F(PeerConnectionInterfaceTest, DataChannelCloseWhenPeerConnectionClose) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   scoped_refptr<DataChannelInterface> data1  =
       pc_->CreateDataChannel("test1", NULL);
   scoped_refptr<DataChannelInterface> data2  =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
-  rtc::scoped_ptr<MockDataChannelObserver> observer1(
+  std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
-  rtc::scoped_ptr<MockDataChannelObserver> observer2(
+  std::unique_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   CreateOfferReceiveAnswer();
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
   EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout);
 
   ReleasePeerConnection();
   EXPECT_EQ(DataChannelInterface::kClosed, data1->state());
   EXPECT_EQ(DataChannelInterface::kClosed, data2->state());
 }
@@ skipping 84 matching lines @@
 TEST_F(PeerConnectionInterfaceTest, CreateSubsequentRecvOnlyOffer) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
   CreateAnswerAsLocalDescription();
 
   // At this point we should be receiving stream 1, but not sending anything.
   // A new offer should be recvonly.
-  rtc::scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   DoCreateOffer(&offer, nullptr);
 
   const cricket::ContentInfo* video_content =
       cricket::GetFirstVideoContent(offer->description());
   const cricket::VideoContentDescription* video_desc =
       static_cast<const cricket::VideoContentDescription*>(
           video_content->description);
   ASSERT_EQ(cricket::MD_RECVONLY, video_desc->direction());
 
   const cricket::ContentInfo* audio_content =
@@ skipping 11 matching lines @@
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
   CreateAnswerAsLocalDescription();
 
   // At this point we should be receiving stream 1, but not sending anything.
   // A new offer would be recvonly, but we'll set the "no receive" constraints
   // to make it inactive.
-  rtc::scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   FakeConstraints offer_constraints;
   offer_constraints.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveVideo, false);
   offer_constraints.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveAudio, false);
   DoCreateOffer(&offer, &offer_constraints);
 
   const cricket::ContentInfo* video_content =
       cricket::GetFirstVideoContent(offer->description());
   const cricket::VideoContentDescription* video_desc =
@@ skipping 74 matching lines @@
   ASSERT_FALSE(local_stream->GetAudioTracks().empty());
   rtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender(
       pc_->CreateDtmfSender(local_stream->GetAudioTracks()[0]));
   EXPECT_TRUE(NULL == dtmf_sender);  // local stream has been removed.
 
   EXPECT_TRUE(pc_->CreateDataChannel("test", NULL) == NULL);
 
   EXPECT_TRUE(pc_->local_description() != NULL);
   EXPECT_TRUE(pc_->remote_description() != NULL);
 
-  rtc::scoped_ptr<SessionDescriptionInterface> offer;
+  std::unique_ptr<SessionDescriptionInterface> offer;
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
-  rtc::scoped_ptr<SessionDescriptionInterface> answer;
+  std::unique_ptr<SessionDescriptionInterface> answer;
   EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
 
   std::string sdp;
   ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
   SessionDescriptionInterface* remote_offer =
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        sdp, NULL);
   EXPECT_FALSE(DoSetRemoteDescription(remote_offer));
 
   ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
@@ skipping 40 matching lines @@
 }
 
 // This test verifies that when remote tracks are added/removed from SDP, the
 // created remote streams are updated appropriately.
 TEST_F(PeerConnectionInterfaceTest,
        AddRemoveTrackFromExistingRemoteMediaStream) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1 =
+  std::unique_ptr<SessionDescriptionInterface> desc_ms1 =
       CreateSessionDescriptionAndReference(1, 1);
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms1.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
 
   // Add extra audio and video tracks to the same MediaStream.
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1_two_tracks =
+  std::unique_ptr<SessionDescriptionInterface> desc_ms1_two_tracks =
       CreateSessionDescriptionAndReference(2, 2);
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms1_two_tracks.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
   scoped_refptr<AudioTrackInterface> audio_track2 =
       observer_.remote_streams()->at(0)->GetAudioTracks()[1];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state());
   scoped_refptr<VideoTrackInterface> video_track2 =
       observer_.remote_streams()->at(0)->GetVideoTracks()[1];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track2->state());
 
   // Remove the extra audio and video tracks.
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms2 =
+  std::unique_ptr<SessionDescriptionInterface> desc_ms2 =
       CreateSessionDescriptionAndReference(1, 1);
   MockTrackObserver audio_track_observer(audio_track2);
   MockTrackObserver video_track_observer(video_track2);
 
   EXPECT_CALL(audio_track_observer, OnChanged()).Times(Exactly(1));
   EXPECT_CALL(video_track_observer, OnChanged()).Times(Exactly(1));
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms2.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
   // Track state may be updated asynchronously.
@@ skipping 18 matching lines @@
   ASSERT_EQ(1u, remote_stream->GetVideoTracks().size());
   ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
 
   rtc::scoped_refptr<webrtc::VideoTrackInterface> remote_video =
       remote_stream->GetVideoTracks()[0];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_video->state());
   rtc::scoped_refptr<webrtc::AudioTrackInterface> remote_audio =
       remote_stream->GetAudioTracks()[0];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> local_answer;
+  std::unique_ptr<SessionDescriptionInterface> local_answer;
   EXPECT_TRUE(DoCreateAnswer(&local_answer, nullptr));
   cricket::ContentInfo* video_info =
       local_answer->description()->GetContentByName("video");
   video_info->rejected = true;
   EXPECT_TRUE(DoSetLocalDescription(local_answer.release()));
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, remote_video->state());
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
 
   // Now create an offer where we reject both video and audio.
-  rtc::scoped_ptr<SessionDescriptionInterface> local_offer;
+  std::unique_ptr<SessionDescriptionInterface> local_offer;
   EXPECT_TRUE(DoCreateOffer(&local_offer, nullptr));
   video_info = local_offer->description()->GetContentByName("video");
   ASSERT_TRUE(video_info != nullptr);
   video_info->rejected = true;
   cricket::ContentInfo* audio_info =
       local_offer->description()->GetContentByName("audio");
   ASSERT_TRUE(audio_info != nullptr);
   audio_info->rejected = true;
   EXPECT_TRUE(DoSetLocalDescription(local_offer.release()));
   // Track state may be updated asynchronously.
   EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
                  remote_audio->state(), kTimeout);
   EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
                  remote_video->state(), kTimeout);
 }
 
 // This tests that we won't crash if the remote track has been removed outside
 // of PeerConnection and then PeerConnection tries to reject the track.
 TEST_F(PeerConnectionInterfaceTest, RemoveTrackThenRejectMediaContent) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
   MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
   remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
   remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
 
-  rtc::scoped_ptr<SessionDescriptionInterface> local_answer(
+  std::unique_ptr<SessionDescriptionInterface> local_answer(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer,
                                        kSdpStringWithStream1, nullptr));
   cricket::ContentInfo* video_info =
       local_answer->description()->GetContentByName("video");
   video_info->rejected = true;
   cricket::ContentInfo* audio_info =
       local_answer->description()->GetContentByName("audio");
   audio_info->rejected = true;
   EXPECT_TRUE(DoSetLocalDescription(local_answer.release()));
 
@@ skipping 153 matching lines @@
 // after adding a local stream.
 // TODO(deadbeef): This test and the one below it need to be updated when
 // an RtpSender's lifetime isn't determined by when a local description is set.
 TEST_F(PeerConnectionInterfaceTest, LocalDescriptionChanged) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
-  rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
+  std::unique_ptr<SessionDescriptionInterface> throwaway;
   ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_1 =
+  std::unique_ptr<SessionDescriptionInterface> desc_1 =
       CreateSessionDescriptionAndReference(2, 2);
 
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc_1.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(4u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
 
   // Remove an audio and video track.
   pc_->RemoveStream(reference_collection_->at(0));
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_2 =
+  std::unique_ptr<SessionDescriptionInterface> desc_2 =
       CreateSessionDescriptionAndReference(1, 1);
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc_2.release()));
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_FALSE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_FALSE(ContainsSender(senders, kVideoTracks[1]));
 }
 
 // This tests that an RtpSender is created when the local description is set
 // before adding a local stream.
 TEST_F(PeerConnectionInterfaceTest,
        AddLocalStreamAfterLocalDescriptionChanged) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
-  rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
+  std::unique_ptr<SessionDescriptionInterface> throwaway;
   ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_1 =
+  std::unique_ptr<SessionDescriptionInterface> desc_1 =
       CreateSessionDescriptionAndReference(2, 2);
 
   EXPECT_TRUE(DoSetLocalDescription(desc_1.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(0u, senders.size());
 
   pc_->AddStream(reference_collection_->at(0));
   senders = pc_->GetSenders();
   EXPECT_EQ(4u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
 }
 
 // This tests that the expected behavior occurs if the SSRC on a local track is
 // changed when SetLocalDescription is called.
 TEST_F(PeerConnectionInterfaceTest,
        ChangeSsrcOnTrackInLocalSessionDescription) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
-  rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
+  std::unique_ptr<SessionDescriptionInterface> throwaway;
   ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc =
+  std::unique_ptr<SessionDescriptionInterface> desc =
       CreateSessionDescriptionAndReference(1, 1);
   std::string sdp;
   desc->ToString(&sdp);
 
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 
   // Change the ssrc of the audio and video track.
   std::string ssrc_org = "a=ssrc:1";
   std::string ssrc_to = "a=ssrc:97";
   rtc::replace_substrs(ssrc_org.c_str(), ssrc_org.length(), ssrc_to.c_str(),
                        ssrc_to.length(), &sdp);
   ssrc_org = "a=ssrc:2";
   ssrc_to = "a=ssrc:98";
   rtc::replace_substrs(ssrc_org.c_str(), ssrc_org.length(), ssrc_to.c_str(),
                        ssrc_to.length(), &sdp);
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_desc(
+  std::unique_ptr<SessionDescriptionInterface> updated_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, sdp,
                                        nullptr));
 
   EXPECT_TRUE(DoSetLocalDescription(updated_desc.release()));
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   // TODO(deadbeef): Once RtpSenders expose parameters, check that the SSRC
   // changed.
 }
 
 // This tests that the expected behavior occurs if a new session description is
 // set with the same tracks, but on a different MediaStream.
 TEST_F(PeerConnectionInterfaceTest,
        SignalSameTracksInSeparateMediaStream) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
-  rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
+  std::unique_ptr<SessionDescriptionInterface> throwaway;
   ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc =
+  std::unique_ptr<SessionDescriptionInterface> desc =
       CreateSessionDescriptionAndReference(1, 1);
   std::string sdp;
   desc->ToString(&sdp);
 
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 
   // Add a new MediaStream but with the same tracks as in the first stream.
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
       webrtc::MediaStream::Create(kStreams[1]));
   stream_1->AddTrack(reference_collection_->at(0)->GetVideoTracks()[0]);
   stream_1->AddTrack(reference_collection_->at(0)->GetAudioTracks()[0]);
   pc_->AddStream(stream_1);
 
   // Replace msid in the original SDP.
   rtc::replace_substrs(kStreams[0], strlen(kStreams[0]), kStreams[1],
                        strlen(kStreams[1]), &sdp);
 
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_desc(
+  std::unique_ptr<SessionDescriptionInterface> updated_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, sdp,
                                        nullptr));
 
   EXPECT_TRUE(DoSetLocalDescription(updated_desc.release()));
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 }
 
@@ skipping 276 matching lines @@
   FakeConstraints updated_answer_c;
   answer_c.SetMandatoryReceiveAudio(false);
   answer_c.SetMandatoryReceiveVideo(false);
 
   cricket::MediaSessionOptions updated_answer_options;
   EXPECT_TRUE(
       ParseConstraintsForAnswer(&updated_answer_c, &updated_answer_options));
   EXPECT_TRUE(updated_answer_options.has_audio());
   EXPECT_TRUE(updated_answer_options.has_video());
 }