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 SurfaceHardwareEchoCancellationSetting(
+    blink::WebMediaStreamSource* source) {
+  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.
+  // At this point it is known if software echo cancellation will be used, but
+  // final audio parameters for the source are not set yet, so it is not yet
+  // known if hardware echo cancellation will actually be used. That information
+  // is known and surfaced in CreateAudioTracks(), after the track is connected
+  // to the source.
+  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_);
   DCHECK(current_request_info_->video_capture_settings().HasValue());
   return new MediaStreamVideoCapturerSource(
@@ skipping 43 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);
+    // At this point the source has started, and its audio parameters have been
+    // set. From the parameters, it is known if hardware echo cancellation is
+    // being used. If this is the case, let |source| know.
+    SurfaceHardwareEchoCancellationSetting(&source);
   }
 }
 
 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 455 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