Split libjingle's signaling thread from the UI thread

content/renderer/media/webrtc_audio_device_impl.cc

 // Copyright 2013 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_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
@@ skipping 14 matching lines @@
       audio_transport_callback_(NULL),
       input_delay_ms_(0),
       output_delay_ms_(0),
       initialized_(false),
       playing_(false),
       recording_(false),
       microphone_volume_(0),
       is_audio_track_processing_enabled_(
           MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled()) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
-  // TODO(tommi):  This object can be constructed on either the signaling thread
-  // or the main thread.  As is, those threads are one and the same so we don't
-  // detach either thread checkers, but once they're separate, we need to detach
-  // here:
-  //   signaling_thread_checker_.DetachFromThread();
-  //   main_thread_checker_.DetachFromThread();
+  // This object can be constructed on either the signaling thread or the main
+  // thread, so we need to detach these thread checkers here and have them
+  // initialize automatically when the first methods are called.
+  signaling_thread_checker_.DetachFromThread();
+  main_thread_checker_.DetachFromThread();
 
   worker_thread_checker_.DetachFromThread();
 }
 
 WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl()";
   DCHECK(main_thread_checker_.CalledOnValidThread());
   Terminate();
 }
 
@@ skipping 316 matching lines @@
   // initialize worker_thread_checker_ on the signaling thread.
   DCHECK(signaling_thread_checker_.CalledOnValidThread() ||
          worker_thread_checker_.CalledOnValidThread());
 
   base::AutoLock auto_lock(lock_);
   recording_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Recording() const {
-  DCHECK(!main_thread_checker_.CalledOnValidThread());
-  DCHECK(!signaling_thread_checker_.CalledOnValidThread());
   DCHECK(worker_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   return recording_;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetMicrophoneVolume(uint32_t volume) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::SetMicrophoneVolume(" << volume << ")";
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
 
@@ skipping 124 matching lines @@
   base::AutoLock auto_lock(lock_);
   DCHECK(std::find(capturers_.begin(), capturers_.end(), capturer) ==
       capturers_.end());
   capturers_.push_back(capturer);
 }
 
 void WebRtcAudioDeviceImpl::RemoveAudioCapturer(
     const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
-  // Called on the main render thread.
   DCHECK(capturer.get());
   base::AutoLock auto_lock(lock_);
   capturers_.remove(capturer);
 }
 
 scoped_refptr<WebRtcAudioCapturer>
 WebRtcAudioDeviceImpl::GetDefaultCapturer() const {
-  // Called on either the signaling thread (during initialization) or worker
-  // thread during capture.
+  // Called on the signaling thread (during initialization), worker
+  // thread during capture or main thread for a WebAudio source.
+  // We can't DCHECK on those three checks here since GetDefaultCapturer
+  // may be the first call and therefore could incorrectly initialize the
+  // thread checkers.
   DCHECK(initialized_);
-  DCHECK(signaling_thread_checker_.CalledOnValidThread() ||
-         worker_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   // Use the last |capturer| which is from the latest getUserMedia call as
   // the default capture device.
   return capturers_.empty() ? NULL : capturers_.back();
 }
 
 void WebRtcAudioDeviceImpl::AddPlayoutSink(
     WebRtcPlayoutDataSource::Sink* sink) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(sink);
@@ skipping 20 matching lines @@
   // If there is no capturer or there are more than one open capture devices,
   // return false.
   if (capturers_.size() != 1)
     return false;
 
   return capturers_.back()->GetPairedOutputParameters(
       session_id, output_sample_rate, output_frames_per_buffer);
 }
 
 }  // namespace content