Ensures that WebRTC works for device selection using a different sample rate than default

content/renderer/media/media_stream_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 50 matching lines @@
       GetMandatoryStreamConstraint(user_media_request.videoConstraints(),
                                    kMediaStreamSource) ==
           kMediaStreamSourceTab) {
     options->video_type = content::MEDIA_TAB_VIDEO_CAPTURE;
     options->video_device_id = GetMandatoryStreamConstraint(
         user_media_request.videoConstraints(),
         kMediaStreamSourceId);
   }
 }
 
-// Get session ID for the selected microphone to ensure that we start
-// capturing audio using the correct input device.
-static int GetSessionId(const WebKit::WebMediaStreamSource& source) {
-  MediaStreamSourceExtraData* source_data =
-      static_cast<MediaStreamSourceExtraData*>(source.extraData());
-  if (!source_data) {
-    // TODO(henrika): Implement support for sources from remote MediaStreams.
-    NOTIMPLEMENTED();
-    return -1;
-  }
-  DVLOG(1) << "local audio track source name: "
-           << source_data->device_info().device.name;
-
-  return source_data->device_info().session_id;
-}
-
 static int g_next_request_id  = 0;
 
 // Creates a WebKit representation of a stream sources based on
 // |devices| from the MediaStreamDispatcher.
 void CreateWebKitSourceVector(
     const std::string& label,
     const StreamDeviceInfoArray& devices,
     WebKit::WebMediaStreamSource::Type type,
     WebKit::WebVector<WebKit::WebMediaStreamSource>& webkit_sources) {
   CHECK_EQ(devices.size(), webkit_sources.size());
@@ skipping 201 matching lines @@
         CreateRemoteAudioRenderer(extra_data->remote_stream());
 
     if (renderer &&
         dependency_factory_->GetWebRtcAudioDevice()->SetRenderer(renderer)) {
       return renderer;
     }
 
     // WebRtcAudioDeviceImpl can only support one renderer.
     return NULL;
   } else if (extra_data->local_stream()) {
-    DVLOG(1) << "creating local audio renderer for stream:"
-             << extra_data->local_stream()->label();
-
-    WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
-    descriptor.audioSources(audio_components);
-    if (audio_components.size() != 1) {
-      // TODO(henrika): add support for more than one audio track.
-      LOG(WARNING) << "Multiple MediaStream audio tracks not supported";
-      return NULL;
-    }
-
-    if (!audio_components[0].isEnabled()) {
-      DVLOG(1) << "audio track is disabled";
-      return NULL;
-    }
-
-    int session_id = 0;
-    const WebKit::WebMediaStreamSource& source = audio_components[0].source();
-    if (!source.requiresAudioConsumer()) {
-      session_id = GetSessionId(source);
-      if (session_id == -1) {
-        return NULL;
-      }
-    } else {
-      DVLOG(1) << "WebAudio MediaStream is detected";
-      session_id = -1;
-    }
-
-    // Create the local audio renderer using the specified session ID.
-    scoped_refptr<WebRtcLocalAudioRenderer> local_renderer =
-        CreateLocalAudioRenderer(session_id);
-    return local_renderer;
+    // Create the local audio renderer if the stream contains audio tracks.
+    return CreateLocalAudioRenderer(extra_data->local_stream());
   }
 
   NOTREACHED();
   return NULL;
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream have been generated by the MediaStreamDispatcher.
 void MediaStreamImpl::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const StreamDeviceInfoArray& audio_array,
     const StreamDeviceInfoArray& video_array) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << "MediaStreamImpl::OnStreamGenerated("
-           << request_id << "," << label << ")";
+  DVLOG(1) << "MediaStreamImpl::OnStreamGenerated stream:" << label;
 
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
     // This can happen if the request is canceled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     // We need to tell the dispatcher to stop the stream.
     media_stream_dispatcher_->StopStream(label);
     DVLOG(1) << "Request ID not found";
     return;
   }
@@ skipping 46 matching lines @@
                               &request_info->request,
                               false);
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDependencyFactory when the sources in |description|
 // have been generated.
 void MediaStreamImpl::OnCreateNativeSourcesComplete(
     WebKit::WebMediaStreamDescriptor* description,
     bool request_succeeded) {
+  DVLOG(1) << "MediaStreamImpl::OnCreateNativeSourcesComplete stream:"
+           << UTF16ToUTF8(description->label());
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(description);
   if (!request_info) {
     // This can happen if the request is canceled or the frame reloads while
     // MediaStreamDependencyFactory is creating the sources.
     DVLOG(1) << "Request ID not found";
     return;
   }
 
   // Create a native representation of the stream.
   if (request_succeeded) {
@@ skipping 166 matching lines @@
   if (!stream->audio_tracks() || stream->audio_tracks()->count() == 0)
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateRemoteAudioRenderer label:"
            << stream->label();
 
   return new WebRtcAudioRenderer(RenderViewObserver::routing_id());
 }
 
 scoped_refptr<WebRtcLocalAudioRenderer>
-MediaStreamImpl::CreateLocalAudioRenderer(int session_id) {
-  // Ensure that the existing capturer reads data from the selected microphone.
+MediaStreamImpl::CreateLocalAudioRenderer(
+    webrtc::MediaStreamInterface* stream) {
+  if (!stream->audio_tracks() || stream->audio_tracks()->count() == 0)
+    return NULL;
+
+  DVLOG(1) << "MediaStreamImpl::CreateLocalAudioRenderer label:"
+           << stream->label();
+
   scoped_refptr<WebRtcAudioCapturer> source =
       dependency_factory_->GetWebRtcAudioDevice()->capturer();
   if (!source) {
-    // The WebRtcAudioCapturer instance can be NULL e.g. if an unsupported
-    // sample rate is used.
-    // TODO(henrika): extend support of capture sample rates.
     return NULL;
   }
 
-  if (session_id != -1)
-    source->SetDevice(session_id);
-
   // Create a new WebRtcLocalAudioRenderer instance and connect it to the
   // existing WebRtcAudioCapturer so that the renderer can use it as source.
   return new WebRtcLocalAudioRenderer(source, RenderViewObserver::routing_id());
 }
 
 MediaStreamSourceExtraData::MediaStreamSourceExtraData(
     const StreamDeviceInfo& device_info)
     : device_info_(device_info) {
 }
 
+MediaStreamSourceExtraData::MediaStreamSourceExtraData(
+    media::AudioCapturerSource* source)
+    : audio_source_(source)  {
+}
+
 MediaStreamSourceExtraData::~MediaStreamSourceExtraData() {}
 
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::MediaStreamInterface* remote_stream)
     : remote_stream_(remote_stream) {
 }
 
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::LocalMediaStreamInterface* local_stream)
     : local_stream_(local_stream) {
 }
 
 MediaStreamExtraData::~MediaStreamExtraData() {
 }
 
 void MediaStreamExtraData::SetLocalStreamStopCallback(
     const StreamStopCallback& stop_callback) {
   stream_stop_callback_ = stop_callback;
 }
 
 void MediaStreamExtraData::OnLocalStreamStop() {
   if (!stream_stop_callback_.is_null())
     stream_stop_callback_.Run(local_stream_->label());
 }
 
 }  // namespace content