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.

[henrika (OOO until Aug 14), 2013/08/26 11:34:55]

TODO()?

[tommi (sloooow) - chröme, 2013/08/27 10:58:22]

This isn't really a todo but more of an explanation to the reader about the
status quo.  Once the spec has been changed to have the constraints property on
the track and not the source, this will have to be changed.  If we're lucky line
388 will just replace the word 'source' with 'track' in this case, but there's
ton of code all over the place that will need to be changed, starting with
Blink/WebKit.

+  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