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

content/browser/renderer_host/media/media_stream_manager.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/browser/renderer_host/media/media_stream_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 200 matching lines @@
     MediaStreamType stream_type,
     const MediaDeviceInfoArray& device_infos) {
   MediaStreamDevices devices;
   for (const auto& info : device_infos) {
     devices.emplace_back(stream_type, info.device_id, info.label);
   }
 
   return devices;
 }
 
+bool FindFirstDeviceIdForVideoKind(const MediaDeviceInfoArray& devices,
+                                   VideoKind video_kind,
+                                   VideoCaptureManager* video_capture_manager,
+                                   std::string* device_id) {
+  for (const auto& device : devices) {
+    media::VideoCaptureFormats formats;
+    video_capture_manager->GetDeviceSupportedFormats(device.device_id,
+                                                     &formats);
+    for (const auto& format : formats) {
+      if ((video_kind == VIDEO_KIND_DEPTH &&
+           format.pixel_format == media::PIXEL_FORMAT_Y16) ||
+          (video_kind == VIDEO_KIND_COLOR &&
+           format.pixel_format != media::PIXEL_FORMAT_Y16)) {
+        *device_id = device.device_id;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
 // available devices or open one or more devices.
 // TODO(perkj): MediaStreamManager still needs refactoring. I propose we create
 // several subclasses of DeviceRequest and move some of the responsibility of
 // the MediaStreamManager to the subclasses to get rid of the way too many if
 // statements in MediaStreamManager.
 class MediaStreamManager::DeviceRequest {
@@ skipping 570 matching lines @@
     LOG(WARNING) << "Invalid device ID = " << controls.device_id;
     return false;
   }
   return true;
 }
 
 bool MediaStreamManager::GetRequestedDeviceCaptureId(
     const DeviceRequest* request,
     MediaStreamType type,
     const MediaDeviceInfoArray& devices,
-    std::string* device_id) const {
+    std::string* device_id) {
   if (type == MEDIA_DEVICE_AUDIO_CAPTURE) {
     return PickDeviceId(request->salt, request->security_origin,
                         request->controls.audio, devices, device_id);
   } else if (type == MEDIA_DEVICE_VIDEO_CAPTURE) {
+    if (request->controls.video.device_id.empty() &&

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

There is a CL (http://crrev.com/2669243004/) close to landing that performs
spec-compliant device selection based on constraints on the renderer side.
You should leave media_stream_manager unmodified and wait for that CL to land.
That CL depends on a selection algorithm that needs to be patched to be aware of
the new constraint, but that will be easy.

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

Thanks. Looks good.

+        request->controls.video_kind != VIDEO_KIND_NO_CONSTRAINT) {
+      return FindFirstDeviceIdForVideoKind(devices,
+                                           request->controls.video_kind,
+                                           video_capture_manager(), device_id);
+    }
     return PickDeviceId(request->salt, request->security_origin,
                         request->controls.video, devices, device_id);
   } else {
     NOTREACHED();
   }
   return false;
 }
 
 void MediaStreamManager::TranslateDeviceIdToSourceId(
     DeviceRequest* request,
@@ skipping 917 matching lines @@
   generate_stream_test_callback_ = test_callback;
 }
 
 #if defined(OS_WIN)
 void MediaStreamManager::FlushVideoCaptureThreadForTesting() {
   video_capture_thread_.FlushForTesting();
 }
 #endif
 
 }  // namespace content