Introduce SelectSettings algorithm for MediaStream video tracks.

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 434 matching lines @@
   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(
         current_request_info_->security_origin(),
-        base::Bind(&UserMediaClientImpl::SelectVideoDeviceSourceSettings,
+        base::Bind(&UserMediaClientImpl::SelectVideoDeviceSettings,
                    weak_factory_.GetWeakPtr(), user_media_request));
   } else {
     base::PostTaskAndReplyWithResult(
         worker_task_runner_.get(), FROM_HERE,
-        base::Bind(&SelectVideoContentCaptureSourceSettings,
+        base::Bind(&SelectSettingsVideoContentCapture,
                    user_media_request.videoConstraints()),
-        base::Bind(
-            &UserMediaClientImpl::FinalizeSelectVideoContentSourceSettings,
-            weak_factory_.GetWeakPtr(), user_media_request));
+        base::Bind(&UserMediaClientImpl::FinalizeSelectVideoContentSettings,
+                   weak_factory_.GetWeakPtr(), user_media_request));
   }
 }
 
-void UserMediaClientImpl::SelectVideoDeviceSourceSettings(
+void UserMediaClientImpl::SelectVideoDeviceSettings(
     const blink::WebUserMediaRequest& user_media_request,
     std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
         video_input_capabilities) {
   DCHECK(CalledOnValidThread());
   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 = {
       media::PowerLineFrequency::FREQUENCY_DEFAULT,
       media::PowerLineFrequency::FREQUENCY_50HZ,
       media::PowerLineFrequency::FREQUENCY_60HZ};
-  capabilities.noise_reduction_capabilities = {rtc::Optional<bool>(),
-                                               rtc::Optional<bool>(true),
-                                               rtc::Optional<bool>(false)};
+  capabilities.noise_reduction_capabilities = {base::Optional<bool>(),
+                                               base::Optional<bool>(true),
+                                               base::Optional<bool>(false)};
   base::PostTaskAndReplyWithResult(
       worker_task_runner_.get(), FROM_HERE,
-      base::Bind(&SelectVideoDeviceCaptureSourceSettings,
-                 std::move(capabilities),
+      base::Bind(&SelectSettingsVideoDeviceCapture, std::move(capabilities),
                  user_media_request.videoConstraints()),
-      base::Bind(&UserMediaClientImpl::FinalizeSelectVideoDeviceSourceSettings,
+      base::Bind(&UserMediaClientImpl::FinalizeSelectVideoDeviceSettings,
                  weak_factory_.GetWeakPtr(), user_media_request));
 }
 
-void UserMediaClientImpl::FinalizeSelectVideoDeviceSourceSettings(
+void UserMediaClientImpl::FinalizeSelectVideoDeviceSettings(
     const blink::WebUserMediaRequest& user_media_request,
-    const VideoDeviceCaptureSourceSelectionResult& selection_result) {
+    const VideoCaptureSettings& settings) {
   DCHECK(CalledOnValidThread());
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
-  if (!selection_result.HasValue()) {
+  if (!settings.HasValue()) {
     blink::WebString failed_constraint_name =
-        blink::WebString::fromASCII(selection_result.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()->video.device_id =
-      selection_result.device_id();
+      settings.device_id();
   GenerateStreamForCurrentRequestInfo();
 }
 
-void UserMediaClientImpl::FinalizeSelectVideoContentSourceSettings(
+void UserMediaClientImpl::FinalizeSelectVideoContentSettings(
     const blink::WebUserMediaRequest& user_media_request,
-    const VideoContentCaptureSourceSelectionResult& selection_result) {
+    const VideoCaptureSettings& settings) {
   DCHECK(CalledOnValidThread());
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
-  if (!selection_result.HasValue()) {
+  if (!settings.HasValue()) {
     blink::WebString failed_constraint_name =
-        blink::WebString::fromASCII(selection_result.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().deviceId.name());
     GetUserMediaRequestFailed(user_media_request,
                               MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED,
                               failed_constraint_name);
     return;
   }
   current_request_info_->stream_controls()->video.device_id =
-      selection_result.device_id();
+      settings.device_id();
   GenerateStreamForCurrentRequestInfo();
 }
 
 void UserMediaClientImpl::GenerateStreamForCurrentRequestInfo() {
   DCHECK(CalledOnValidThread());
   DCHECK(current_request_info_);
 
   WebRtcLogMessage(base::StringPrintf(
       "MSI::requestUserMedia. request_id=%d"
       ", audio source id=%s"
@@ skipping 811 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