Media Capture Depth Stream Extensions API: videoKind settings and constraint.

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 157 matching lines @@
 
   if (audio_constraints.basic().disableLocalEcho.hasExact()) {
     controls->disable_local_echo =
         audio_constraints.basic().disableLocalEcho.exact();
   } else {
     controls->disable_local_echo =
         controls->audio.stream_source != kMediaStreamSourceDesktop;
   }
 }
 
+bool CopyVideoKindToStreamControls(
+    const blink::WebMediaConstraints& video_constraints,
+    StreamControls* controls) {
+  if (video_constraints.isNull())
+    return true;
+
+  std::string video_kind_string;
+  if (!GetConstraintValueAsString(video_constraints,
+                                  &blink::WebMediaTrackConstraintSet::videoKind,
+                                  &video_kind_string))
+    return true;
+  if (video_kind_string == "color") {

[Guido Urdaneta, 2017/02/07 10:26:04]

nit: perhaps make the constants that were already defined with these values
public?

[aleksandar.stojiljkovic, 2017/02/07 11:33:49]

Done.

+    controls->video_kind = VIDEO_KIND_COLOR;
+    return true;
+  }
+  if (video_kind_string == "depth") {
+    controls->video_kind = VIDEO_KIND_DEPTH;
+    return true;
+  }
+  LOG(ERROR) << "Invalid videoKind value = " << video_kind_string;
+  return false;
+}
+
 bool IsSameDevice(const StreamDeviceInfo& device,
                   const StreamDeviceInfo& other_device) {
   return device.device.id == other_device.device.id &&
          device.device.type == other_device.device.type &&
          device.session_id == other_device.session_id;
 }
 
 bool IsSameSource(const blink::WebMediaStreamSource& source,
                   const blink::WebMediaStreamSource& other_source) {
   MediaStreamSource* const source_extra_data =
@@ skipping 81 matching lines @@
     GetConstraintValueAsBoolean(
         user_media_request.audioConstraints(),
         &blink::WebMediaTrackConstraintSet::renderToAssociatedSink,
         &enable_automatic_output_device_selection);
   }
   bool request_video_input_devices = false;
   if (user_media_request.video()) {
     CopyConstraintsToTrackControls(user_media_request.videoConstraints(),
                                    &controls->video,
                                    &request_video_input_devices);
+    if (!CopyVideoKindToStreamControls(user_media_request.videoConstraints(),
+                                       controls.get())) {
+      GetUserMediaRequestFailed(user_media_request, MEDIA_DEVICE_NO_HARDWARE,
+                                "");
+      return;
+    }
   }
 
   url::Origin security_origin = user_media_request.getSecurityOrigin();
   if (request_audio_input_devices || request_video_input_devices) {
     GetMediaDevicesDispatcher()->EnumerateDevices(
         request_audio_input_devices, request_video_input_devices,
         false /* request_audio_output_devices */, security_origin,
         base::Bind(&UserMediaClientImpl::SelectUserMediaDevice,
                    weak_factory_.GetWeakPtr(), request_id, user_media_request,
                    base::Passed(&controls),
@@ skipping 869 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