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

content/renderer/media/media_stream_dependency_factory.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/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
@@ skipping 444 matching lines @@
 
   // The video source takes ownership of |capturer|.
   scoped_refptr<webrtc::VideoSourceInterface> source =
       pc_factory_->CreateVideoSource(capturer, constraints).get();
   return source;
 }
 
 bool MediaStreamDependencyFactory::InitializeAudioSource(
   const StreamDeviceInfo& device_info) {
   DVLOG(1) << "MediaStreamDependencyFactory::InitializeAudioSource()";
-  const MediaStreamDevice device = device_info.device;
+
+  // TODO(henrika): the current design does not support a unique source
+  // for each audio track.
+  if (device_info.session_id <= 0)
+    return false;
 
   // Initialize the source using audio parameters for the selected
   // capture device.
   WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
   // TODO(henrika): refactor \content\public\common\media_stream_request.h
   // to allow dependency of media::ChannelLayout and avoid static_cast.
   if (!capturer->Initialize(
-          static_cast<media::ChannelLayout>(device.channel_layout),
-          device.sample_rate))
+          static_cast<media::ChannelLayout>(device_info.device.channel_layout),
+          device_info.device.sample_rate, device_info.session_id))
     return false;
 
-  // Specify which capture device to use. The acquired session id is used
-  // for identification.
-  // TODO(henrika): the current design does not support a uniqe source
-  // for each audio track.
-  if (device_info.session_id <= 0)
-    return false;
-
-  capturer->SetDevice(device_info.session_id);
   return true;
 }
 
 bool MediaStreamDependencyFactory::CreateWebAudioSource(
     WebKit::WebMediaStreamSource* source) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateWebAudioSource()";
   DCHECK(GetWebRtcAudioDevice());
 
   // WebAudio needs the WebRtcAudioCapturer to be able to send its data
   // over a PeerConnection. The microphone source is not utilized in this
@@ skipping 53 matching lines @@
     int sdp_mline_index,
     const std::string& sdp) {
   return webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, sdp);
 }
 
 WebRtcAudioDeviceImpl*
 MediaStreamDependencyFactory::GetWebRtcAudioDevice() {
   return audio_device_;
 }
 
+void MediaStreamDependencyFactory::StopLocalAudioSource(
+    const WebKit::WebMediaStream& description) {
+  MediaStreamExtraData* extra_data = static_cast<MediaStreamExtraData*>(
+      description.extraData());
+  if (extra_data && extra_data->is_local() && extra_data->stream() &&
+      !extra_data->stream()->GetAudioTracks().empty()) {
+    if (GetWebRtcAudioDevice()) {
+      scoped_refptr<WebRtcAudioCapturer> capturer =
+          GetWebRtcAudioDevice()->capturer();
+      if (capturer)
+        capturer->Stop();
+    }
+  }
+}
+
 void MediaStreamDependencyFactory::InitializeWorkerThread(
     talk_base::Thread** thread,
     base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread(
@@ skipping 84 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content