Feed audio constraints over to WebRtcLocalAudioTrack

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/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 52 matching lines @@
     {webrtc::MediaConstraintsInterface::kEchoCancellation,
      webrtc::MediaConstraintsInterface::kValueTrue},
     {webrtc::MediaConstraintsInterface::kAutoGainControl,
      webrtc::MediaConstraintsInterface::kValueTrue},
     {webrtc::MediaConstraintsInterface::kNoiseSuppression,
      webrtc::MediaConstraintsInterface::kValueTrue},
     {webrtc::MediaConstraintsInterface::kHighpassFilter,
      webrtc::MediaConstraintsInterface::kValueTrue},
 };
 
-class WebAudioConstraints : public RTCMediaConstraints {
- public:
-  WebAudioConstraints()
-      : RTCMediaConstraints(WebKit::WebMediaConstraints()) {
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kWebAudioConstraints); ++i) {
-      webrtc::MediaConstraintsInterface::Constraint constraint;
-      constraint.key = kWebAudioConstraints[i].key;
-      constraint.value = kWebAudioConstraints[i].value;
-
-      DVLOG(1) << "WebAudioConstraints: " << constraint.key
-               << " : " <<  constraint.value;
-      mandatory_.push_back(constraint);
-    }
+void ApplyFixedWebAudioConstraints(RTCMediaConstraints* constraints) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kWebAudioConstraints); ++i) {
+    constraints->AddMandatory(kWebAudioConstraints[i].key,
+        kWebAudioConstraints[i].value, false);
   }
-
-  virtual ~WebAudioConstraints() {}
-};
+}
 
 class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface {
  public:
   P2PPortAllocatorFactory(
       P2PSocketDispatcher* socket_dispatcher,
       talk_base::NetworkManager* network_manager,
       talk_base::PacketSocketFactory* socket_factory,
       WebKit::WebFrame* web_frame)
       : socket_dispatcher_(socket_dispatcher),
         network_manager_(network_manager),
@@ skipping 218 matching lines @@
 
     // TODO(xians): Create a new capturer for difference microphones when we
     // support multiple microphones. See issue crbug/262117 .
     const StreamDeviceInfo device_info = source_data->device_info();
     scoped_refptr<WebRtcAudioCapturer> capturer(
         MaybeCreateAudioCapturer(render_view_id, device_info));
     if (!capturer.get()) {
       DLOG(WARNING) << "Failed to create the capturer for device "
                     << device_info.device.id;
       sources_created.Run(web_stream, false);
+      // TODO(xians): Don't we need to check if source_observer is observing
+      // something? If not, then it looks like we have a leak here.
+      // OTOH, if it _is_ observing something, then the callback might
+      // be called multiple times which is likely also a bug.
       return;
     }
 
     // Creates a LocalAudioSource object which holds audio options.
     // TODO(xians): The option should apply to the track instead of the source.
     source_data->SetLocalAudioSource(
         CreateLocalAudioSource(&native_audio_constraints).get());
     source_observer->AddSource(source_data->local_audio_source());
   }
 
@@ skipping 45 matching lines @@
       const WebKit::WebMediaStreamTrack& track) {
   MediaStreamExtraData* extra_data =
      static_cast<MediaStreamExtraData*>(stream.extraData());
   webrtc::MediaStreamInterface* native_stream = extra_data->stream().get();
   DCHECK(native_stream);
 
   WebKit::WebMediaStreamSource source = track.source();
   MediaStreamSourceExtraData* source_data =
       static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
+  // In the future the constraints will belong to the track itself, but
+  // right now they're on the source, so we fetch them from there.
+  RTCMediaConstraints track_constraints(source.constraints());
+
   scoped_refptr<WebRtcAudioCapturer> capturer;
   if (!source_data) {
     if (source.requiresAudioConsumer()) {
       // We're adding a WebAudio MediaStream.
       // Create a specific capturer for each WebAudio consumer.
-      capturer = CreateWebAudioSource(&source);
+      capturer = CreateWebAudioSource(&source, &track_constraints);
       source_data =
           static_cast<MediaStreamSourceExtraData*>(source.extraData());
     } else {
       // TODO(perkj): Implement support for sources from
       // remote MediaStreams.
       NOTIMPLEMENTED();
       return false;
     }
   }
 
   WebKit::WebMediaStreamSource::Type type = track.source().type();
   DCHECK(type == WebKit::WebMediaStreamSource::TypeAudio ||
          type == WebKit::WebMediaStreamSource::TypeVideo);
 
   std::string track_id = UTF16ToUTF8(track.id());
   if (source.type() == WebKit::WebMediaStreamSource::TypeAudio) {
     if (!capturer.get() && GetWebRtcAudioDevice())
       capturer = GetWebRtcAudioDevice()->GetDefaultCapturer();
 
     scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         CreateLocalAudioTrack(track_id,
                               capturer,
-                              source_data->local_audio_source()));
+                              source_data->local_audio_source(),
+                              &track_constraints));
     audio_track->set_enabled(track.isEnabled());
     return native_stream->AddTrack(audio_track.get());
   } else {
     DCHECK(source.type() == WebKit::WebMediaStreamSource::TypeVideo);
     scoped_refptr<webrtc::VideoTrackInterface> video_track(
         CreateLocalVideoTrack(track_id, source_data->video_source()));
     video_track->set_enabled(track.isEnabled());
     return native_stream->AddTrack(video_track.get());
   }
 }
