Enable new getUserMedia audio constraints algorithm behind a flag.

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>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/local_media_stream_audio_source.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
+#include "content/renderer/media/media_stream_constraints_util_audio.h"
 #include "content/renderer/media/media_stream_constraints_util_video_content.h"
 #include "content/renderer/media/media_stream_constraints_util_video_device.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/webrtc/processed_local_audio_source.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/capture/video_capture_types.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 namespace content {
 namespace {
 
 void CopyFirstString(const blink::StringConstraint& constraint,
                      std::string* destination) {
   if (!constraint.Exact().IsEmpty())
     *destination = constraint.Exact()[0].Utf8();
 }
 
+// TODO(guidou): Remove this function. http://crbug.com/706408
 bool FindDeviceId(const blink::WebVector<blink::WebString> candidates,
                   const MediaDeviceInfoArray& device_infos,
                   std::string* device_id) {
   for (const auto& candidate : candidates) {
     auto it = std::find_if(device_infos.begin(), device_infos.end(),
                            [&candidate](const MediaDeviceInfo& info) {
                              return info.device_id == candidate.Utf8();
                            });
 
     if (it != device_infos.end()) {
@@ skipping 10 matching lines @@
 // false. If such a device is not found in |device_infos|, the function returns
 // false and |*device_id| is left unmodified.
 // If more than one device ID is requested as an exact basic constraint in
 // |constraint|, the function returns false and |*device_id| is left unmodified.
 // If no device ID is requested as an exact basic constraint, and at least one
 // device ID requested as an ideal basic constraint or as an exact or ideal
 // advanced constraint in |constraints| is found in |device_infos|, the first
 // such device ID is copied to |*device_id| and the function returns true.
 // If no such device ID is found, |*device_id| is left unmodified and the
 // function returns true.
-// TODO(guidou): Replace with a spec-compliant selection algorithm. See
-// http://crbug.com/657733.
+// TODO(guidou): Remove this function. http://crbug.com/706408
 bool PickDeviceId(const blink::WebMediaConstraints& constraints,
                   const MediaDeviceInfoArray& device_infos,
                   std::string* device_id) {
   DCHECK(!constraints.IsNull());
   DCHECK(device_id->empty());
 
   if (constraints.Basic().device_id.Exact().size() > 1) {
     LOG(ERROR) << "Only one required device ID is supported";
     return false;
   }
@@ skipping 22 matching lines @@
   }
 
   // No valid alternate device ID found. Select default device.
   return true;
 }
 
 bool IsDeviceSource(const std::string& source) {
   return source.empty();
 }
 
-// TODO(guidou): Remove once audio constraints are processed with spec-compliant
-// algorithm. See http://crbug.com/657733.
+// TODO(guidou): Remove this function. http://crbug.com/706408
 void CopyConstraintsToTrackControls(
     const blink::WebMediaConstraints& constraints,
     TrackControls* track_controls,
     bool* request_devices) {
   DCHECK(!constraints.IsNull());
   track_controls->requested = true;
   CopyFirstString(constraints.Basic().media_stream_source,
                   &track_controls->stream_source);
   if (IsDeviceSource(track_controls->stream_source)) {
     bool request_devices_advanced = false;
@@ skipping 12 matching lines @@
 }
 
 void InitializeTrackControls(const blink::WebMediaConstraints& constraints,
                              TrackControls* track_controls) {
   DCHECK(!constraints.IsNull());
   track_controls->requested = true;
   CopyFirstString(constraints.Basic().media_stream_source,
                   &track_controls->stream_source);
 }
 
+// TODO(guidou): Remove this function. http://crbug.com/706408
 void CopyHotwordAndLocalEchoToStreamControls(
     const blink::WebMediaConstraints& audio_constraints,
     StreamControls* controls) {
   if (audio_constraints.IsNull())
     return;
 
   if (audio_constraints.Basic().hotword_enabled.HasExact()) {
     controls->hotword_enabled =
         audio_constraints.Basic().hotword_enabled.Exact();
   } else {
@@ skipping 42 matching lines @@
     case MEDIA_DEVICE_TYPE_VIDEO_INPUT:
       return blink::WebMediaDeviceInfo::kMediaDeviceKindVideoInput;
     case MEDIA_DEVICE_TYPE_AUDIO_OUTPUT:
       return blink::WebMediaDeviceInfo::kMediaDeviceKindAudioOutput;
     default:
       NOTREACHED();
       return blink::WebMediaDeviceInfo::kMediaDeviceKindAudioInput;
   }
 }
 
+bool IsValidAudioContentSource(const std::string& source) {
+  return source == kMediaStreamSourceTab ||
+         source == kMediaStreamSourceDesktop ||
+         source == kMediaStreamSourceSystem;
+}
+
+bool IsValidVideoContentSource(const std::string& source) {
+  return source == kMediaStreamSourceTab ||
+         source == kMediaStreamSourceDesktop ||
+         source == kMediaStreamSourceScreen;
+}
+
 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 26 matching lines @@
   // Called when a local audio source has finished (or failed) initializing.
   void OnAudioSourceStarted(MediaStreamSource* source,
                             MediaStreamRequestResult result,
                             const blink::WebString& result_name);
 
   int request_id() const { return request_id_; }
 
   State state() const { return state_; }
   void set_state(State state) { state_ = state; }
 
-  bool enable_automatic_output_device_selection() const {
-    return enable_automatic_output_device_selection_;
+  // TODO(guidou): Remove this function. http://crbug.com/706408
+  bool legacy_enable_automatic_output_device_selection() const {
+    DCHECK(IsOldAudioConstraints());
+    return legacy_enable_automatic_output_device_selection_;
   }
-  void set_enable_automatic_output_device_selection(bool value) {
-    enable_automatic_output_device_selection_ = value;
+  // TODO(guidou): Remove this function. http://crbug.com/706408
+  void set_legacy_enable_automatic_output_device_selection(bool value) {
+    DCHECK(IsOldAudioConstraints());
+    legacy_enable_automatic_output_device_selection_ = value;
+  }
+  const AudioCaptureSettings& audio_capture_settings() const {
+    DCHECK(!IsOldAudioConstraints());
+    return audio_capture_settings_;
+  }
+  bool is_audio_content_capture() const {
+    DCHECK(!IsOldAudioConstraints());
+    return audio_capture_settings_.HasValue() && is_audio_content_capture_;
+  }
+  bool is_audio_device_capture() const {
+    DCHECK(!IsOldAudioConstraints());
+    return audio_capture_settings_.HasValue() && !is_audio_content_capture_;
+  }
+  void SetAudioCaptureSettings(const AudioCaptureSettings& settings,
+                               bool is_content_capture) {
+    DCHECK(settings.HasValue());
+    is_audio_content_capture_ = is_content_capture;
+    audio_capture_settings_ = settings;
   }
   const VideoCaptureSettings& video_capture_settings() const {
     return video_capture_settings_;
   }
   void SetVideoCaptureSettings(const VideoCaptureSettings& settings,
                                bool is_content_capture) {
     DCHECK(settings.HasValue());
     is_video_content_capture_ = is_content_capture;
     video_capture_settings_ = settings;
   }
@@ skipping 15 matching lines @@
                       MediaStreamRequestResult result,
                       const blink::WebString& result_name);
 
   // Cheks if the sources for all tracks have been started and if so,
   // invoke the |ready_callback_|.  Note that the caller should expect
   // that |this| might be deleted when the function returns.
   void CheckAllTracksStarted();
 
   const int request_id_;
   State state_;
-  bool enable_automatic_output_device_selection_;
+  // TODO(guidou): Remove this field. http://crbug.com/706408
+  bool legacy_enable_automatic_output_device_selection_;
+  AudioCaptureSettings audio_capture_settings_;
+  bool is_audio_content_capture_;
   VideoCaptureSettings video_capture_settings_;
   bool is_video_content_capture_;
   blink::WebMediaStream web_stream_;
   const blink::WebUserMediaRequest request_;
   StreamControls stream_controls_;
   const bool is_processing_user_gesture_;
   const url::Origin security_origin_;
   ResourcesReady ready_callback_;
   MediaStreamRequestResult request_result_;
   blink::WebString request_result_name_;
@@ skipping 64 matching lines @@
 }
 
 void UserMediaClientImpl::MaybeProcessNextRequestInfo() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (current_request_info_ || pending_request_infos_.empty())
     return;
 
   current_request_info_ = std::move(pending_request_infos_.front());
   pending_request_infos_.pop_front();
 
-  // TODO(guidou): Request audio and video capabilities in parallel.
+  // TODO(guidou): Set up audio and video in parallel.
   if (current_request_info_->request().Audio()) {
-    bool request_audio_input_devices = false;
-    // TODO(guidou): Implement spec-compliant device selection for audio. See
-    // http://crbug.com/623104.
-    CopyConstraintsToTrackControls(
-        current_request_info_->request().AudioConstraints(),
-        &current_request_info_->stream_controls()->audio,
-        &request_audio_input_devices);
-    CopyHotwordAndLocalEchoToStreamControls(
-        current_request_info_->request().AudioConstraints(),
-        current_request_info_->stream_controls());
-    // Check if this input device should be used to select a matching output
-    // device for audio rendering.
-    bool enable_automatic_output_device_selection = false;
-    GetConstraintValueAsBoolean(
-        current_request_info_->request().AudioConstraints(),
-        &blink::WebMediaTrackConstraintSet::render_to_associated_sink,
-        &enable_automatic_output_device_selection);
-    current_request_info_->set_enable_automatic_output_device_selection(
-        enable_automatic_output_device_selection);
+    if (IsOldAudioConstraints())
+      LegacySetupAudioInput();
+    else
+      SetupAudioInput(current_request_info_->request());
+    return;
+  }
+  SetupVideoInput(current_request_info_->request());
+}
 
-    if (request_audio_input_devices) {
-      GetMediaDevicesDispatcher()->EnumerateDevices(
-          true /* audio_input */, false /* video_input */,
-          false /* audio_output */,
-          base::Bind(&UserMediaClientImpl::SelectAudioInputDevice,
-                     weak_factory_.GetWeakPtr(),
-                     current_request_info_->request()));
-      return;
-    }
+void UserMediaClientImpl::LegacySetupAudioInput() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(IsOldAudioConstraints());
+  DCHECK(current_request_info_);
+  DCHECK(current_request_info_->request().Audio());
+
+  bool request_audio_input_devices = false;
+  CopyConstraintsToTrackControls(
+      current_request_info_->request().AudioConstraints(),
+      &current_request_info_->stream_controls()->audio,
+      &request_audio_input_devices);
+  CopyHotwordAndLocalEchoToStreamControls(
+      current_request_info_->request().AudioConstraints(),
+      current_request_info_->stream_controls());
+  // Check if this input device should be used to select a matching output
+  // device for audio rendering.
+  bool enable_automatic_output_device_selection = false;
+  GetConstraintValueAsBoolean(
+      current_request_info_->request().AudioConstraints(),
+      &blink::WebMediaTrackConstraintSet::render_to_associated_sink,
+      &enable_automatic_output_device_selection);
+  current_request_info_->set_legacy_enable_automatic_output_device_selection(
+      enable_automatic_output_device_selection);
+
+  if (request_audio_input_devices) {
+    GetMediaDevicesDispatcher()->EnumerateDevices(
+        true /* audio_input */, false /* video_input */,
+        false /* audio_output */,
+        base::Bind(&UserMediaClientImpl::LegacySelectAudioInputDevice,
+                   weak_factory_.GetWeakPtr(),
+                   current_request_info_->request()));
+    return;
   }
 
   SetupVideoInput(current_request_info_->request());
 }
 
-void UserMediaClientImpl::SelectAudioInputDevice(
+void UserMediaClientImpl::LegacySelectAudioInputDevice(
     const blink::WebUserMediaRequest& user_media_request,
     const EnumerationResult& device_enumeration) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(IsOldAudioConstraints());
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
   auto& audio_controls = current_request_info_->stream_controls()->audio;
   DCHECK(audio_controls.requested);
   DCHECK(IsDeviceSource(audio_controls.stream_source));
 
   if (!PickDeviceId(user_media_request.AudioConstraints(),
                     device_enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT],
                     &audio_controls.device_id)) {
     GetUserMediaRequestFailed(user_media_request, MEDIA_DEVICE_NO_HARDWARE, "");
     return;
   }
 
   SetupVideoInput(user_media_request);
 }
 
+void UserMediaClientImpl::SetupAudioInput(
+    const blink::WebUserMediaRequest& user_media_request) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(!IsOldAudioConstraints());
+  DCHECK(user_media_request.Audio());
+  if (!IsCurrentRequestInfo(user_media_request))

[miu, 2017/06/19 21:18:44]

Can you write a comment here to clarify why these might not match at this point?
Is the early return is safe (instead of some error-handling or logging)? Or,
would DCHECK(IsCurrentRequestInfo(umr)) be more appropriate?

[Guido Urdaneta, 2017/06/20 12:18:48]

Nice catch. This function is always called synchronously while
|current_request_info_| is being processed, so it shouldn't even take a
WebUserMediaRequest parameter.
Applied the same fix to SetupVideoInput and GetUserMediaRequestFailed.

There are some other functions that are called asynchronously, in which case the
check is necessary because the request might have been canceled.

+    return;
+
+  auto& audio_controls = current_request_info_->stream_controls()->audio;
+  InitializeTrackControls(user_media_request.AudioConstraints(),
+                          &audio_controls);
+  if (IsDeviceSource(audio_controls.stream_source)) {
+    GetMediaDevicesDispatcher()->GetAudioInputCapabilities(
+        base::Bind(&UserMediaClientImpl::SelectAudioSettings,
+                   weak_factory_.GetWeakPtr(), user_media_request));
+  } else {
+    if (!IsValidAudioContentSource(audio_controls.stream_source)) {
+      blink::WebString failed_constraint_name =
+          blink::WebString::FromASCII(user_media_request.AudioConstraints()
+                                          .Basic()
+                                          .media_stream_source.GetName());
+      MediaStreamRequestResult result = MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
+      GetUserMediaRequestFailed(user_media_request, result,
+                                failed_constraint_name);
+      return;
+    }
+    SelectAudioSettings(user_media_request, AudioDeviceCaptureCapabilities());
+  }
+}
+
+void UserMediaClientImpl::SelectAudioSettings(
+    const blink::WebUserMediaRequest& user_media_request,
+    std::vector<::mojom::AudioInputDeviceCapabilitiesPtr>
+        audio_input_capabilities) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(!IsOldAudioConstraints());
+  if (!IsCurrentRequestInfo(user_media_request))

