Do not pass the string device_id via IPC message to create an audio input stream

content/renderer/media/webrtc_audio_capturer.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_audio_capturer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 60 matching lines @@
       public WebRtcAudioCapturerSink {
  public:
   explicit SinkOwner(WebRtcAudioCapturerSink* sink);
 
   virtual void CaptureData(const int16* audio_data,
                            int number_of_channels,
                            int number_of_frames,
                            int audio_delay_milliseconds,
                            double volume) OVERRIDE;
   virtual void SetCaptureFormat(const media::AudioParameters& params) OVERRIDE;
-  virtual void OnCaptureDeviceStopped() OVERRIDE;
 
   bool IsEqual(const WebRtcAudioCapturerSink* other) const;
   void Reset();
 
   // Wrapper which allows to use std::find_if() when adding and removing
   // sinks to/from the list.
   struct WrapsSink {
     WrapsSink(WebRtcAudioCapturerSink* sink) : sink_(sink) {}
     bool operator()(
         const scoped_refptr<WebRtcAudioCapturer::SinkOwner>& owner) {
@@ skipping 27 matching lines @@
   }
 }
 
 void WebRtcAudioCapturer::SinkOwner::SetCaptureFormat(
     const media::AudioParameters& params) {
   base::AutoLock lock(lock_);
   if (delegate_)
     delegate_->SetCaptureFormat(params);
 }
 
-void WebRtcAudioCapturer::SinkOwner::OnCaptureDeviceStopped() {
-  base::AutoLock lock(lock_);
-  if (delegate_)
-    delegate_->OnCaptureDeviceStopped();
-}
-
 bool WebRtcAudioCapturer::SinkOwner::IsEqual(
     const WebRtcAudioCapturerSink* other) const {
   base::AutoLock lock(lock_);
   return (other == delegate_);
 }
 
 void WebRtcAudioCapturer::SinkOwner::Reset() {
   base::AutoLock lock(lock_);
   delegate_ = NULL;
 }
@@ skipping 60 matching lines @@
   }
 
   // Tell all sinks which format we use.
   for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it)
     (*it)->SetCaptureFormat(new_buffer->params());
 
   return true;
 }
 
 bool WebRtcAudioCapturer::Initialize(media::ChannelLayout channel_layout,
-                                     int sample_rate) {
+                                     int sample_rate,
+                                     int session_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!sinks_.empty());
   DVLOG(1) << "WebRtcAudioCapturer::Initialize()";
 
   DVLOG(1) << "Audio input hardware channel layout: " << channel_layout;
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
                             channel_layout, media::CHANNEL_LAYOUT_MAX);
 
+  session_id_ = session_id;
+
   // Verify that the reported input channel configuration is supported.
   if (channel_layout != media::CHANNEL_LAYOUT_MONO &&
       channel_layout != media::CHANNEL_LAYOUT_STEREO) {
     DLOG(ERROR) << channel_layout
                 << " is not a supported input channel configuration.";
     return false;
   }
 
   DVLOG(1) << "Audio input hardware sample rate: " << sample_rate;
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputSampleRate",
                             sample_rate, media::kUnexpectedAudioSampleRate);
 
   // Verify that the reported input hardware sample rate is supported
   // on the current platform.
   if (std::find(&kValidInputRates[0],
                 &kValidInputRates[0] + arraysize(kValidInputRates),
                 sample_rate) ==
           &kValidInputRates[arraysize(kValidInputRates)]) {
     DLOG(ERROR) << sample_rate << " is not a supported input rate.";
     return false;
   }
 
   if (!Reconfigure(sample_rate, channel_layout))
     return false;
 
   // Create and configure the default audio capturing source. The |source_|
   // will be overwritten if an external client later calls SetCapturerSource()
-  // providing an alternaive media::AudioCapturerSource.
+  // providing an alternative media::AudioCapturerSource.
   SetCapturerSource(AudioDeviceFactory::NewInputDevice(),
                     channel_layout,
                     static_cast<float>(sample_rate));
 
   return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer()
