TrackObserver DCHECK not on main thread, tests updated.

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>
@@ skipping 330 matching lines @@
 
   // Creates a remote MediaStream and adds it to the mocked native
   // peer connection.
   rtc::scoped_refptr<webrtc::MediaStreamInterface> AddRemoteMockMediaStream(
       const std::string& stream_label,
       const std::string& video_track_label,
       const std::string& audio_track_label) {
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label).get());
     if (!video_track_label.empty()) {
-      stream->AddTrack(MockWebRtcVideoTrack::Create(video_track_label).get());
+      InvokeAddTrack(stream,
+                     MockWebRtcVideoTrack::Create(video_track_label).get());
     }
     if (!audio_track_label.empty()) {
-      stream->AddTrack(MockWebRtcAudioTrack::Create(audio_track_label).get());
+      InvokeAddTrack(stream,
+                     MockWebRtcAudioTrack::Create(audio_track_label).get());
     }
     mock_peer_connection_->AddRemoteStream(stream);
     return stream;
   }
 
   void StopAllTracks(const blink::WebMediaStream& stream) {
     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
     stream.AudioTracks(audio_tracks);
     for (const auto& track : audio_tracks)
       MediaStreamAudioTrack::From(track)->Stop();
 
     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) {}
 
+  void InvokeOnAddStream(
+      const rtc::scoped_refptr<webrtc::MediaStreamInterface>& remote_stream) {
+    InvokeOnSignalingThread(
+        base::Bind(&webrtc::PeerConnectionObserver::OnAddStream,
+                   base::Unretained(pc_handler_->observer()), remote_stream));
+  }
+
+  void InvokeOnRemoveStream(
+      const rtc::scoped_refptr<webrtc::MediaStreamInterface>& remote_stream) {
+    InvokeOnSignalingThread(
+        base::Bind(&webrtc::PeerConnectionObserver::OnRemoveStream,
+                   base::Unretained(pc_handler_->observer()), remote_stream));
+  }
+
+  template <typename T>
+  void InvokeAddTrack(
+      const rtc::scoped_refptr<webrtc::MediaStreamInterface>& remote_stream,
+      T* webrtc_track) {
+    InvokeOnSignalingThread(base::Bind(
+        [](webrtc::MediaStreamInterface* remote_stream, T* webrtc_track) {
+          EXPECT_TRUE(remote_stream->AddTrack(webrtc_track));
+        },
+        base::Unretained(remote_stream.get()), base::Unretained(webrtc_track)));
+  }
+
+  template <typename T>
+  void InvokeRemoveTrack(
+      const rtc::scoped_refptr<webrtc::MediaStreamInterface>& remote_stream,
+      T* webrtc_track) {
+    InvokeOnSignalingThread(base::Bind(
+        [](webrtc::MediaStreamInterface* remote_stream, T* webrtc_track) {
+          EXPECT_TRUE(remote_stream->RemoveTrack(webrtc_track));
+        },
+        base::Unretained(remote_stream.get()), base::Unretained(webrtc_track)));
+  }
+
+  template <typename T>
+  void InvokeOnSignalingThread(T callback) {
+    mock_dependency_factory_->GetWebRtcSignalingThread()->PostTask(FROM_HERE,
+                                                                   callback);
+    RunMessageLoopsUntilIdle();
+  }
+
   // 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));
+        FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
+                              base::Unretained(&waitable_event)));
     waitable_event.Wait();
     base::RunLoop().RunUntilIdle();
   }
 
  private:
   void SignalWaitableEvent(base::WaitableEvent* waitable_event) {
     waitable_event->Signal();
   }
 
  public:
@@ skipping 35 matching lines @@
       webrtc::PeerConnectionInterface::kIceGatheringNew);
 
   EXPECT_CALL(*mock_client_.get(), DidChangeICEConnectionState(_)).Times(0);
   pc_handler_->observer()->OnIceConnectionChange(
       webrtc::PeerConnectionInterface::kIceConnectionDisconnected);
 
   EXPECT_CALL(*mock_client_.get(), DidAddRemoteStream(_)).Times(0);
   std::string remote_stream_label("remote_stream");
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
-  pc_handler_->observer()->OnAddStream(remote_stream);
+  InvokeOnAddStream(remote_stream);
 
   EXPECT_CALL(*mock_client_.get(), DidRemoveRemoteStream(_)).Times(0);
-  pc_handler_->observer()->OnRemoveStream(remote_stream);
+  InvokeOnRemoveStream(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);
 
   RunMessageLoopsUntilIdle();
 }
 
@@ skipping 273 matching lines @@
   pc_handler_->getStats(request.get());
   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);
-  RunMessageLoopsUntilIdle();
+  InvokeOnAddStream(stream);
   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());
@@ skipping 140 matching lines @@
       NOTREACHED();
     }
   }
   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"));
-  RunMessageLoopsUntilIdle();
+  InvokeOnAddStream(AddRemoteMockMediaStream("stream0", "video0", "audio0"));
   remote_streams.push_back(mock_client_->remote_stream());