@@ skipping 159 matching lines @@
       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;
 }
 
 scoped_refptr<WebRtcAudioCapturer>
 MediaStreamDependencyFactory::CreateWebAudioSource(
-    WebKit::WebMediaStreamSource* source) {
+    WebKit::WebMediaStreamSource* source,
+    RTCMediaConstraints* constraints) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateWebAudioSource()";
   DCHECK(GetWebRtcAudioDevice());
 
   // Set up the source and ensure that WebAudio is driving things instead of
   // a microphone. For WebAudio, we always create a new capturer without
   // calling initialize(), WebAudio will re-configure the capturer later on.
   // Pass -1 as the |render_view_id| and an empty device struct to tell the
   // capturer not to start the default source.
   scoped_refptr<WebRtcAudioCapturer> capturer(
       MaybeCreateAudioCapturer(-1, StreamDeviceInfo()));
   DCHECK(capturer.get());
 
   scoped_refptr<WebAudioCapturerSource>
       webaudio_capturer_source(new WebAudioCapturerSource(capturer.get()));
   MediaStreamSourceExtraData* source_data =
       new content::MediaStreamSourceExtraData(webaudio_capturer_source.get());
 
   // Create a LocalAudioSource object which holds audio options.
   // Use audio constraints where all values are true, i.e., enable
   // echo cancellation, automatic gain control, noise suppression and
   // high-pass filter. SetLocalAudioSource() affects core audio parts in
   // third_party/Libjingle.
-  WebAudioConstraints webaudio_audio_constraints_all_true;
-  source_data->SetLocalAudioSource(
-      CreateLocalAudioSource(&webaudio_audio_constraints_all_true).get());
+  ApplyFixedWebAudioConstraints(constraints);
+  source_data->SetLocalAudioSource(CreateLocalAudioSource(constraints).get());
   source->setExtraData(source_data);
 
   // Replace the default source with WebAudio as source instead.
   source->addAudioConsumer(webaudio_capturer_source.get());
 
   return capturer;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
@@ skipping 15 matching lines @@
       pc_factory_->CreateVideoSource(capturer, NULL).get();
 
   // Create native track from the source.
   return pc_factory_->CreateVideoTrack(id, source.get()).get();
 }
 
 scoped_refptr<webrtc::AudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
     const scoped_refptr<WebRtcAudioCapturer>& capturer,
-    webrtc::AudioSourceInterface* source) {
+    webrtc::AudioSourceInterface* source,
+    const webrtc::MediaConstraintsInterface* constraints) {
   // TODO(xians): Merge |source| to the capturer(). We can't do this today
   // because only one capturer() is supported while one |source| is created
   // for each audio track.
   scoped_refptr<WebRtcLocalAudioTrack> audio_track(
-      WebRtcLocalAudioTrack::Create(id, capturer, source));
+      WebRtcLocalAudioTrack::Create(id, capturer, source, constraints));
   // Add the WebRtcAudioDevice as the sink to the local audio track.
   audio_track->AddSink(GetWebRtcAudioDevice());
   // Start the audio track. This will hook the |audio_track| to the capturer
   // as the sink of the audio, and only start the source of the capturer if
   // it is the first audio track connecting to the capturer.
   audio_track->Start();
   return audio_track;
 }
 
 webrtc::SessionDescriptionInterface*
@@ skipping 145 matching lines @@
   }
 
   // Add the capturer to the WebRtcAudioDeviceImpl if it is a new capturer.
   if (is_new_capturer)
     GetWebRtcAudioDevice()->AddAudioCapturer(capturer);
 
   return capturer;
 }
 
 }  // namespace content