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 165 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"
                          ", video source id=%s",
                          request_id, controls->audio.device_id.c_str(),
                          controls->video.device_id.c_str()));

[hbos_chromium, 2017/03/17 11:53:28]

I noticed we do FinalizeRequestUserMedia if !video; are we requesting video
device even if !user_media_request.video()? Likewise with audio?
Does this need to be modified? Should we DCHECK audio() || video()?

How does WebUserMediaRequest.audio()/video() align with
StreamControls.audio/video.requested?

[Guido Urdaneta, 2017/03/17 12:33:42]

If audio and video are both false, the constraints parser detects that (in
Blink) and getUserMedia aborts with a TypeError. That happens before the request
arrives to UserMediaClientImpl.
In UserMediaClientImpl, we are sure that at least one of them has been provided
and FinalizeRequestUserMedia must be called unless there are errors processing
the constraints.

StreamConstrols.audio/video.requested is set in CopyConstraintsToStreamControl()
for audio, and InitializeStreamControls() for video (starting on this CL).

[hbos_chromium, 2017/03/17 15:27:39]

OK. Can we DCHECK audio or video in the public requestUserMedia?

[Guido Urdaneta, 2017/03/17 18:13:46]

Done.

 
   user_media_requests_.push_back(base::MakeUnique<UserMediaRequestInfo>(
       request_id, user_media_request,
       request_settings.enable_automatic_audio_output_device_selection));
 
   media_stream_dispatcher_->GenerateStream(
       request_id, weak_factory_.GetWeakPtr(), *controls,
       request_settings.security_origin,
       request_settings.is_processing_user_gesture);
 }
@@ skipping 803 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