Modified PeerConnection and WebRtcSession for end-to-end QuicDataChannel usage.

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.
  */
 
@@ skipping 224 matching lines @@
     "a=ssrc:4 msid:stream1 videotrack1\r\n";
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(feature())) {                               \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
 using ::testing::Exactly;
 using cricket::StreamParams;
-using rtc::scoped_refptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrack;
 using webrtc::AudioTrackInterface;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInterface;
 using webrtc::FakeConstraints;
 using webrtc::IceCandidateInterface;
 using webrtc::JsepSessionDescription;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStream;
@@ skipping 272 matching lines @@
     if (last_added_stream_.get())
       return last_added_stream_->label();
     return "";
   }
   std::string GetLastRemovedStreamLabel() {
     if (last_removed_stream_.get())
       return last_removed_stream_->label();
     return "";
   }
 
-  scoped_refptr<PeerConnectionInterface> pc_;
+  rtc::scoped_refptr<PeerConnectionInterface> pc_;
   PeerConnectionInterface::SignalingState state_;
   std::unique_ptr<IceCandidateInterface> last_candidate_;
-  scoped_refptr<DataChannelInterface> last_datachannel_;
+  rtc::scoped_refptr<DataChannelInterface> last_datachannel_;
   rtc::scoped_refptr<StreamCollection> remote_streams_;
   bool renegotiation_needed_ = false;
   bool ice_complete_ = false;
   bool callback_triggered = false;
 
  private:
-  scoped_refptr<MediaStreamInterface> last_added_stream_;
-  scoped_refptr<MediaStreamInterface> last_removed_stream_;
+  rtc::scoped_refptr<MediaStreamInterface> last_added_stream_;
+  rtc::scoped_refptr<MediaStreamInterface> last_removed_stream_;
 };
 
 }  // namespace
 
 // The PeerConnectionMediaConfig tests below verify that configuration
 // and constraints are propagated into the MediaConfig passed to
 // CreateMediaController. These settings are intended for MediaChannel
 // constructors, but that is not exercised by these unittest.
 class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
  public:
@@ skipping 97 matching lines @@
     observer_.SetPeerConnectionInterface(pc_.get());
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   void CreatePeerConnectionExpectFail(const std::string& uri) {
     PeerConnectionInterface::RTCConfiguration config;
     PeerConnectionInterface::IceServer server;
     server.uri = uri;
     config.servers.push_back(server);
 
-    scoped_refptr<PeerConnectionInterface> pc;
+    rtc::scoped_refptr<PeerConnectionInterface> pc;
     pc = pc_factory_->CreatePeerConnection(config, nullptr, nullptr, nullptr,
                                            &observer_);
     EXPECT_EQ(nullptr, pc);
   }
 
   void CreatePeerConnectionWithDifferentConfigurations() {
     CreatePeerConnectionWithIceServer(kStunAddressOnly, "");
     EXPECT_EQ(1u, port_allocator_->stun_servers().size());
     EXPECT_EQ(0u, port_allocator_->turn_servers().size());
     EXPECT_EQ("address", port_allocator_->stun_servers().begin()->hostname());
@@ skipping 15 matching lines @@
               port_allocator_->turn_servers()[0].ports[0].address.hostname());
   }
 
   void ReleasePeerConnection() {
     pc_ = NULL;
     observer_.SetPeerConnectionInterface(NULL);
   }
 
   void AddVideoStream(const std::string& label) {
     // Create a local stream.
-    scoped_refptr<MediaStreamInterface> stream(
+    rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
-    scoped_refptr<VideoTrackSourceInterface> video_source(
+    rtc::scoped_refptr<VideoTrackSourceInterface> video_source(
         pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer(), NULL));
-    scoped_refptr<VideoTrackInterface> video_track(
+    rtc::scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(label + "v0", video_source));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
   void AddVoiceStream(const std::string& label) {
     // Create a local stream.
-    scoped_refptr<MediaStreamInterface> stream(
+    rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
-    scoped_refptr<AudioTrackInterface> audio_track(
+    rtc::scoped_refptr<AudioTrackInterface> audio_track(
         pc_factory_->CreateAudioTrack(label + "a0", NULL));
     stream->AddTrack(audio_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
   void AddAudioVideoStream(const std::string& stream_label,
                            const std::string& audio_track_label,
                            const std::string& video_track_label) {
     // Create a local stream.
-    scoped_refptr<MediaStreamInterface> stream(
+    rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(stream_label));
-    scoped_refptr<AudioTrackInterface> audio_track(
+    rtc::scoped_refptr<AudioTrackInterface> audio_track(
         pc_factory_->CreateAudioTrack(
             audio_track_label, static_cast<AudioSourceInterface*>(NULL)));
     stream->AddTrack(audio_track.get());
-    scoped_refptr<VideoTrackInterface> video_track(
+    rtc::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(std::unique_ptr<SessionDescriptionInterface>* desc,
@@ skipping 287 matching lines @@
       const SessionDescriptionInterface* desc) {
     const cricket::ContentInfo* audio_content =
         cricket::GetFirstAudioContent(desc->description());
     const cricket::AudioContentDescription* audio_desc =
         static_cast<const cricket::AudioContentDescription*>(
             audio_content->description);
     return audio_desc->streams()[0].cname;
   }
 
   cricket::FakePortAllocator* port_allocator_ = nullptr;
-  scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
-  scoped_refptr<PeerConnectionFactoryForTest> pc_factory_for_test_;
-  scoped_refptr<PeerConnectionInterface> pc_;
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
+  rtc::scoped_refptr<PeerConnectionFactoryForTest> pc_factory_for_test_;
+  rtc::scoped_refptr<PeerConnectionInterface> pc_;
   MockPeerConnectionObserver observer_;
   rtc::scoped_refptr<StreamCollection> reference_collection_;
 };
 
 // Test that no callbacks on the PeerConnectionObserver are called after the
 // PeerConnection is closed.
 TEST_F(PeerConnectionInterfaceTest, CloseAndTestCallbackFunctions) {
-  scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       pc_factory_for_test_->CreatePeerConnection(
           PeerConnectionInterface::RTCConfiguration(), nullptr, nullptr,
           nullptr, &observer_));
   observer_.SetPeerConnectionInterface(pc.get());
   pc->Close();
 
   // No callbacks is expected to be called.
   observer_.callback_triggered = false;
   std::vector<cricket::Candidate> candidates;
   pc_factory_for_test_->transport_controller->SignalGatheringState(
@@ skipping 97 matching lines @@
   EXPECT_TRUE(raw_port_allocator->initialized());
 }
 
 TEST_F(PeerConnectionInterfaceTest, AddStreams) {
   CreatePeerConnection();
   AddVideoStream(kStreamLabel1);
   AddVoiceStream(kStreamLabel2);
   ASSERT_EQ(2u, pc_->local_streams()->count());
 
   // Test we can add multiple local streams to one peerconnection.
-  scoped_refptr<MediaStreamInterface> stream(
+  rtc::scoped_refptr<MediaStreamInterface> stream(
       pc_factory_->CreateLocalMediaStream(kStreamLabel3));
-  scoped_refptr<AudioTrackInterface> audio_track(
-      pc_factory_->CreateAudioTrack(
-          kStreamLabel3, static_cast<AudioSourceInterface*>(NULL)));
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      pc_factory_->CreateAudioTrack(kStreamLabel3,
+                                    static_cast<AudioSourceInterface*>(NULL)));
   stream->AddTrack(audio_track.get());
   EXPECT_TRUE(pc_->AddStream(stream));
   EXPECT_EQ(3u, pc_->local_streams()->count());
 
   // Remove the third stream.
   pc_->RemoveStream(pc_->local_streams()->at(2));
   EXPECT_EQ(2u, pc_->local_streams()->count());
 
   // Remove the second stream.
   pc_->RemoveStream(pc_->local_streams()->at(1));
@@ skipping 57 matching lines @@
   EXPECT_EQ(0u, pc_->local_streams()->count());
 }
 
 // Test for AddTrack and RemoveTrack methods.
 // Tests that the created offer includes tracks we added,
 // and that the RtpSenders are created correctly.
 // Also tests that RemoveTrack removes the tracks from subsequent offers.
 TEST_F(PeerConnectionInterfaceTest, AddTrackRemoveTrack) {
   CreatePeerConnection();
   // Create a dummy stream, so tracks share a stream label.
-  scoped_refptr<MediaStreamInterface> stream(
+  rtc::scoped_refptr<MediaStreamInterface> stream(
       pc_factory_->CreateLocalMediaStream(kStreamLabel1));
   std::vector<MediaStreamInterface*> stream_list;
   stream_list.push_back(stream.get());
-  scoped_refptr<AudioTrackInterface> audio_track(
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
       pc_factory_->CreateAudioTrack("audio_track", nullptr));
-  scoped_refptr<VideoTrackInterface> video_track(pc_factory_->CreateVideoTrack(
-      "video_track",
-      pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      pc_factory_->CreateVideoTrack(
+          "video_track",
+          pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   auto audio_sender = pc_->AddTrack(audio_track, stream_list);
   auto video_sender = pc_->AddTrack(video_track, stream_list);
   EXPECT_EQ(1UL, audio_sender->stream_ids().size());
   EXPECT_EQ(kStreamLabel1, audio_sender->stream_ids()[0]);
   EXPECT_EQ("audio_track", audio_sender->id());
   EXPECT_EQ(audio_track, audio_sender->track());
   EXPECT_EQ(1UL, video_sender->stream_ids().size());
   EXPECT_EQ(kStreamLabel1, video_sender->stream_ids()[0]);
   EXPECT_EQ("video_track", video_sender->id());
   EXPECT_EQ(video_track, video_sender->track());
@@ skipping 45 matching lines @@
   // should return false.
   EXPECT_FALSE(pc_->RemoveTrack(audio_sender));
   EXPECT_FALSE(pc_->RemoveTrack(video_sender));
 }
 
 // Test creating senders without a stream specified,
 // expecting a random stream ID to be generated.
 TEST_F(PeerConnectionInterfaceTest, AddTrackWithoutStream) {
   CreatePeerConnection();
   // Create a dummy stream, so tracks share a stream label.
-  scoped_refptr<AudioTrackInterface> audio_track(
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
       pc_factory_->CreateAudioTrack("audio_track", nullptr));
-  scoped_refptr<VideoTrackInterface> video_track(pc_factory_->CreateVideoTrack(
-      "video_track",
-      pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      pc_factory_->CreateVideoTrack(
+          "video_track",
+          pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   auto audio_sender =
       pc_->AddTrack(audio_track, std::vector<MediaStreamInterface*>());
   auto video_sender =
       pc_->AddTrack(video_track, std::vector<MediaStreamInterface*>());
   EXPECT_EQ("audio_track", audio_sender->id());
   EXPECT_EQ(audio_track, audio_sender->track());
   EXPECT_EQ("video_track", video_sender->id());
   EXPECT_EQ(video_track, video_sender->track());
   // If the ID is truly a random GUID, it should be infinitely unlikely they
   // will be the same.
@@ skipping 138 matching lines @@
 // 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())));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      pc_factory_->CreateVideoTrack(
+          "video_label",
+          pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   stream->AddTrack(video_track.get());
 
   std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   EXPECT_TRUE(video_desc != nullptr);
 }
 
@@ skipping 31 matching lines @@
   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.
 TEST_F(PeerConnectionInterfaceTest, GetStatsForSpecificTrack) {
   InitiateCall();
   ASSERT_LT(0u, pc_->remote_streams()->count());
   ASSERT_LT(0u, pc_->remote_streams()->at(0)->GetAudioTracks().size());
-  scoped_refptr<MediaStreamTrackInterface> remote_audio =
+  rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
       pc_->remote_streams()->at(0)->GetAudioTracks()[0];
   EXPECT_TRUE(DoGetStats(remote_audio));
 
   // Remove the stream. Since we are sending to our selves the local
   // and the remote stream is the same.
   pc_->RemoveStream(pc_->local_streams()->at(0));
   // Do a re-negotiation.
   CreateOfferReceiveAnswer();
 
   ASSERT_EQ(0u, pc_->remote_streams()->count());
 
   // Test that we still can get statistics for the old track. Even if it is not
   // sent any longer.
   EXPECT_TRUE(DoGetStats(remote_audio));
 }
 
 // Test that we can get stats on a video track.
 TEST_F(PeerConnectionInterfaceTest, GetStatsForVideoTrack) {
   InitiateCall();
   ASSERT_LT(0u, pc_->remote_streams()->count());
   ASSERT_LT(0u, pc_->remote_streams()->at(0)->GetVideoTracks().size());
-  scoped_refptr<MediaStreamTrackInterface> remote_video =
+  rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
       pc_->remote_streams()->at(0)->GetVideoTracks()[0];
   EXPECT_TRUE(DoGetStats(remote_video));
 }
 
 // Test that we don't get statistics for an invalid track.
 // TODO(tommi): Fix this test.  DoGetStats will return true
 // for the unknown track (since GetStats is async), but no
 // data is returned for the track.
 TEST_F(PeerConnectionInterfaceTest, DISABLED_GetStatsForInvalidTrack) {
   InitiateCall();
-  scoped_refptr<AudioTrackInterface> unknown_audio_track(
+  rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track(
       pc_factory_->CreateAudioTrack("unknown track", NULL));
   EXPECT_FALSE(DoGetStats(unknown_audio_track));
 }
 
 // This test setup two RTP data channels in loop back.
 TEST_F(PeerConnectionInterfaceTest, TestDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
-  scoped_refptr<DataChannelInterface> data1  =
+  rtc::scoped_refptr<DataChannelInterface> data1 =
       pc_->CreateDataChannel("test1", NULL);
-  scoped_refptr<DataChannelInterface> data2  =
+  rtc::scoped_refptr<DataChannelInterface> data2 =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
   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";
@@ skipping 24 matching lines @@
 
   EXPECT_EQ_WAIT(data_to_send2, observer2->last_message(), kTimeout);
 }
 
 // This test verifies that sendnig binary data over RTP data channels should
 // fail.
 TEST_F(PeerConnectionInterfaceTest, TestSendBinaryOnRtpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
-  scoped_refptr<DataChannelInterface> data1  =
+  rtc::scoped_refptr<DataChannelInterface> data1 =
       pc_->CreateDataChannel("test1", NULL);
-  scoped_refptr<DataChannelInterface> data2  =
+  rtc::scoped_refptr<DataChannelInterface> data2 =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
   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  =
+  rtc::scoped_refptr<DataChannelInterface> data1 =
       pc_->CreateDataChannel("test1", NULL);
   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());
   EXPECT_FALSE(observer1->IsOpen());
 }
 
 // This test that if a data channel is added in an answer a receive only channel
 // channel is created.
 TEST_F(PeerConnectionInterfaceTest, TestReceiveOnlyDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string offer_label = "offer_channel";
-  scoped_refptr<DataChannelInterface> offer_channel  =
+  rtc::scoped_refptr<DataChannelInterface> offer_channel =
       pc_->CreateDataChannel(offer_label, NULL);
 
   CreateOfferAsLocalDescription();
 
   // Replace the data channel label in the offer and apply it as an answer.
   std::string receive_label = "answer_channel";
   std::string sdp;
   EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
   rtc::replace_substrs(offer_label.c_str(), offer_label.length(),
                              receive_label.c_str(), receive_label.length(),
@@ skipping 22 matching lines @@
 // requested.
 // TODO(perkj): Remove this test once reliable channels are implemented.
 TEST_F(PeerConnectionInterfaceTest, CreateReliableRtpDataChannelShouldFail) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
   webrtc::DataChannelInit config;
   config.reliable = true;
-  scoped_refptr<DataChannelInterface> channel  =
+  rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, &config);
   EXPECT_TRUE(channel == NULL);
 }
 
 // Verifies that duplicated label is not allowed for RTP data channel.
 TEST_F(PeerConnectionInterfaceTest, RtpDuplicatedLabelNotAllowed) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
-  scoped_refptr<DataChannelInterface> channel =
+  rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_NE(channel, nullptr);
 
-  scoped_refptr<DataChannelInterface> dup_channel =
+  rtc::scoped_refptr<DataChannelInterface> dup_channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_EQ(dup_channel, nullptr);
 }
 
 // This tests that a SCTP data channel is returned using different
 // DataChannelInit configurations.
 TEST_F(PeerConnectionInterfaceTest, CreateSctpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowDtlsSctpDataChannels();
   CreatePeerConnection(&constraints);
 
   webrtc::DataChannelInit config;
 
-  scoped_refptr<DataChannelInterface> channel =
+  rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel("1", &config);
   EXPECT_TRUE(channel != NULL);
   EXPECT_TRUE(channel->reliable());
   EXPECT_TRUE(observer_.renegotiation_needed_);
   observer_.renegotiation_needed_ = false;
 
   config.ordered = false;
   channel = pc_->CreateDataChannel("2", &config);
   EXPECT_TRUE(channel != NULL);
   EXPECT_TRUE(channel->reliable());
@@ skipping 20 matching lines @@
        CreateSctpDataChannelShouldFailForInvalidConfig) {
   FakeConstraints constraints;
   constraints.SetAllowDtlsSctpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
   webrtc::DataChannelInit config;
   config.maxRetransmits = 0;
   config.maxRetransmitTime = 0;
 
-  scoped_refptr<DataChannelInterface> channel =
+  rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, &config);
   EXPECT_TRUE(channel == NULL);
 }
 
 // The test verifies that creating a SCTP data channel with an id already in use
 // or out of range should fail.
 TEST_F(PeerConnectionInterfaceTest,
        CreateSctpDataChannelWithInvalidIdShouldFail) {
   FakeConstraints constraints;
   constraints.SetAllowDtlsSctpDataChannels();
   CreatePeerConnection(&constraints);
 
   webrtc::DataChannelInit config;
-  scoped_refptr<DataChannelInterface> channel;
+  rtc::scoped_refptr<DataChannelInterface> channel;
 
   config.id = 1;
   channel = pc_->CreateDataChannel("1", &config);
   EXPECT_TRUE(channel != NULL);
   EXPECT_EQ(1, channel->id());
 
   channel = pc_->CreateDataChannel("x", &config);
   EXPECT_TRUE(channel == NULL);
 
   config.id = cricket::kMaxSctpSid;
   channel = pc_->CreateDataChannel("max", &config);
   EXPECT_TRUE(channel != NULL);
   EXPECT_EQ(config.id, channel->id());
 
   config.id = cricket::kMaxSctpSid + 1;
   channel = pc_->CreateDataChannel("x", &config);
   EXPECT_TRUE(channel == NULL);
 }
 
 // Verifies that duplicated label is allowed for SCTP data channel.
 TEST_F(PeerConnectionInterfaceTest, SctpDuplicatedLabelAllowed) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
-  scoped_refptr<DataChannelInterface> channel =
+  rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_NE(channel, nullptr);
 
-  scoped_refptr<DataChannelInterface> dup_channel =
+  rtc::scoped_refptr<DataChannelInterface> dup_channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_NE(dup_channel, nullptr);
 }
 
 // This test verifies that OnRenegotiationNeeded is fired for every new RTP
 // DataChannel.
 TEST_F(PeerConnectionInterfaceTest, RenegotiationNeededForNewRtpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
-  scoped_refptr<DataChannelInterface> dc1  =
+  rtc::scoped_refptr<DataChannelInterface> dc1 =
       pc_->CreateDataChannel("test1", NULL);
   EXPECT_TRUE(observer_.renegotiation_needed_);
   observer_.renegotiation_needed_ = false;
 
-  scoped_refptr<DataChannelInterface> dc2  =
+  rtc::scoped_refptr<DataChannelInterface> dc2 =
       pc_->CreateDataChannel("test2", NULL);
   EXPECT_TRUE(observer_.renegotiation_needed_);
 }
 
 // This test that a data channel closes when a PeerConnection is deleted/closed.
 TEST_F(PeerConnectionInterfaceTest, DataChannelCloseWhenPeerConnectionClose) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
-  scoped_refptr<DataChannelInterface> data1  =
+  rtc::scoped_refptr<DataChannelInterface> data1 =
       pc_->CreateDataChannel("test1", NULL);
-  scoped_refptr<DataChannelInterface> data2  =
+  rtc::scoped_refptr<DataChannelInterface> data2 =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
   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());
 }
 
 // This test that data channels can be rejected in an answer.
 TEST_F(PeerConnectionInterfaceTest, TestRejectDataChannelInAnswer) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
-  scoped_refptr<DataChannelInterface> offer_channel(
+  rtc::scoped_refptr<DataChannelInterface> offer_channel(
       pc_->CreateDataChannel("offer_channel", NULL));
 
   CreateOfferAsLocalDescription();
 
   // Create an answer where the m-line for data channels are rejected.
   std::string sdp;
   EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
   webrtc::JsepSessionDescription* answer = new webrtc::JsepSessionDescription(
       SessionDescriptionInterface::kAnswer);
   EXPECT_TRUE(answer->Initialize(sdp, NULL));
@@ skipping 185 matching lines @@
 
   EXPECT_EQ(PeerConnectionInterface::kClosed, pc_->signaling_state());
   EXPECT_EQ(PeerConnectionInterface::kIceConnectionClosed,
             pc_->ice_connection_state());
   EXPECT_EQ(PeerConnectionInterface::kIceGatheringComplete,
             pc_->ice_gathering_state());
 
   EXPECT_EQ(1u, pc_->local_streams()->count());
   EXPECT_EQ(1u, pc_->remote_streams()->count());
 
-  scoped_refptr<MediaStreamInterface> remote_stream =
-          pc_->remote_streams()->at(0);
+  rtc::scoped_refptr<MediaStreamInterface> remote_stream =
+      pc_->remote_streams()->at(0);
   // Track state may be updated asynchronously.
   EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded,
                  remote_stream->GetAudioTracks()[0]->state(), kTimeout);
   EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded,
                  remote_stream->GetVideoTracks()[0]->state(), kTimeout);
 }
 
 // Test that PeerConnection methods fails gracefully after
 // PeerConnection::Close has been called.
 TEST_F(PeerConnectionInterfaceTest, CloseAndTestMethods) {
   CreatePeerConnection();
   AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
   CreateOfferAsRemoteDescription();
   CreateAnswerAsLocalDescription();
 
   ASSERT_EQ(1u, pc_->local_streams()->count());
-  scoped_refptr<MediaStreamInterface> local_stream =
+  rtc::scoped_refptr<MediaStreamInterface> local_stream =
       pc_->local_streams()->at(0);
 
   pc_->Close();
 
   pc_->RemoveStream(local_stream);
   EXPECT_FALSE(pc_->AddStream(local_stream));
 
   ASSERT_FALSE(local_stream->GetAudioTracks().empty());
   rtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender(
       pc_->CreateDtmfSender(local_stream->GetAudioTracks()[0]));
@@ skipping 72 matching lines @@
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms1.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
 
   // Add extra audio and video tracks to the same MediaStream.
   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 =
+  rtc::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 =
+  rtc::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.
   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));
@@ skipping 400 matching lines @@
  protected:
   void SetUp() override {
     pcf_ = new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
     pcf_->Initialize();
   }
   const cricket::MediaConfig& TestCreatePeerConnection(
       const PeerConnectionInterface::RTCConfiguration& config,
       const MediaConstraintsInterface *constraints) {
     pcf_->create_media_controller_called_ = false;
 
-    scoped_refptr<PeerConnectionInterface> pc(
-        pcf_->CreatePeerConnection(config, constraints, nullptr, nullptr,
-                                   &observer_));
+    rtc::scoped_refptr<PeerConnectionInterface> pc(pcf_->CreatePeerConnection(
+        config, constraints, nullptr, nullptr, &observer_));
     EXPECT_TRUE(pc.get());
     EXPECT_TRUE(pcf_->create_media_controller_called_);
     return pcf_->create_media_controller_config_;
   }
 
-  scoped_refptr<PeerConnectionFactoryForTest> pcf_;
+  rtc::scoped_refptr<PeerConnectionFactoryForTest> pcf_;
   MockPeerConnectionObserver observer_;
 };
 
 // This test verifies the default behaviour with no constraints and a
 // default RTCConfiguration.
 TEST_F(PeerConnectionMediaConfigTest, TestDefaults) {
   PeerConnectionInterface::RTCConfiguration config;
   FakeConstraints constraints;
 
   const cricket::MediaConfig& media_config =
@@ skipping 224 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());
 }