[miu, 2017/06/19 21:18:44]

ditto here

[Guido Urdaneta, 2017/06/20 12:18:48]

In this case the check is necessary. Added comment (here and in other places)
explaining why the check is necessary.

+    return;
+
+  DCHECK(current_request_info_->stream_controls()->audio.requested);
+  auto settings =
+      SelectSettingsAudioCapture(std::move(audio_input_capabilities),
+                                 user_media_request.AudioConstraints());
+  if (!settings.HasValue()) {
+    blink::WebString failed_constraint_name =
+        blink::WebString::FromASCII(settings.failed_constraint_name());
+    MediaStreamRequestResult result =
+        failed_constraint_name.IsEmpty()
+            ? MEDIA_DEVICE_NO_HARDWARE
+            : MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
+    GetUserMediaRequestFailed(user_media_request, result,
+                              failed_constraint_name);
+    return;
+  }
+  current_request_info_->stream_controls()->audio.device_id =
+      settings.device_id();
+  current_request_info_->stream_controls()->disable_local_echo =
+      settings.disable_local_echo();
+  current_request_info_->stream_controls()->hotword_enabled =
+      settings.hotword_enabled();
+  current_request_info_->SetAudioCaptureSettings(
+      settings,
+      !IsDeviceSource(
+          current_request_info_->stream_controls()->audio.stream_source));
+
+  SetupVideoInput(user_media_request);