-    : main_loop_(base::MessageLoopProxy::current()),
-      source_(NULL),
+    : source_(NULL),
       running_(false),
-      agc_is_enabled_(false) {
+      agc_is_enabled_(false),
+      session_id_(0) {
   DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
 
 WebRtcAudioCapturer::~WebRtcAudioCapturer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(sinks_.empty());
   DCHECK(!running_);
   DVLOG(1) << "WebRtcAudioCapturer::~WebRtcAudioCapturer()";
 }
 
@@ skipping 26 matching lines @@
     (*it)->Reset();
     sinks_.erase(it);
   }
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
     float sample_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  CHECK_GT(session_id_, 0);
   DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
            << "sample_rate=" << sample_rate << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
   scoped_refptr<ConfiguredBuffer> current_buffer;
   {
     base::AutoLock auto_lock(lock_);
     if (source_ == source)
       return;
 
     source_.swap(old_source);
@@ skipping 19 matching lines @@
       return;
     } else {
       // The buffer has been reconfigured.  Update |current_buffer|.
       base::AutoLock auto_lock(lock_);
       current_buffer = buffer_;
     }
   }
 
   if (source) {
     // Make sure to grab the new parameters in case they were reconfigured.
-    source->Initialize(current_buffer->params(), this, this);
+    source->Initialize(current_buffer->params(), this, session_id_);
   }
 }
 
 void WebRtcAudioCapturer::Start() {
   DVLOG(1) << "WebRtcAudioCapturer::Start()";
   base::AutoLock auto_lock(lock_);
   if (running_)
     return;
 
   // Start the data source, i.e., start capturing data from the current source.
@@ skipping 23 matching lines @@
     source->Stop();
 }
 
 void WebRtcAudioCapturer::SetVolume(double volume) {
   DVLOG(1) << "WebRtcAudioCapturer::SetVolume()";
   base::AutoLock auto_lock(lock_);
   if (source_)
     source_->SetVolume(volume);
 }
 
-void WebRtcAudioCapturer::SetDevice(int session_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "WebRtcAudioCapturer::SetDevice(" << session_id << ")";
-  base::AutoLock auto_lock(lock_);
-  if (source_)
-    source_->SetDevice(session_id);
-}
-
 void WebRtcAudioCapturer::SetAutomaticGainControl(bool enable) {
   base::AutoLock auto_lock(lock_);
   // Store the setting since SetAutomaticGainControl() can be called before
   // Initialize(), in this case stored setting will be applied in Start().
   agc_is_enabled_ = enable;
 
   if (source_)
     source_->SetAutomaticGainControl(enable);
 }
 
@@ skipping 32 matching lines @@
     (*it)->CaptureData(buffer_ref_while_calling->buffer(),
                        audio_source->channels(), audio_source->frames(),
                        audio_delay_milliseconds, volume);
   }
 }
 
 void WebRtcAudioCapturer::OnCaptureError() {
   NOTIMPLEMENTED();
 }
 
-void WebRtcAudioCapturer::OnDeviceStarted(const std::string& device_id) {
-  device_id_ = device_id;
-}
-
-void WebRtcAudioCapturer::OnDeviceStopped() {
-  DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
-  main_loop_->PostTask(
-      FROM_HERE, base::Bind(&WebRtcAudioCapturer::DoOnDeviceStopped, this));
-}
-
-// TODO(henrika): this implementation should be removed as soon as we add
-// suppport for proper handling of LocalMediaStream::stop().
-void WebRtcAudioCapturer::DoOnDeviceStopped() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "WebRtcAudioCapturer::DoOnDeviceStopped()";
-  SinkList sinks;
-  {
-    base::AutoLock auto_lock(lock_);
-    running_ = false;
-    sinks = sinks_;
-  }
-
-  // Inform registered sinks about the stopped device so they can take
-  // appropriate actions.
-  for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it)
-    (*it)->OnCaptureDeviceStopped();
-}
-
 media::AudioParameters WebRtcAudioCapturer::audio_parameters() const {
   base::AutoLock auto_lock(lock_);
   return buffer_->params();
 }
 
 }  // namespace content