Make RTCPeerConnectionHandlerTest use the webrtc signaling thread.

content/renderer/media/rtc_peer_connection_handler_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_audio_device_factory.h"
 #include "content/renderer/media/mock_constraint_factory.h"
@@ skipping 212 matching lines @@
   }
 
   MockPeerConnectionImpl* native_peer_connection() {
     return static_cast<MockPeerConnectionImpl*>(
         RTCPeerConnectionHandler::native_peer_connection());
   }
 
   webrtc::PeerConnectionObserver* observer() {
     return native_peer_connection()->observer();
   }
-
-  scoped_refptr<base::SingleThreadTaskRunner>
-  signaling_thread() const override {
-    return base::ThreadTaskRunnerHandle::Get();
-  }
 };
 
 class RTCPeerConnectionHandlerTest : public ::testing::Test {
  public:
   RTCPeerConnectionHandlerTest() : mock_peer_connection_(NULL) {
     child_process_.reset(new ChildProcess());
   }
 
   void SetUp() override {
     mock_client_.reset(new NiceMock<MockWebRTCPeerConnectionHandlerClient>());
@@ skipping 103 matching lines @@
     blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
     stream.VideoTracks(video_tracks);
     for (const auto& track : video_tracks)
       MediaStreamVideoTrack::GetVideoTrack(track)->Stop();
   }
 
   static void OnAudioSourceStarted(MediaStreamSource* source,
                                    MediaStreamRequestResult result,
                                    const blink::WebString& result_name) {}
 
+  // Wait for all current posts to the webrtc signaling thread to run and then
+  // run the message loop until idle on the main thread.
+  void RunMessageLoopsUntilIdle() {
+    base::WaitableEvent waitable_event(
+        base::WaitableEvent::ResetPolicy::MANUAL,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
+    mock_dependency_factory_->GetWebRtcSignalingThread()->PostTask(
+        FROM_HERE,
+        base::Bind(&RTCPeerConnectionHandlerTest::SignalWaitableEvent,
+                   base::Unretained(this), &waitable_event));
+    waitable_event.Wait();
+    base::RunLoop().RunUntilIdle();
+  }
+
+ private:
+  void SignalWaitableEvent(base::WaitableEvent* waitable_event) {
+    waitable_event->Signal();
+  }
+
+ public:
   base::MessageLoop message_loop_;
   std::unique_ptr<ChildProcess> child_process_;
   std::unique_ptr<MockWebRTCPeerConnectionHandlerClient> mock_client_;
   std::unique_ptr<MockPeerConnectionDependencyFactory> mock_dependency_factory_;
   std::unique_ptr<NiceMock<MockPeerConnectionTracker>> mock_tracker_;
   std::unique_ptr<RTCPeerConnectionHandlerUnderTest> pc_handler_;
   MockAudioDeviceFactory mock_audio_device_factory_;
 
   // Weak reference to the mocked native peer connection implementation.
   MockPeerConnectionImpl* mock_peer_connection_;
@@ skipping 36 matching lines @@
 
   EXPECT_CALL(*mock_client_.get(), DidRemoveRemoteStream(_)).Times(0);
   pc_handler_->observer()->OnRemoveStream(remote_stream);
 
   EXPECT_CALL(*mock_client_.get(), DidAddRemoteDataChannel(_)).Times(0);
   webrtc::DataChannelInit config;
   rtc::scoped_refptr<webrtc::DataChannelInterface> remote_data_channel(
       new rtc::RefCountedObject<MockDataChannel>("dummy", &config));
   pc_handler_->observer()->OnDataChannel(remote_data_channel);
 
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, DestructAllHandlers) {
   EXPECT_CALL(*mock_client_.get(), ReleasePeerConnectionHandler()).Times(1);
   RTCPeerConnectionHandler::DestructAllHandlers();
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, CreateOffer) {
   blink::WebRTCSessionDescriptionRequest request;
   blink::WebMediaConstraints options;
@@ skipping 26 matching lines @@
   // PeerConnectionTracker::TrackSetSessionDescription is expected to be called
   // before |mock_peer_connection| is called.
   testing::InSequence sequence;
   EXPECT_CALL(*mock_tracker_.get(),
               TrackSetSessionDescription(pc_handler_.get(), kDummySdp,
                                          kDummySdpType,
                                          PeerConnectionTracker::SOURCE_LOCAL));
   EXPECT_CALL(*mock_peer_connection_, SetLocalDescription(_, _));
 
   pc_handler_->SetLocalDescription(request, description);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(description.GetType(), pc_handler_->LocalDescription().GetType());
   EXPECT_EQ(description.Sdp(), pc_handler_->LocalDescription().Sdp());
 
   std::string sdp_string;
   ASSERT_TRUE(mock_peer_connection_->local_description() != NULL);
   EXPECT_EQ(kDummySdpType, mock_peer_connection_->local_description()->type());
   mock_peer_connection_->local_description()->ToString(&sdp_string);
   EXPECT_EQ(kDummySdp, sdp_string);
 
   // TODO(deadbeef): Also mock the "success" callback from the PeerConnection
@@ skipping 15 matching lines @@
                                  PeerConnectionTracker::SOURCE_LOCAL));
   EXPECT_CALL(
       *mock_tracker_.get(),
       TrackSessionDescriptionCallback(
           pc_handler_.get(),
           PeerConnectionTracker::ACTION_SET_LOCAL_DESCRIPTION, "OnFailure", _));
 
   // Used to simulate a parse failure.
   mock_dependency_factory_->SetFailToCreateSessionDescription(true);
   pc_handler_->SetLocalDescription(request, description);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   // A description that failed to be applied shouldn't be stored.
   EXPECT_TRUE(pc_handler_->LocalDescription().Sdp().IsEmpty());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, setRemoteDescription) {
   blink::WebRTCVoidRequest request;
   blink::WebRTCSessionDescription description;
   description.Initialize(kDummySdpType, kDummySdp);
 
   // PeerConnectionTracker::TrackSetSessionDescription is expected to be called
   // before |mock_peer_connection| is called.
   testing::InSequence sequence;
   EXPECT_CALL(*mock_tracker_.get(),
               TrackSetSessionDescription(pc_handler_.get(), kDummySdp,
                                          kDummySdpType,
                                          PeerConnectionTracker::SOURCE_REMOTE));
   EXPECT_CALL(*mock_peer_connection_, SetRemoteDescription(_, _));
 
   pc_handler_->SetRemoteDescription(request, description);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(description.GetType(), pc_handler_->RemoteDescription().GetType());
   EXPECT_EQ(description.Sdp(), pc_handler_->RemoteDescription().Sdp());
 
   std::string sdp_string;
   ASSERT_TRUE(mock_peer_connection_->remote_description() != NULL);
   EXPECT_EQ(kDummySdpType, mock_peer_connection_->remote_description()->type());
   mock_peer_connection_->remote_description()->ToString(&sdp_string);
   EXPECT_EQ(kDummySdp, sdp_string);
 
   // TODO(deadbeef): Also mock the "success" callback from the PeerConnection
@@ skipping 15 matching lines @@
                                  PeerConnectionTracker::SOURCE_REMOTE));
   EXPECT_CALL(*mock_tracker_.get(),
               TrackSessionDescriptionCallback(
                   pc_handler_.get(),
                   PeerConnectionTracker::ACTION_SET_REMOTE_DESCRIPTION,
                   "OnFailure", _));
 
   // Used to simulate a parse failure.
   mock_dependency_factory_->SetFailToCreateSessionDescription(true);
   pc_handler_->SetRemoteDescription(request, description);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   // A description that failed to be applied shouldn't be stored.
   EXPECT_TRUE(pc_handler_->RemoteDescription().Sdp().IsEmpty());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, setConfiguration) {
   blink::WebRTCConfiguration config;
 
   EXPECT_CALL(*mock_tracker_.get(),
               TrackSetConfiguration(pc_handler_.get(), _));
   // TODO(perkj): Test that the parameters in |config| can be translated when a
@@ skipping 88 matching lines @@
       1u,
       mock_peer_connection_->local_streams()->at(0)->GetVideoTracks().size());
 
   StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsNoSelector) {
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   pc_handler_->getStats(request.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   ASSERT_TRUE(request->result());
   EXPECT_LT(1, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsAfterClose) {
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   pc_handler_->Stop();
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   pc_handler_->getStats(request.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   ASSERT_TRUE(request->result());
   EXPECT_LT(1, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithLocalSelector) {
   blink::WebMediaStream local_stream(
       CreateLocalMediaStream("local_stream"));
   blink::WebMediaConstraints constraints;
   pc_handler_->AddStream(local_stream, constraints);
   blink::WebVector<blink::WebMediaStreamTrack> tracks;
   local_stream.AudioTracks(tracks);
   ASSERT_LE(1ul, tracks.size());
 
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(tracks[0]);
   pc_handler_->getStats(request.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(1, request->result()->report_count());
 
   StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithRemoteSelector) {
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
       AddRemoteMockMediaStream("remote_stream", "video", "audio"));
   pc_handler_->observer()->OnAddStream(stream);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   const blink::WebMediaStream& remote_stream = mock_client_->remote_stream();
 
   blink::WebVector<blink::WebMediaStreamTrack> tracks;
   remote_stream.AudioTracks(tracks);
   ASSERT_LE(1ul, tracks.size());
 
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(tracks[0]);
   pc_handler_->getStats(request.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(1, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithBadSelector) {
   // The setup is the same as GetStatsWithLocalSelector, but the stream is not
   // added to the PeerConnection.
   blink::WebMediaStream local_stream(
       CreateLocalMediaStream("local_stream_2"));
   blink::WebMediaConstraints constraints;
   blink::WebVector<blink::WebMediaStreamTrack> tracks;
 
   local_stream.AudioTracks(tracks);
   blink::WebMediaStreamTrack component = tracks[0];
   mock_peer_connection_->SetGetStatsResult(false);
 
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(component);
   pc_handler_->getStats(request.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(0, request->result()->report_count());
 
   StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetRTCStats) {
   WhitelistStatsForTesting(webrtc::RTCTestStats::kType);
 
   rtc::scoped_refptr<webrtc::RTCStatsReport> report =
       webrtc::RTCStatsReport::Create();
@@ skipping 17 matching lines @@
   stats_defined_members->m_sequence_uint64 = ToSequence<uint64_t>(42);
   stats_defined_members->m_sequence_double = ToSequence<double>(42);
   stats_defined_members->m_sequence_string = ToSequence<std::string>("42");
   report->AddStats(std::unique_ptr<const webrtc::RTCStats>(
       stats_defined_members.release()));
 
   pc_handler_->native_peer_connection()->SetGetStatsReport(report);
   std::unique_ptr<blink::WebRTCStatsReport> result;
   pc_handler_->GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>(
       new MockRTCStatsReportCallback(&result)));
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_TRUE(result);
 
   int undefined_stats_count = 0;
   int defined_stats_count = 0;
   for (std::unique_ptr<blink::WebRTCStats> stats = result->Next(); stats;
        stats.reset(result->Next().release())) {
     EXPECT_EQ(stats->GetType().Utf8(), webrtc::RTCTestStats::kType);
     if (stats->Id().Utf8() == "RTCUndefinedStats") {
       ++undefined_stats_count;
       EXPECT_EQ(stats->Timestamp(), 1.0);
@@ skipping 73 matching lines @@
   }
   EXPECT_EQ(undefined_stats_count, 1);
   EXPECT_EQ(defined_stats_count, 1);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetReceivers) {
   std::vector<blink::WebMediaStream> remote_streams;
 
   pc_handler_->observer()->OnAddStream(
       AddRemoteMockMediaStream("stream0", "video0", "audio0"));
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   remote_streams.push_back(mock_client_->remote_stream());
   pc_handler_->observer()->OnAddStream(
       AddRemoteMockMediaStream("stream1", "video1", "audio1"));
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   remote_streams.push_back(mock_client_->remote_stream());
   pc_handler_->observer()->OnAddStream(
       AddRemoteMockMediaStream("stream2", "video2", "audio2"));
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   remote_streams.push_back(mock_client_->remote_stream());
 
   std::set<std::string> expected_remote_track_ids;
   expected_remote_track_ids.insert("video0");
   expected_remote_track_ids.insert("audio0");
   expected_remote_track_ids.insert("video1");
   expected_remote_track_ids.insert("audio1");
   expected_remote_track_ids.insert("video2");
   expected_remote_track_ids.insert("audio2");
 
@@ skipping 242 matching lines @@
           pc_handler_.get(),
           testing::Property(&blink::WebMediaStream::Id,
                             blink::WebString::FromASCII(remote_stream_label)),
           PeerConnectionTracker::SOURCE_REMOTE));
   EXPECT_CALL(*mock_client_.get(),
               DidRemoveRemoteStream(testing::Property(
                   &blink::WebMediaStream::Id,
                   blink::WebString::FromASCII(remote_stream_label))));
 
   pc_handler_->observer()->OnAddStream(remote_stream);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   pc_handler_->observer()->OnRemoveStream(remote_stream);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
 }
 
 // This test that WebKit is notified about remote track state changes.
 TEST_F(RTCPeerConnectionHandlerTest, RemoteTrackState) {
   std::string remote_stream_label("remote_stream");
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 
   testing::InSequence sequence;
   EXPECT_CALL(*mock_client_.get(),
               DidAddRemoteStream(testing::Property(
                   &blink::WebMediaStream::Id,
                   blink::WebString::FromASCII(remote_stream_label))));
   pc_handler_->observer()->OnAddStream(remote_stream);
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   const blink::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   webkit_stream.AudioTracks(audio_tracks);
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateLive,
             audio_tracks[0].Source().GetReadyState());
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   webkit_stream.VideoTracks(video_tracks);
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateLive,
             video_tracks[0].Source().GetReadyState());
 
   static_cast<MockWebRtcAudioTrack*>(remote_stream->GetAudioTracks()[0].get())
       ->SetEnded();
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateEnded,
             audio_tracks[0].Source().GetReadyState());
 
   static_cast<MockWebRtcVideoTrack*>(remote_stream->GetVideoTracks()[0].get())
       ->SetEnded();
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateEnded,
             video_tracks[0].Source().GetReadyState());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddAudioTrackFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   base::RunLoop run_loop;
 
   // Grab the added media stream when it's been successfully added to the PC.
   blink::WebMediaStream webkit_stream;
@@ skipping 14 matching lines @@
     // source later.
     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
     webkit_stream.AudioTracks(audio_tracks);
     EXPECT_EQ(1u, audio_tracks.size());
   }
 
   // Remove the Webrtc audio track from the Webrtc MediaStream.
   scoped_refptr<webrtc::AudioTrackInterface> webrtc_track =
       remote_stream->GetAudioTracks()[0].get();
   remote_stream->RemoveTrack(webrtc_track.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
 
   {
     blink::WebVector<blink::WebMediaStreamTrack> modified_audio_tracks1;
     webkit_stream.AudioTracks(modified_audio_tracks1);
     EXPECT_EQ(0u, modified_audio_tracks1.size());
   }
 
   blink::WebHeap::CollectGarbageForTesting();
 
   // Add the WebRtc audio track again.
   remote_stream->AddTrack(webrtc_track.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   blink::WebVector<blink::WebMediaStreamTrack> modified_audio_tracks2;
   webkit_stream.AudioTracks(modified_audio_tracks2);
   EXPECT_EQ(1u, modified_audio_tracks2.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddVideoTrackFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   base::RunLoop run_loop;
 
   // Grab the added media stream when it's been successfully added to the PC.
@@ skipping 15 matching lines @@
     // source later.
     blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
     webkit_stream.VideoTracks(video_tracks);
     EXPECT_EQ(1u, video_tracks.size());
   }
 
   // Remove the Webrtc video track from the Webrtc MediaStream.
   scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
       remote_stream->GetVideoTracks()[0].get();
   remote_stream->RemoveTrack(webrtc_track.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   {
     blink::WebVector<blink::WebMediaStreamTrack> modified_video_tracks1;
     webkit_stream.VideoTracks(modified_video_tracks1);
     EXPECT_EQ(0u, modified_video_tracks1.size());
   }
 
   blink::WebHeap::CollectGarbageForTesting();
 
   // Add the WebRtc video track again.
   remote_stream->AddTrack(webrtc_track.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   blink::WebVector<blink::WebMediaStreamTrack> modified_video_tracks2;
   webkit_stream.VideoTracks(modified_video_tracks2);
   EXPECT_EQ(1u, modified_video_tracks2.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddTracksFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   base::RunLoop run_loop;
 
   // Grab the added media stream when it's been successfully added to the PC.
@@ skipping 19 matching lines @@
     blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
     webkit_stream.VideoTracks(video_tracks);
     EXPECT_EQ(1u, video_tracks.size());
   }
 
   // Remove the Webrtc tracks from the MediaStream.
   auto audio_track = remote_stream->GetAudioTracks()[0];
   EXPECT_TRUE(remote_stream->RemoveTrack(audio_track.get()));
   auto video_track = remote_stream->GetVideoTracks()[0];
   EXPECT_TRUE(remote_stream->RemoveTrack(video_track.get()));
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
 
   {
     blink::WebVector<blink::WebMediaStreamTrack> modified_audio_tracks;
     webkit_stream.AudioTracks(modified_audio_tracks);
     EXPECT_EQ(0u, modified_audio_tracks.size());
     blink::WebVector<blink::WebMediaStreamTrack> modified_video_tracks;
     webkit_stream.VideoTracks(modified_video_tracks);
     EXPECT_EQ(0u, modified_video_tracks.size());
   }
 
   blink::WebHeap::CollectGarbageForTesting();
 
   // Add the tracks again.
   remote_stream->AddTrack(audio_track.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   remote_stream->AddTrack(video_track.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
 
   blink::WebHeap::CollectGarbageForTesting();
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   webkit_stream.AudioTracks(audio_tracks);
   EXPECT_EQ(1u, audio_tracks.size());
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   webkit_stream.VideoTracks(video_tracks);
   EXPECT_EQ(1u, video_tracks.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnIceCandidate) {
   testing::InSequence sequence;
   EXPECT_CALL(*mock_tracker_.get(),
               TrackAddIceCandidate(pc_handler_.get(), _,
                                    PeerConnectionTracker::SOURCE_LOCAL, true));
   EXPECT_CALL(*mock_client_.get(), DidGenerateICECandidate(_));
 
   std::unique_ptr<webrtc::IceCandidateInterface> native_candidate(
       mock_dependency_factory_->CreateIceCandidate("sdpMid", 1, kDummySdp));
   pc_handler_->observer()->OnIceCandidate(native_candidate.get());
-  base::RunLoop().RunUntilIdle();
+  RunMessageLoopsUntilIdle();
   EXPECT_EQ("sdpMid", mock_client_->candidate_mid());
   EXPECT_EQ(1, mock_client_->candidate_mlineindex());
   EXPECT_EQ(kDummySdp, mock_client_->candidate_sdp());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnRenegotiationNeeded) {
   testing::InSequence sequence;
   EXPECT_CALL(*mock_tracker_.get(),
               TrackOnRenegotiationNeeded(pc_handler_.get()));
   EXPECT_CALL(*mock_client_.get(), NegotiationNeeded());
@@ skipping 33 matching lines @@
                                     testing::Ref(tracks[0])));
 
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> sender(
       pc_handler_->CreateDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 
   StopAllTracks(local_stream);
 }
 
 }  // namespace content