[miu, 2017/06/19 21:18:44]

Can this be moved to MaybeProcessNextRequestInfo()? It's a bit surprising for a
SelectAudioSettings() method to call a SetupVideoInput() method. ;-)

[Guido Urdaneta, 2017/06/20 12:18:48]

The plan is to do it after we remove the old constraints processing code, so
that the code is simpler.
Right now we first set up audio and when we're done we go for video.
The plan is to do it in parallel. There is a TODO on line 431 about this.

+}
+
 void UserMediaClientImpl::SetupVideoInput(
     const blink::WebUserMediaRequest& user_media_request) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
   if (!user_media_request.Video()) {
     GenerateStreamForCurrentRequestInfo();
     return;
   }
   auto& video_controls = current_request_info_->stream_controls()->video;
   InitializeTrackControls(user_media_request.VideoConstraints(),
                           &video_controls);
   if (IsDeviceSource(video_controls.stream_source)) {
     GetMediaDevicesDispatcher()->GetVideoInputCapabilities(
         base::Bind(&UserMediaClientImpl::SelectVideoDeviceSettings,
                    weak_factory_.GetWeakPtr(), user_media_request));
   } else {
+    if (!IsValidVideoContentSource(video_controls.stream_source)) {
+      blink::WebString failed_constraint_name =
+          blink::WebString::FromASCII(user_media_request.VideoConstraints()
+                                          .Basic()
+                                          .media_stream_source.GetName());
+      MediaStreamRequestResult result = MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
+      GetUserMediaRequestFailed(user_media_request, result,
+                                failed_constraint_name);
+      return;
+    }
     base::PostTaskAndReplyWithResult(
         worker_task_runner_.get(), FROM_HERE,
         base::Bind(&SelectSettingsVideoContentCapture,
                    user_media_request.VideoConstraints(),
                    video_controls.stream_source),
         base::Bind(&UserMediaClientImpl::FinalizeSelectVideoContentSettings,
                    weak_factory_.GetWeakPtr(), user_media_request));
   }
 }
 
