Use spec-compliant algorithm for video content-capture deviceId selection in getUserMedia.

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/hash.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.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_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/webrtc_video_capturer_adapter.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 83 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.
 void CopyConstraintsToTrackControls(
     const blink::WebMediaConstraints& constraints,
     TrackControls* track_controls,
     bool* request_devices) {
   DCHECK(!constraints.isNull());
   track_controls->requested = true;
   CopyFirstString(constraints.basic().mediaStreamSource,
                   &track_controls->stream_source);
   if (IsDeviceSource(track_controls->stream_source)) {
     bool request_devices_advanced = false;
     for (const auto& advanced : constraints.advanced()) {
       if (!advanced.deviceId.isEmpty()) {
         request_devices_advanced = true;
         break;
       }
     }
     *request_devices =
         request_devices_advanced || !constraints.basic().deviceId.isEmpty();
   } else {
     CopyFirstString(constraints.basic().deviceId, &track_controls->device_id);
     *request_devices = false;
   }
 }
 
+void InitializeTrackControls(const blink::WebMediaConstraints& constraints,
+                             TrackControls* track_controls) {
+  DCHECK(!constraints.isNull());
+  track_controls->requested = true;
+  CopyFirstString(constraints.basic().mediaStreamSource,
+                  &track_controls->stream_source);
+}
+
 void CopyHotwordAndLocalEchoToStreamControls(
     const blink::WebMediaConstraints& audio_constraints,
     StreamControls* controls) {
   if (audio_constraints.isNull())
     return;
 
   if (audio_constraints.basic().hotwordEnabled.hasExact()) {
     controls->hotword_enabled =
         audio_constraints.basic().hotwordEnabled.exact();
   } else {
@@ skipping 87 matching lines @@
 }
 
 void UserMediaClientImpl::requestUserMedia(
     const blink::WebUserMediaRequest& user_media_request) {
   // Save histogram data so we can see how much GetUserMedia is used.
   // The histogram counts the number of calls to the JS API
   // webGetUserMedia.
   UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA);
   DCHECK(CalledOnValidThread());
   DCHECK(!user_media_request.isNull());
+  DCHECK(user_media_request.audio() || user_media_request.video());
   // ownerDocument may be null if we are in a test.
   // In that case, it's OK to not check frame().
   DCHECK(user_media_request.ownerDocument().isNull() ||
          render_frame()->GetWebFrame() ==
              static_cast<blink::WebFrame*>(
                  user_media_request.ownerDocument().frame()));
 
   if (RenderThreadImpl::current()) {
     RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia(
         user_media_request);
@@ skipping 58 matching lines @@
 
   SetupVideoInput(request_id, user_media_request, std::move(controls),
                   request_settings);
 }
 
 void UserMediaClientImpl::SetupVideoInput(
     int request_id,
     const blink::WebUserMediaRequest& user_media_request,
     std::unique_ptr<StreamControls> controls,
     const RequestSettings& request_settings) {
-  if (user_media_request.video()) {
-    bool ignore;
-    CopyConstraintsToTrackControls(user_media_request.videoConstraints(),
-                                   &controls->video, &ignore);
-    if (IsDeviceSource(controls->video.stream_source)) {
-      GetMediaDevicesDispatcher()->GetVideoInputCapabilities(
-          request_settings.security_origin,
-          base::Bind(&UserMediaClientImpl::SelectVideoDeviceSourceSettings,
-                     weak_factory_.GetWeakPtr(), request_id, user_media_request,
-                     base::Passed(&controls), request_settings));
-      return;
-    }
+  if (!user_media_request.video()) {
+    FinalizeRequestUserMedia(request_id, user_media_request,
+                             std::move(controls), request_settings);
+    return;
   }
-  FinalizeRequestUserMedia(request_id, user_media_request, std::move(controls),
-                           request_settings);
+  InitializeTrackControls(user_media_request.videoConstraints(),
+                          &controls->video);
+  if (IsDeviceSource(controls->video.stream_source)) {
+    GetMediaDevicesDispatcher()->GetVideoInputCapabilities(
+        request_settings.security_origin,
+        base::Bind(&UserMediaClientImpl::SelectVideoDeviceSourceSettings,
+                   weak_factory_.GetWeakPtr(), request_id, user_media_request,
+                   base::Passed(&controls), request_settings));
+  } else {
+    base::PostTaskAndReplyWithResult(
+        worker_task_runner_.get(), FROM_HERE,
+        base::Bind(&SelectVideoContentCaptureSourceSettings,
+                   user_media_request.videoConstraints()),
+        base::Bind(
+            &UserMediaClientImpl::FinalizeSelectVideoContentSourceSettings,
+            weak_factory_.GetWeakPtr(), request_id, user_media_request,
+            base::Passed(&controls), request_settings));
+  }
 }
 
 void UserMediaClientImpl::SelectVideoDeviceSourceSettings(
     int request_id,
     const blink::WebUserMediaRequest& user_media_request,
     std::unique_ptr<StreamControls> controls,
     const RequestSettings& request_settings,
     std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
         video_input_capabilities) {
   DCHECK(CalledOnValidThread());
@@ skipping 44 matching lines @@
       GetUserMediaRequestFailed(user_media_request,
                                 MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED,
                                 failed_constraint_name);
       return;
     }
   }
   FinalizeRequestUserMedia(request_id, user_media_request, std::move(controls),
                            request_settings);
 }
 
+void UserMediaClientImpl::FinalizeSelectVideoContentSourceSettings(
+    int request_id,
+    const blink::WebUserMediaRequest& user_media_request,
+    std::unique_ptr<StreamControls> controls,
+    const RequestSettings& request_settings,
+    const VideoContentCaptureSourceSelectionResult& selection_result) {
+  DCHECK(CalledOnValidThread());
+  if (!selection_result.HasValue()) {
+    blink::WebString failed_constraint_name =
+        blink::WebString::fromASCII(selection_result.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;
+  }
+  controls->video.device_id = selection_result.device_id();
+  FinalizeRequestUserMedia(request_id, user_media_request, std::move(controls),
+                           request_settings);
+}
+
 void UserMediaClientImpl::FinalizeRequestUserMedia(
     int request_id,
     const blink::WebUserMediaRequest& user_media_request,
     std::unique_ptr<StreamControls> controls,
     const RequestSettings& request_settings) {
   DCHECK(CalledOnValidThread());
 
   WebRtcLogMessage(
       base::StringPrintf("MSI::requestUserMedia. request_id=%d"
                          ", audio source id=%s"
@@ skipping 817 matching lines @@
                          sources_waiting_for_callback_.end(), source);
   if (found != sources_waiting_for_callback_.end())
     OnTrackStarted(source, result, result_name);
 }
 
 void UserMediaClientImpl::OnDestruct() {
   delete this;
 }
 
 }  // namespace content