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();
+    return;
+  }
+  SetupVideoInput();
+}
 
-    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());
+  // No further audio setup required. Continue with video.
+  SetupVideoInput();
 }
 
-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());
+  // The frame might reload or |user_media_request| might be cancelled while
+  // devices are enumerated. Do nothing if a different request is being
+  // processed at this point.
   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, "");
+    GetUserMediaRequestFailed(MEDIA_DEVICE_NO_HARDWARE, "");
     return;
   }
 
-  SetupVideoInput(user_media_request);
+  // No further audio setup required. Continue with video.
+  SetupVideoInput();
 }
 
-void UserMediaClientImpl::SetupVideoInput(
-    const blink::WebUserMediaRequest& user_media_request) {
+void UserMediaClientImpl::SetupAudioInput() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(!IsOldAudioConstraints());
+  DCHECK(current_request_info_);
+  DCHECK(current_request_info_->request().Audio());
+
+  auto& audio_controls = current_request_info_->stream_controls()->audio;
+  InitializeTrackControls(current_request_info_->request().AudioConstraints(),
+                          &audio_controls);
+  if (IsDeviceSource(audio_controls.stream_source)) {
+    GetMediaDevicesDispatcher()->GetAudioInputCapabilities(base::Bind(
+        &UserMediaClientImpl::SelectAudioSettings, weak_factory_.GetWeakPtr(),
+        current_request_info_->request()));
+  } else {
+    if (!IsValidAudioContentSource(audio_controls.stream_source)) {
+      blink::WebString failed_constraint_name =
+          blink::WebString::FromASCII(current_request_info_->request()
+                                          .AudioConstraints()
+                                          .Basic()
+                                          .media_stream_source.GetName());
+      MediaStreamRequestResult result = MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
+      GetUserMediaRequestFailed(result, failed_constraint_name);
+      return;
+    }
+    SelectAudioSettings(current_request_info_->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());
+  // The frame might reload or |user_media_request| might be cancelled while
+  // capabilities are queried. Do nothing if a different request is being
+  // processed at this point.
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
-  if (!user_media_request.Video()) {
+  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(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));
+
+  // No further audio setup required. Continue with video.
+  SetupVideoInput();
+}
+
+void UserMediaClientImpl::SetupVideoInput() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(current_request_info_);
+
+  if (!current_request_info_->request().Video()) {
     GenerateStreamForCurrentRequestInfo();
     return;
   }
   auto& video_controls = current_request_info_->stream_controls()->video;
-  InitializeTrackControls(user_media_request.VideoConstraints(),
+  InitializeTrackControls(current_request_info_->request().VideoConstraints(),
                           &video_controls);
   if (IsDeviceSource(video_controls.stream_source)) {
-    GetMediaDevicesDispatcher()->GetVideoInputCapabilities(
-        base::Bind(&UserMediaClientImpl::SelectVideoDeviceSettings,
-                   weak_factory_.GetWeakPtr(), user_media_request));
+    GetMediaDevicesDispatcher()->GetVideoInputCapabilities(base::Bind(
+        &UserMediaClientImpl::SelectVideoDeviceSettings,
+        weak_factory_.GetWeakPtr(), current_request_info_->request()));
   } else {
+    if (!IsValidVideoContentSource(video_controls.stream_source)) {
+      blink::WebString failed_constraint_name =
+          blink::WebString::FromASCII(current_request_info_->request()
+                                          .VideoConstraints()
+                                          .Basic()
+                                          .media_stream_source.GetName());
+      MediaStreamRequestResult result = MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
+      GetUserMediaRequestFailed(result, failed_constraint_name);
+      return;
+    }
     base::PostTaskAndReplyWithResult(
         worker_task_runner_.get(), FROM_HERE,
         base::Bind(&SelectSettingsVideoContentCapture,
-                   user_media_request.VideoConstraints(),
+                   current_request_info_->request().VideoConstraints(),
                    video_controls.stream_source),
         base::Bind(&UserMediaClientImpl::FinalizeSelectVideoContentSettings,
-                   weak_factory_.GetWeakPtr(), user_media_request));
+                   weak_factory_.GetWeakPtr(),
+                   current_request_info_->request()));
   }
 }
 
 void UserMediaClientImpl::SelectVideoDeviceSettings(
     const blink::WebUserMediaRequest& user_media_request,
     std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
         video_input_capabilities) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  // The frame might reload or |user_media_request| might be cancelled while
