Add support for echoCancellation and deviceId to MediaStreamTrack.getSettings

content/renderer/media/user_media_client_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/user_media_client_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 214 matching lines @@
          source == kMediaStreamSourceDesktop ||
          source == kMediaStreamSourceSystem;
 }
 
 bool IsValidVideoContentSource(const std::string& source) {
   return source == kMediaStreamSourceTab ||
          source == kMediaStreamSourceDesktop ||
          source == kMediaStreamSourceScreen;
 }
 
+void SetHardwareEchoCancellationSetting(blink::WebMediaStreamSource* source) {

[hbos_chromium, 2017/07/04 15:26:49]

Should this be generalized and/or renamed, e.g. SurfaceAudioParamsSettings or
SurfaceHardwareEchoCancellationSetting?
"Set" makes it sound like the value is always updated to reflect the hw value,
when in truth it only sets it to true if it has that effect. It could already be
true due to sw. Please add a comment.

Is this logic specific to ECHO_CANCELLER or would the code look the same for any
AudioParameters that are of interest (e.g. set if true, leave old value
otherwise)?

[Guido Urdaneta, 2017/07/05 09:23:36]

This would probably be the place for future settings that depend on parameters.
However, I prefer to wait until we implement those features before renaming to a
more generic name.
Renamed to SurfaceHardwareEchoCancellationSetting for now.

+  MediaStreamAudioSource* source_impl =
+      static_cast<MediaStreamAudioSource*>(source->GetExtraData());
+  media::AudioParameters params = source_impl->GetAudioParameters();
+  if (params.IsValid() &&
+      (params.effects() & media::AudioParameters::ECHO_CANCELLER))
+    source->SetEchoCancellation(true);
+}
+
 static int g_next_request_id = 0;
 
 }  // namespace
 
 // Class for storing information about a Blink request to create a
 // MediaStream.
 class UserMediaClientImpl::UserMediaRequestInfo
     : public base::SupportsWeakPtr<UserMediaRequestInfo> {
  public:
   using ResourcesReady =
@@ skipping 716 matching lines @@
 
   // While sources are being initialized, keep them in a separate array.
   // Once they've finished initialized, they'll be moved over to local_sources_.
   // See OnAudioSourceStarted for more details.
   pending_local_sources_.push_back(source);
 
   MediaStreamSource::ConstraintsCallback source_ready = base::Bind(
       &UserMediaClientImpl::OnAudioSourceStartedOnAudioThread,
       base::ThreadTaskRunnerHandle::Get(), weak_factory_.GetWeakPtr());
 
-  MediaStreamAudioSource* const audio_source =
-      CreateAudioSource(device, constraints, source_ready);
+  bool has_sw_echo_cancellation = false;
+  MediaStreamAudioSource* const audio_source = CreateAudioSource(
+      device, constraints, source_ready, &has_sw_echo_cancellation);
   audio_source->SetStopCallback(base::Bind(
       &UserMediaClientImpl::OnLocalSourceStopped, weak_factory_.GetWeakPtr()));
   source.SetExtraData(audio_source);  // Takes ownership.
+  // If the hardware has echo cancellation, the value is updated in
+  // CreateAudioTracks(), after the track has started.

[hbos_chromium, 2017/07/04 15:26:48]

Could you clarify that the reason we don't set it here is because we don't know
that yet.

[Guido Urdaneta, 2017/07/05 09:23:37]

Done.

+  source.SetEchoCancellation(has_sw_echo_cancellation);
   return source;
 }
 
 MediaStreamAudioSource* UserMediaClientImpl::CreateAudioSource(
     const StreamDeviceInfo& device,
     const blink::WebMediaConstraints& constraints,
-    const MediaStreamSource::ConstraintsCallback& source_ready) {
+    const MediaStreamSource::ConstraintsCallback& source_ready,
+    bool* has_sw_echo_cancellation) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(current_request_info_);
   // If the audio device is a loopback device (for screen capture), or if the
   // constraints/effects parameters indicate no audio processing is needed,
   // create an efficient, direct-path MediaStreamAudioSource instance.
   AudioProcessingProperties audio_processing_properties =
       IsOldAudioConstraints() ? AudioProcessingProperties::FromConstraints(
                                     constraints, device.device.input)
                               : current_request_info_->audio_capture_settings()
                                     .audio_processing_properties();
   if (IsScreenCaptureMediaType(device.device.type) ||
       !MediaStreamAudioProcessor::WouldModifyAudio(
           audio_processing_properties)) {
+    *has_sw_echo_cancellation = false;
     return new LocalMediaStreamAudioSource(RenderFrameObserver::routing_id(),
                                            device, source_ready);
   }
 
   // The audio device is not associated with screen capture and also requires
   // processing.
   ProcessedLocalAudioSource* source = new ProcessedLocalAudioSource(
       RenderFrameObserver::routing_id(), device, audio_processing_properties,
       source_ready, dependency_factory_);
+  *has_sw_echo_cancellation =
+      audio_processing_properties.enable_sw_echo_cancellation;
   return source;
 }
 
 MediaStreamVideoSource* UserMediaClientImpl::CreateVideoSource(
     const StreamDeviceInfo& device,
     const MediaStreamSource::SourceStoppedCallback& stop_callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(current_request_info_);
   if (IsOldVideoConstraints()) {
     return new MediaStreamVideoCapturerSource(stop_callback, device,
@@ skipping 48 matching lines @@
           MediaStreamDevice::AudioDeviceParameters();
     }
   }
 
   for (size_t i = 0; i < overridden_audio_array.size(); ++i) {
     bool is_pending = false;
     blink::WebMediaStreamSource source = InitializeAudioSourceObject(
         overridden_audio_array[i], constraints, &is_pending);
     (*webkit_tracks)[i].Initialize(source);
     current_request_info_->StartAudioTrack((*webkit_tracks)[i], is_pending);
+    SetHardwareEchoCancellationSetting(&source);

[hbos_chromium, 2017/07/04 15:26:48]

Add a comment saying the source's current value reflects if it has sw and it is
updated if we have hw (but the old value doesn't change otherwise)... if this
isn't clear from function name change.

[Guido Urdaneta, 2017/07/05 09:23:36]

Done.

   }
 }
 
 void UserMediaClientImpl::OnCreateNativeTracksCompleted(
     const std::string& label,
     UserMediaRequestInfo* request_info,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (result == content::MEDIA_DEVICE_OK) {
@@ skipping 462 matching lines @@
     const blink::WebString& result_name) {
   // Check if we're waiting to be notified of this source.  If not, then we'll
   // ignore the notification.
   auto found = std::find(sources_waiting_for_callback_.begin(),
                          sources_waiting_for_callback_.end(), source);
   if (found != sources_waiting_for_callback_.end())
     OnTrackStarted(source, result, result_name);
 }
 
 }  // namespace content