Media Capture Depth Stream Extensions API: focal length and depth range.

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 189 matching lines @@
       return MEDIA_DEVICE_TYPE_AUDIO_INPUT;
     case MEDIA_DEVICE_VIDEO_CAPTURE:
       return MEDIA_DEVICE_TYPE_VIDEO_INPUT;
     default:
       NOTREACHED();
   }
 
   return NUM_MEDIA_DEVICE_TYPES;
 }
 
-MediaStreamDevices ConvertToMediaStreamDevices(
-    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;
-}
-
 }  // 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 707 matching lines @@
   if (IsVideoMediaType(video_type))
     request->SetState(video_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
 
   // If using the fake UI, it will just auto-select from the available devices.
   // The fake UI doesn't work for desktop sharing requests since we can't see
   // its devices from here; always use the real UI for such requests.
   if (use_fake_ui_ && request->video_type() != MEDIA_DESKTOP_VIDEO_CAPTURE) {
     if (!fake_ui_)
       fake_ui_.reset(new FakeMediaStreamUIProxy());
 
-    MediaStreamDevices devices;
-    for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
-      devices.emplace_back(audio_type, info.device_id, info.label);
-    }
-    for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT]) {
-      devices.emplace_back(video_type, info.device_id, info.label);
-    }
+    MediaStreamDevices devices = ConvertToMediaStreamDevices(
+        request->audio_type(), enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]);
+    MediaStreamDevices video_devices = ConvertToMediaStreamDevices(
+        request->video_type(), enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT]);
+    devices.reserve(devices.size() + video_devices.size());
+    devices.insert(devices.end(), video_devices.begin(), video_devices.end());
 
     fake_ui_->SetAvailableDevices(devices);
 
     request->ui_proxy = std::move(fake_ui_);
   } else {
     request->ui_proxy = MediaStreamUIProxy::Create();
   }
 
   request->ui_proxy->RequestAccess(
       request->DetachUIRequest(),
@@ skipping 777 matching lines @@
     GenerateStreamTestCallback test_callback) {
   generate_stream_test_callback_ = test_callback;
 }
 
 #if defined(OS_WIN)
 void MediaStreamManager::FlushVideoCaptureThreadForTesting() {
   video_capture_thread_.FlushForTesting();
 }
 #endif
 
+MediaStreamDevices MediaStreamManager::ConvertToMediaStreamDevices(
+    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);
+
+  if (stream_type != MEDIA_DEVICE_VIDEO_CAPTURE)
+    return devices;
+
+  for (auto& device : devices) {
+    device.camera_calibration =
+        video_capture_manager()->GetCameraCalibration(device.id);
+  }
+  return devices;
+}
+
 }  // namespace content