+  // capabilities are queried. Do nothing if a different request is being
+  // processed at this point.
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
   DCHECK(current_request_info_->stream_controls()->video.requested);
   DCHECK(IsDeviceSource(
       current_request_info_->stream_controls()->video.stream_source));
 
   VideoDeviceCaptureCapabilities capabilities;
   capabilities.device_capabilities = std::move(video_input_capabilities);
   capabilities.power_line_capabilities = {
@@ skipping 18 matching lines @@
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
   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);
+    GetUserMediaRequestFailed(result, failed_constraint_name);
     return;
   }
   current_request_info_->stream_controls()->video.device_id =
       settings.device_id();
   current_request_info_->SetVideoCaptureSettings(
       settings, false /* is_content_capture */);
   GenerateStreamForCurrentRequestInfo();
 }
 
 void UserMediaClientImpl::FinalizeSelectVideoContentSettings(
     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,
+    GetUserMediaRequestFailed(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 199 matching lines @@
 void UserMediaClientImpl::OnStreamGenerationFailed(
     int request_id,
     MediaStreamRequestResult result) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!IsCurrentRequestInfo(request_id)) {
     // This can happen if the request is cancelled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     return;
   }
 
-  GetUserMediaRequestFailed(current_request_info_->request(), result, "");
+  GetUserMediaRequestFailed(result, "");
   DeleteRequestInfo(current_request_info_->request());
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
 void UserMediaClientImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(1) << "UserMediaClientImpl::OnDeviceStopped("
@@ skipping 63 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 10 matching lines @@
     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) {
     GetUserMediaRequestSucceeded(*request_info->web_stream(),
                                  request_info->request());
     media_stream_dispatcher_->OnStreamStarted(label);
   } else {
-    GetUserMediaRequestFailed(request_info->request(), result, result_name);
+    GetUserMediaRequestFailed(result, result_name);
 
     blink::WebVector<blink::WebMediaStreamTrack> tracks;
     request_info->web_stream()->AudioTracks(tracks);
     for (auto& web_track : tracks) {
       MediaStreamTrack* track = MediaStreamTrack::GetTrack(web_track);
       if (track)
         track->Stop();
     }
     request_info->web_stream()->VideoTracks(tracks);
     for (auto& web_track : tracks) {
@@ skipping 44 matching lines @@
 void UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
     blink::WebUserMediaRequest request) {
   DVLOG(1) << "UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded";
   LogUserMediaRequestResult(MEDIA_DEVICE_OK);
   DeleteRequestInfo(request);
   request.RequestSucceeded(stream);
 }
 
 void UserMediaClientImpl::GetUserMediaRequestFailed(
-    blink::WebUserMediaRequest request,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
+  DCHECK(current_request_info_);
   // Completing the getUserMedia request can lead to that the RenderFrame and
   // the UserMediaClientImpl is destroyed if the JavaScript code request the
   // frame to be destroyed within the scope of the callback. Therefore,
   // post a task to complete the request with a clean stack.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&UserMediaClientImpl::DelayedGetUserMediaRequestFailed,
-                 weak_factory_.GetWeakPtr(), request, result, result_name));
+                 weak_factory_.GetWeakPtr(), current_request_info_->request(),
+                 result, result_name));
 }
 
 void UserMediaClientImpl::DelayedGetUserMediaRequestFailed(
     blink::WebUserMediaRequest request,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   LogUserMediaRequestResult(result);
   DeleteRequestInfo(request);
   switch (result) {
     case MEDIA_DEVICE_OK:
@@ skipping 228 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::AudioCaptureSettingsForTesting() const {
+  DCHECK(current_request_info_);
+  return current_request_info_->audio_capture_settings();
+}
+
+const VideoCaptureSettings&
+UserMediaClientImpl::VideoCaptureSettingsForTesting() 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