Split libjingle's signaling thread from the UI thread

content/renderer/media/webrtc_local_audio_track.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/webrtc_local_audio_track.h"
 
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/renderer/media/media_stream_audio_level_calculator.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
 #include "content/renderer/media/media_stream_audio_sink_owner.h"
 #include "content/renderer/media/media_stream_audio_track_sink.h"
 #include "content/renderer/media/peer_connection_audio_sink_owner.h"
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 
 namespace content {
 
 WebRtcLocalAudioTrack::WebRtcLocalAudioTrack(
     WebRtcLocalAudioTrackAdapter* adapter,
     const scoped_refptr<WebRtcAudioCapturer>& capturer,
     WebAudioCapturerSource* webaudio_source)
-    : MediaStreamTrack(adapter, true),
+    : MediaStreamTrack(true),
       adapter_(adapter),
       capturer_(capturer),
       webaudio_source_(webaudio_source) {
   DCHECK(capturer.get() || webaudio_source);
+  signal_thread_checker_.DetachFromThread();
 
   adapter_->Initialize(this);
 
   DVLOG(1) << "WebRtcLocalAudioTrack::WebRtcLocalAudioTrack()";
 }
 
 WebRtcLocalAudioTrack::~WebRtcLocalAudioTrack() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::~WebRtcLocalAudioTrack()";
   // Users might not call Stop() on the track.
@@ skipping 77 matching lines @@
     const scoped_refptr<MediaStreamAudioProcessor>& processor) {
   // if the |processor| does not have audio processing, which can happen if
   // kDisableAudioTrackProcessing is set set or all the constraints in
   // the |processor| are turned off. In such case, we pass NULL to the
   // adapter to indicate that no stats can be gotten from the processor.
   adapter_->SetAudioProcessor(processor->has_audio_processing() ?
       processor : NULL);
 }
 
 void WebRtcLocalAudioTrack::AddSink(MediaStreamAudioSink* sink) {
-  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  // This method is called from webrtc, on the signaling thread, when the local
+  // description is set and from the main thread from WebMediaPlayerMS::load
+  // (via WebRtcLocalAudioRenderer::Start).
+  DCHECK(main_render_thread_checker_.CalledOnValidThread() ||
+         signal_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::AddSink()";
   base::AutoLock auto_lock(lock_);
 
   // Verify that |sink| is not already added to the list.
   DCHECK(!sinks_.Contains(
       MediaStreamAudioTrackSink::WrapsMediaStreamSink(sink)));
 
   // Create (and add to the list) a new MediaStreamAudioTrackSink
   // which owns the |sink| and delagates all calls to the
   // MediaStreamAudioSink interface. It will be tagged in the list, so
   // we remember to call OnSetFormat() on the new sink.
   scoped_refptr<MediaStreamAudioTrackSink> sink_owner(
       new MediaStreamAudioSinkOwner(sink));
   sinks_.AddAndTag(sink_owner.get());
 }
 
 void WebRtcLocalAudioTrack::RemoveSink(MediaStreamAudioSink* sink) {
-  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  // See AddSink for additional context.  When local audio is stopped from
+  // webrtc, we'll be called here on the signaling thread.
+  DCHECK(main_render_thread_checker_.CalledOnValidThread() ||
+         signal_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::RemoveSink()";
 
-  base::AutoLock auto_lock(lock_);
-
-  scoped_refptr<MediaStreamAudioTrackSink> removed_item = sinks_.Remove(
-      MediaStreamAudioTrackSink::WrapsMediaStreamSink(sink));
+  scoped_refptr<MediaStreamAudioTrackSink> removed_item;
+  {
+    base::AutoLock auto_lock(lock_);
+    removed_item = sinks_.Remove(
+        MediaStreamAudioTrackSink::WrapsMediaStreamSink(sink));
+  }
 
   // Clear the delegate to ensure that no more capture callbacks will
   // be sent to this sink. Also avoids a possible crash which can happen
   // if this method is called while capturing is active.
   if (removed_item.get())
     removed_item->Reset();
 }
 
 void WebRtcLocalAudioTrack::AddSink(PeerConnectionAudioSink* sink) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
@@ skipping 45 matching lines @@
     base::AutoLock auto_lock(lock_);
     sinks = sinks_.Items();
   }
   for (SinkList::ItemList::const_iterator it = sinks.begin();
        it != sinks.end();
        ++it) {
     (*it)->OnReadyStateChanged(blink::WebMediaStreamSource::ReadyStateLive);
   }
 }
 
+void WebRtcLocalAudioTrack::SetEnabled(bool enabled) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (adapter_.get())
+    adapter_->set_enabled(enabled);
+}
+
 void WebRtcLocalAudioTrack::Stop() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::Stop()";
   if (!capturer_.get() && !webaudio_source_.get())
     return;
 
   if (webaudio_source_.get()) {
     // Called Stop() on the |webaudio_source_| explicitly so that
     // |webaudio_source_| won't push more data to the track anymore.
     // Also note that the track is not registered as a sink to the |capturer_|
@@ skipping 17 matching lines @@
   }
 
   for (SinkList::ItemList::const_iterator it = sinks.begin();
        it != sinks.end();
        ++it){
     (*it)->OnReadyStateChanged(blink::WebMediaStreamSource::ReadyStateEnded);
     (*it)->Reset();
   }
 }
 
+webrtc::AudioTrackInterface* WebRtcLocalAudioTrack::GetAudioAdapter() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return adapter_.get();
+}
+
 }  // namespace content