@@ skipping 55 matching lines @@
     const blink::WebUserMediaRequest& user_media_request,
     const VideoCaptureSettings& settings) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
   if (!settings.HasValue()) {
     blink::WebString failed_constraint_name =
         blink::WebString::FromASCII(settings.failed_constraint_name());
     DCHECK(!failed_constraint_name.IsEmpty());
-    blink::WebString device_id_constraint_name = blink::WebString::FromASCII(
-        user_media_request.VideoConstraints().Basic().device_id.GetName());
     GetUserMediaRequestFailed(user_media_request,
                               MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED,
                               failed_constraint_name);
     return;
   }
   current_request_info_->stream_controls()->video.device_id =
       settings.device_id();
   current_request_info_->SetVideoCaptureSettings(settings,
                                                  true /* is_content_capture */);
   GenerateStreamForCurrentRequestInfo();
@@ skipping 285 matching lines @@
       &UserMediaClientImpl::OnLocalSourceStopped, weak_factory_.GetWeakPtr()));
   source.SetExtraData(audio_source);  // Takes ownership.
   return source;
 }
 
 MediaStreamAudioSource* UserMediaClientImpl::CreateAudioSource(
     const StreamDeviceInfo& device,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamSource::ConstraintsCallback& source_ready) {
   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(
-          constraints, device.device.input.effects)) {
+          audio_processing_properties)) {
     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, constraints, source_ready,
-      dependency_factory_);
+      RenderFrameObserver::routing_id(), device, audio_processing_properties,
+      source_ready, dependency_factory_);
   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 24 matching lines @@
 
 void UserMediaClientImpl::CreateAudioTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(current_request_info_);
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   StreamDeviceInfoArray overridden_audio_array = devices;
-  if (!current_request_info_->enable_automatic_output_device_selection()) {
+  bool render_to_associated_sink =
+      IsOldAudioConstraints()
+          ? current_request_info_
+                ->legacy_enable_automatic_output_device_selection()
+          : current_request_info_->audio_capture_settings().HasValue() &&
+                current_request_info_->audio_capture_settings()
+                    .render_to_associated_sink();
+  if (!render_to_associated_sink) {
     // If the GetUserMedia request did not explicitly set the constraint
     // kMediaStreamRenderToAssociatedSink, the output device parameters must
     // be removed.
     for (auto& device_info : overridden_audio_array) {
       device_info.device.matched_output_device_id = "";
       device_info.device.matched_output =
           MediaStreamDevice::AudioDeviceParameters();
     }
   }
 
@@ skipping 334 matching lines @@
 const ::mojom::MediaDevicesDispatcherHostPtr&
 UserMediaClientImpl::GetMediaDevicesDispatcher() {
   if (!media_devices_dispatcher_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&media_devices_dispatcher_));
   }
 
   return media_devices_dispatcher_;
 }
 
