TrackObserver DCHECK not on main thread, tests updated.

content/renderer/media/webrtc/media_stream_remote_video_source_unittest.cc

 // Copyright 2014 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/webrtc/media_stream_remote_video_source.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_media_stream_video_sink.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/track_observer.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
@@ skipping 16 matching lines @@
 
 class MediaStreamRemoteVideoSourceTest
     : public ::testing::Test {
  public:
   MediaStreamRemoteVideoSourceTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::UI),
         child_process_(new ChildProcess()),
         mock_factory_(new MockPeerConnectionDependencyFactory()),
         webrtc_video_track_(MockWebRtcVideoTrack::Create("test")),
-        remote_source_(new MediaStreamRemoteVideoSourceUnderTest(
-            std::unique_ptr<TrackObserver>(
-                new TrackObserver(base::ThreadTaskRunnerHandle::Get(),
-                                  webrtc_video_track_.get())))),
+        remote_source_(nullptr),
         number_of_successful_track_starts_(0),
-        number_of_failed_track_starts_(0) {
+        number_of_failed_track_starts_(0) {}
+
+  void SetUp() override {
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread =
+        base::ThreadTaskRunnerHandle::Get();
+
+    base::WaitableEvent waitable_event(
+        base::WaitableEvent::ResetPolicy::MANUAL,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
+
+    std::unique_ptr<TrackObserver> track_observer;
+    mock_factory_->GetWebRtcSignalingThread()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            [](scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+               webrtc::MediaStreamTrackInterface* webrtc_track,
+               std::unique_ptr<TrackObserver>* track_observer,
+               base::WaitableEvent* waitable_event) {
+              track_observer->reset(
+                  new TrackObserver(main_thread, webrtc_track));
+              waitable_event->Signal();
+            },
+            main_thread, base::Unretained(webrtc_video_track_.get()),
+            base::Unretained(&track_observer),
+            base::Unretained(&waitable_event)));
+    waitable_event.Wait();
+
+    remote_source_ =
+        new MediaStreamRemoteVideoSourceUnderTest(std::move(track_observer));
     webkit_source_.Initialize(blink::WebString::FromASCII("dummy_source_id"),
                               blink::WebMediaStreamSource::kTypeVideo,
                               blink::WebString::FromASCII("dummy_source_name"),
                               true /* remote */);
     webkit_source_.SetExtraData(remote_source_);
   }
 
   void TearDown() override {
     remote_source_->OnSourceTerminated();
     webkit_source_.Reset();
@@ skipping 15 matching lines @@
 
   int NumberOfSuccessConstraintsCallbacks() const {
     return number_of_successful_track_starts_;
   }
 
   int NumberOfFailedConstraintsCallbacks() const {
     return number_of_failed_track_starts_;
   }
 
   void StopWebRtcTrack() {
-    static_cast<MockWebRtcVideoTrack*>(webrtc_video_track_.get())->SetEnded();
+    base::WaitableEvent waitable_event(
+        base::WaitableEvent::ResetPolicy::MANUAL,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
+    mock_factory_->GetWebRtcSignalingThread()->PostTask(
+        FROM_HERE, base::Bind(
+                       [](MockWebRtcVideoTrack* video_track,
+                          base::WaitableEvent* waitable_event) {
+                         video_track->SetEnded();
+                         waitable_event->Signal();
+                       },
+                       base::Unretained(static_cast<MockWebRtcVideoTrack*>(
+                           webrtc_video_track_.get())),
+                       base::Unretained(&waitable_event)));
+    waitable_event.Wait();
   }
 
   const blink::WebMediaStreamSource& webkit_source() const {
     return  webkit_source_;
   }
 
  private:
   void OnTrackStarted(MediaStreamSource* source,
                       MediaStreamRequestResult result,
                       const blink::WebString& result_name) {
@@ skipping 49 matching lines @@
   StopWebRtcTrack();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateEnded,
             webkit_source().GetReadyState());
   EXPECT_EQ(blink::WebMediaStreamSource::kReadyStateEnded, sink.state());
 
   track->RemoveSink(&sink);
 }
 
 }  // namespace content