-  pc_handler_->observer()->OnAddStream(
-      AddRemoteMockMediaStream("stream1", "video1", "audio1"));
-  RunMessageLoopsUntilIdle();
+  InvokeOnAddStream(AddRemoteMockMediaStream("stream1", "video1", "audio1"));
   remote_streams.push_back(mock_client_->remote_stream());
-  pc_handler_->observer()->OnAddStream(
-      AddRemoteMockMediaStream("stream2", "video2", "audio2"));
-  RunMessageLoopsUntilIdle();
+  InvokeOnAddStream(AddRemoteMockMediaStream("stream2", "video2", "audio2"));
   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 241 matching lines @@
       TrackRemoveStream(
           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);
-  RunMessageLoopsUntilIdle();
-  pc_handler_->observer()->OnRemoveStream(remote_stream);
-  RunMessageLoopsUntilIdle();
+  InvokeOnAddStream(remote_stream);
+  InvokeOnRemoveStream(remote_stream);
 }
 
 // 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);
-  RunMessageLoopsUntilIdle();
+  InvokeOnAddStream(remote_stream);
   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();
-  RunMessageLoopsUntilIdle();
+  InvokeOnSignalingThread(
+      base::Bind(&MockWebRtcAudioTrack::SetEnded,
+                 base::Unretained(static_cast<MockWebRtcAudioTrack*>(
+                     remote_stream->GetAudioTracks()[0].get()))));
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateEnded,
             audio_tracks[0].Source().GetReadyState());
 
-  static_cast<MockWebRtcVideoTrack*>(remote_stream->GetVideoTracks()[0].get())
-      ->SetEnded();
-  RunMessageLoopsUntilIdle();
+  InvokeOnSignalingThread(
+      base::Bind(&MockWebRtcVideoTrack::SetEnded,
+                 base::Unretained(static_cast<MockWebRtcVideoTrack*>(
+                     remote_stream->GetVideoTracks()[0].get()))));
   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;
   EXPECT_CALL(*mock_client_.get(),
               DidAddRemoteStream(testing::Property(
                   &blink::WebMediaStream::Id,
                   blink::WebString::FromASCII(remote_stream_label))))
       .WillOnce(DoAll(SaveArg<0>(&webkit_stream),
                       ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
-  pc_handler_->observer()->OnAddStream(remote_stream);
+  InvokeOnAddStream(remote_stream);
   run_loop.Run();
 
   {
     // Test in a small scope so that  |audio_tracks| don't hold on to destroyed
     // 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());
-  RunMessageLoopsUntilIdle();
+  InvokeRemoveTrack(remote_stream, webrtc_track.get());
 
   {
     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());
-  RunMessageLoopsUntilIdle();
+  InvokeAddTrack(remote_stream, webrtc_track.get());
   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.
   blink::WebMediaStream webkit_stream;
   EXPECT_CALL(*mock_client_.get(),
               DidAddRemoteStream(testing::Property(
                   &blink::WebMediaStream::Id,
                   blink::WebString::FromASCII(remote_stream_label))))
       .WillOnce(DoAll(SaveArg<0>(&webkit_stream),
                       ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
-  pc_handler_->observer()->OnAddStream(remote_stream);
+  InvokeOnAddStream(remote_stream);
   run_loop.Run();
 
   {
     // Test in a small scope so that  |video_tracks| don't hold on to destroyed
     // 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());
+  InvokeRemoveTrack(remote_stream, webrtc_track.get());
   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());
+  InvokeAddTrack(remote_stream, webrtc_track.get());
   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.
   blink::WebMediaStream webkit_stream;
   EXPECT_CALL(*mock_client_.get(),
               DidAddRemoteStream(testing::Property(
                   &blink::WebMediaStream::Id,
                   blink::WebString::FromASCII(remote_stream_label))))
       .WillOnce(DoAll(SaveArg<0>(&webkit_stream),
                       ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
-  pc_handler_->observer()->OnAddStream(remote_stream);
+  InvokeOnAddStream(remote_stream);
   run_loop.Run();
 
   {
     // Test in a small scope so that  |audio_tracks| don't hold on to destroyed
     // source later.
     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());
   }
 
   // Remove the Webrtc tracks from the MediaStream.
   auto audio_track = remote_stream->GetAudioTracks()[0];
-  EXPECT_TRUE(remote_stream->RemoveTrack(audio_track.get()));
+  InvokeRemoveTrack(remote_stream, audio_track.get());
   auto video_track = remote_stream->GetVideoTracks()[0];
-  EXPECT_TRUE(remote_stream->RemoveTrack(video_track.get()));
+  InvokeRemoveTrack(remote_stream, video_track.get());
   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());
-  RunMessageLoopsUntilIdle();
-  remote_stream->AddTrack(video_track.get());
-  RunMessageLoopsUntilIdle();
+  InvokeAddTrack(remote_stream, audio_track.get());
+  InvokeAddTrack(remote_stream, video_track.get());
 
   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());
 }
@@ skipping 55 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