+const AudioCaptureSettings&
+UserMediaClientImpl::AudioCaptureSettingsForCurrentRequest() const {
+  DCHECK(current_request_info_);
+  return current_request_info_->audio_capture_settings();
+}
+
+const VideoCaptureSettings&
+UserMediaClientImpl::VideoCaptureSettingsForCurrentRequest() const {
+  DCHECK(current_request_info_);
+  return current_request_info_->video_capture_settings();
+}
+
 base::Optional<bool>
 UserMediaClientImpl::AutomaticOutputDeviceSelectionEnabledForCurrentRequest() {
   if (!current_request_info_)
     return base::Optional<bool>();
 
   return base::Optional<bool>(
-      current_request_info_->enable_automatic_output_device_selection());
+      current_request_info_->legacy_enable_automatic_output_device_selection());
 }
 
 void UserMediaClientImpl::OnDestruct() {
   delete this;
 }
 
 UserMediaClientImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
     const blink::WebUserMediaRequest& request,
     bool is_processing_user_gesture,
     const url::Origin& security_origin)
     : request_id_(request_id),
       state_(State::NOT_SENT_FOR_GENERATION),
-      enable_automatic_output_device_selection_(false),
+      legacy_enable_automatic_output_device_selection_(false),
+      is_audio_content_capture_(false),
       is_video_content_capture_(false),
       request_(request),
       is_processing_user_gesture_(is_processing_user_gesture),
       security_origin_(security_origin),
       request_result_(MEDIA_DEVICE_OK),
       request_result_name_("") {}
 
 void UserMediaClientImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
     bool is_pending) {
   DCHECK(track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio);
+  DCHECK(request_.Audio());
+#if DCHECK_IS_ON()
+  if (!IsOldAudioConstraints())
+    DCHECK(audio_capture_settings_.HasValue());
+#endif
   MediaStreamAudioSource* native_source =
       MediaStreamAudioSource::From(track.Source());
   // Add the source as pending since OnTrackStarted will expect it to be there.
   sources_waiting_for_callback_.push_back(native_source);
 
   sources_.push_back(track.Source());
   bool connected = native_source->ConnectToTrack(track);
   if (!is_pending) {
     OnTrackStarted(
         native_source,
@@ skipping 73 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