RemoteMediaStreamImpl using WebRtcMediaStreamTrackMap.

content/renderer/media/webrtc/webrtc_media_stream_track_adapter.cc

 // Copyright (c) 2017 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/webrtc_media_stream_track_adapter.h"
 
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/webrtc/media_stream_video_webrtc_sink.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/processed_local_audio_source.h"
 
 namespace content {
 
 // static
 scoped_refptr<WebRtcMediaStreamTrackAdapter>
 WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
     PeerConnectionDependencyFactory* factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     const blink::WebMediaStreamTrack& web_track) {
+  DCHECK(factory);
   DCHECK(main_thread->BelongsToCurrentThread());
+  DCHECK(!web_track.IsNull());
   scoped_refptr<WebRtcMediaStreamTrackAdapter> local_track_adapter(
       new WebRtcMediaStreamTrackAdapter(factory, main_thread));
   if (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) {
     local_track_adapter->InitializeLocalAudioTrack(web_track);
   } else {
     DCHECK_EQ(web_track.Source().GetType(),
               blink::WebMediaStreamSource::kTypeVideo);
     local_track_adapter->InitializeLocalVideoTrack(web_track);
   }
   return local_track_adapter;
 }
 
 // static
 scoped_refptr<WebRtcMediaStreamTrackAdapter>
 WebRtcMediaStreamTrackAdapter::CreateRemoteTrackAdapter(
     PeerConnectionDependencyFactory* factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     webrtc::MediaStreamTrackInterface* webrtc_track) {
-  DCHECK(factory->GetWebRtcSignalingThread()->BelongsToCurrentThread());
+  DCHECK(factory);
+  DCHECK(!main_thread->BelongsToCurrentThread());

[Guido Urdaneta, 2017/06/12 14:25:29]

Would a ThreadChecker/SequenceChecker (detached in the constructor) be a better
option for this?

[hbos_chromium, 2017/06/12 15:05:21]

I'd like to avoid that because then the test passes on any test that runs on a
single thread, and only fails on the subset of tests that would use different
threads for different invocations. (This is what other classes did that caused
me trouble.) Usually if a method is used the wrong way and called on the wrong
thread, it will be called on the wrong thread every time. And if a test is small
and only calls it once the detached thread checker is no better than
DCHECK(true).

I could use a thread checker in combination with !main_thread to ensure that a
third thread isn't being used, but I think it would give little value over
checking !main_thread.

[Guido Urdaneta, 2017/06/12 15:18:35]

Acknowledged.

   DCHECK(webrtc_track);
   scoped_refptr<WebRtcMediaStreamTrackAdapter> remote_track_adapter(
       new WebRtcMediaStreamTrackAdapter(factory, main_thread));
   if (webrtc_track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
     remote_track_adapter->InitializeRemoteAudioTrack(
         static_cast<webrtc::AudioTrackInterface*>(webrtc_track));
   } else {
     DCHECK_EQ(webrtc_track->kind(),
               webrtc::MediaStreamTrackInterface::kVideoKind);
     remote_track_adapter->InitializeRemoteVideoTrack(
@@ skipping 106 matching lines @@
   web_track_ = web_track;
   local_track_video_sink_.reset(
       new MediaStreamVideoWebRtcSink(web_track_, factory_));
   webrtc_track_ = local_track_video_sink_->webrtc_video_track();
   DCHECK(webrtc_track_);
   is_initialized_ = true;
 }
 
 void WebRtcMediaStreamTrackAdapter::InitializeRemoteAudioTrack(
     webrtc::AudioTrackInterface* webrtc_audio_track) {
-  DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread());
+  DCHECK(!main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(webrtc_audio_track);
   DCHECK_EQ(webrtc_audio_track->kind(),
             webrtc::MediaStreamTrackInterface::kAudioKind);
   remote_audio_track_adapter_ =
       new RemoteAudioTrackAdapter(main_thread_, webrtc_audio_track);
   webrtc_track_ = webrtc_audio_track;
   main_thread_->PostTask(
       FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter::
                                 FinalizeRemoteTrackInitializationOnMainThread,
                             this));
 }
 
 void WebRtcMediaStreamTrackAdapter::InitializeRemoteVideoTrack(
     webrtc::VideoTrackInterface* webrtc_video_track) {
-  DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread());
+  DCHECK(!main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(webrtc_video_track);
   DCHECK_EQ(webrtc_video_track->kind(),
             webrtc::MediaStreamTrackInterface::kVideoKind);
   remote_video_track_adapter_ =
       new RemoteVideoTrackAdapter(main_thread_, webrtc_video_track);
   webrtc_track_ = webrtc_video_track;
   main_thread_->PostTask(
       FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter::
                                 FinalizeRemoteTrackInitializationOnMainThread,
@@ skipping 56 matching lines @@
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(remote_video_track_adapter_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   FinalizeRemoteTrackDisposingOnMainThread();
 }
 
 void WebRtcMediaStreamTrackAdapter::
     UnregisterRemoteAudioTrackAdapterOnSignalingThread() {
-  DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread());
+  DCHECK(!main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(remote_audio_track_adapter_);
   remote_audio_track_adapter_->Unregister();
   main_thread_->PostTask(
       FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter::
                                 FinalizeRemoteTrackDisposingOnMainThread,
                             this));
 }
 
 void WebRtcMediaStreamTrackAdapter::FinalizeRemoteTrackDisposingOnMainThread() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   remote_audio_track_adapter_ = nullptr;
   remote_video_track_adapter_ = nullptr;
   webrtc_track_ = nullptr;
   web_track_.Reset();
 }
 
 }  // namespace content