Implement audio constraints for PeerConneciton API

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 200 matching lines @@
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data) {
       // TODO(perkj): Implement support for sources from remote MediaStreams.
       NOTIMPLEMENTED();
       continue;
     }
     const bool is_screencast = (source_data->device_info().device.type ==
         content::MEDIA_TAB_VIDEO_CAPTURE);
     source_data->SetVideoSource(
-        CreateVideoSource(source_data->device_info().session_id,
-                          is_screencast,
-                          &native_video_constraints));
+        CreateLocalVideoSource(source_data->device_info().session_id,
+                               is_screencast,
+                               &native_video_constraints));
     source_observer->AddSource(source_data->video_source());
   }
 
   // Do additional source initialization if the audio source is a valid
   // microphone or tab audio.
+  RTCMediaConstraints native_audio_constraints(audio_constraints);
   WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
   description->audioSources(audio_components);
   for (size_t i = 0; i < audio_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = audio_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data) {
       // TODO(henrika): Implement support for sources from remote MediaStreams.
       NOTIMPLEMENTED();
       continue;
     }
 
     const StreamDeviceInfo device_info = source_data->device_info();
     if (IsAudioMediaType(device_info.device.type)) {
       if (!InitializeAudioSource(device_info)) {
         DLOG(WARNING) << "Unsupported audio source";
         sources_created.Run(description, false);
         return;
       }
     }
+
+    // Creates a LocalAudioSource object which holds audio options.
+    source_data->SetLocalAudioSource(
+        CreateLocalAudioSource(&native_audio_constraints));
+    source_observer->AddSource(source_data->local_audio_source());
   }
 
   source_observer->StartObservering();
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     WebKit::WebMediaStreamDescriptor* description) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
   if (!EnsurePeerConnectionFactory()) {
       DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
@@ skipping 10 matching lines @@
 
   for (size_t i = 0; i < audio_components.size(); ++i) {
     WebKit::WebMediaStreamSource source = audio_components[i].source();
 
     // See if we're adding a WebAudio MediaStream.
     if (source.requiresAudioConsumer()) {
       // TODO(crogers, xians): In reality we should be able to send a unique
       // audio stream to each PeerConnection separately.  But currently WebRTC
       // is only able to handle a global audio stream sent to ALL peers.
 
-      // TODO(henrika): refactor and utilize audio constraints.
+      // TODO(henrika): Refactor and utilize audio constraints. Audio
+      // constraints are passed via LocalAudioSource.
       if (CreateWebAudioSource(&source)) {
         scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
-            CreateLocalAudioTrack(UTF16ToUTF8(audio_components[i].id()), NULL));
+            CreateLocalAudioTrack(UTF16ToUTF8(audio_components[i].id()),
+                                  NULL));
         native_stream->AddTrack(audio_track);
         audio_track->set_enabled(audio_components[i].isEnabled());
       } else {
         DLOG(WARNING) << "Failed to create WebAudio source";
       }
     } else {
         MediaStreamSourceExtraData* source_data =
             static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
         if (!source_data) {
           // TODO(perkj): Implement support for sources from
           // remote MediaStreams.
           NOTIMPLEMENTED();
           continue;
         }
 
-        // TODO(perkj): Refactor the creation of audio tracks to use a proper
-        // interface for receiving audio input data. Currently NULL is passed
-        // since the |audio_device| is the wrong class and is unused.
         scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
-            CreateLocalAudioTrack(UTF16ToUTF8(source.id()), NULL));
+            CreateLocalAudioTrack(UTF16ToUTF8(source.id()),
+                                  source_data->local_audio_source()));
         native_stream->AddTrack(audio_track);
         audio_track->set_enabled(audio_components[i].isEnabled());
     }
   }
 
   // Add video tracks.
   WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
   description->videoSources(video_components);
   for (size_t i = 0; i < video_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = video_components[i].source();
@@ skipping 65 matching lines @@
   return pc_factory_->CreatePeerConnection(
       ice_servers, constraints, pa_factory, observer).get();
 }
 
 scoped_refptr<webrtc::LocalMediaStreamInterface>
 MediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return pc_factory_->CreateLocalMediaStream(label).get();
 }
 
+scoped_refptr<webrtc::AudioSourceInterface>
+MediaStreamDependencyFactory::CreateLocalAudioSource(
+    const webrtc::MediaConstraintsInterface* constraints) {
+  scoped_refptr<webrtc::AudioSourceInterface> source =
+      pc_factory_->CreateAudioSource(constraints).get();
+  return source;
+}
+
 scoped_refptr<webrtc::VideoSourceInterface>
-MediaStreamDependencyFactory::CreateVideoSource(
+MediaStreamDependencyFactory::CreateLocalVideoSource(
     int video_session_id,
     bool is_screencast,
     const webrtc::MediaConstraintsInterface* constraints) {
   RtcVideoCapturer* capturer = new RtcVideoCapturer(
       video_session_id, vc_manager_.get(), is_screencast);
 
   // The video source takes ownership of |capturer|.
   scoped_refptr<webrtc::VideoSourceInterface> source =
       pc_factory_->CreateVideoSource(capturer, constraints).get();
   return source;
@@ skipping 51 matching lines @@
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& label,
     webrtc::VideoSourceInterface* source) {
   return pc_factory_->CreateVideoTrack(label, source).get();
 }
 
 scoped_refptr<webrtc::LocalAudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& label,
-    webrtc::AudioDeviceModule* audio_device) {
-  return pc_factory_->CreateLocalAudioTrack(label, audio_device).get();
+    webrtc::AudioSourceInterface* source) {
+  return pc_factory_->CreateAudioTrack(label, source).get();
 }
 
 webrtc::SessionDescriptionInterface*
 MediaStreamDependencyFactory::CreateSessionDescription(const std::string& type,
                                                        const std::string& sdp) {
   return webrtc::CreateSessionDescription(type, sdp);
 }
 
 webrtc::IceCandidateInterface* MediaStreamDependencyFactory::CreateIceCandidate(
     const std::string& sdp_mid,
@@ skipping 98 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