Add IPC to query capabilities of video input devices.

content/browser/renderer_host/media/media_devices_dispatcher_host.cc

 // Copyright 2016 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_devices_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/bad_message.h"
+#include "content/browser/media/media_devices_util.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
+#include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_devices.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/common/media_stream_request.h"
+#include "media/base/video_facing.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "url/origin.h"
 
 namespace content {
 
 namespace {
 
 MediaDeviceInfo TranslateDeviceInfo(bool has_permission,
                                     const std::string& device_id_salt,
@@ skipping 18 matching lines @@
     const MediaDeviceInfoArray& input) {
   MediaDeviceInfoArray result;
   for (const auto& device_info : input) {
     result.push_back(TranslateDeviceInfo(has_permission, device_id_salt,
                                          group_id_salt, security_origin,
                                          device_info));
   }
   return result;
 }
 
+::mojom::FacingMode ToFacingMode(media::VideoFacingMode facing_mode) {
+  switch (facing_mode) {
+    case media::MEDIA_VIDEO_FACING_NONE:
+      return ::mojom::FacingMode::NONE;
+    case media::MEDIA_VIDEO_FACING_USER:
+      return ::mojom::FacingMode::USER;
+    case media::MEDIA_VIDEO_FACING_ENVIRONMENT:
+      return ::mojom::FacingMode::ENVIRONMENT;
+    default:
+      NOTREACHED();
+      return ::mojom::FacingMode::NONE;
+  }
+}
+
 }  // namespace
 
 struct MediaDevicesDispatcherHost::SubscriptionInfo {
   uint32_t subscription_id;
   url::Origin security_origin;
 };
 
 // static
 void MediaDevicesDispatcherHost::Create(
     int render_process_id,
@@ skipping 70 matching lines @@
   devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = request_audio_output;
 
   permission_checker_->CheckPermissions(
       devices_to_enumerate, render_process_id_, render_frame_id_,
       security_origin,
       base::Bind(&MediaDevicesDispatcherHost::DoEnumerateDevices,
                  weak_factory_.GetWeakPtr(), devices_to_enumerate,
                  security_origin, client_callback));
 }
 
+void MediaDevicesDispatcherHost::GetVideoInputCapabilities(
+    const url::Origin& security_origin,
+    const GetVideoInputCapabilitiesCallback& client_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
+                                           security_origin)) {
+    bad_message::ReceivedBadMessage(render_process_id_,
+                                    bad_message::MDDH_UNAUTHORIZED_ORIGIN);
+    return;
+  }
+
+  GetDefaultMediaDeviceID(
+      MEDIA_DEVICE_TYPE_VIDEO_INPUT, render_process_id_, render_frame_id_,
+      base::Bind(&MediaDevicesDispatcherHost::GotDefaultVideoInputDeviceID,
+                 weak_factory_.GetWeakPtr(), security_origin, client_callback));
+}
+
 void MediaDevicesDispatcherHost::SubscribeDeviceChangeNotifications(
     MediaDeviceType type,
     uint32_t subscription_id,
     const url::Origin& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(IsValidMediaDeviceType(type));
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
                                            security_origin)) {
     bad_message::ReceivedBadMessage(render_process_id_,
                                     bad_message::MDDH_UNAUTHORIZED_ORIGIN);
@@ skipping 131 matching lines @@
 
     for (const auto& device_info : enumeration[i]) {
       result[i].push_back(TranslateDeviceInfo(has_permissions[i],
                                               device_id_salt_, group_id_salt_,
                                               security_origin, device_info));
     }
   }
   client_callback.Run(result);
 }
 
+void MediaDevicesDispatcherHost::GotDefaultVideoInputDeviceID(
+    const url::Origin& security_origin,
+    const GetVideoInputCapabilitiesCallback& client_callback,
+    const std::string& default_device_id) {
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
+  media_stream_manager_->video_capture_manager()->EnumerateDevices(
+      base::Bind(&MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities,
+                 weak_factory_.GetWeakPtr(), security_origin, client_callback,
+                 default_device_id));
+}
+
+void MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities(
+    const url::Origin& security_origin,
+    const GetVideoInputCapabilitiesCallback& client_callback,
+    const std::string& default_device_id,
+    const media::VideoCaptureDeviceDescriptors& device_descriptors) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
+      video_input_capabilities;
+  for (const auto& descriptor : device_descriptors) {
+    std::string hmac_device_id = GetHMACForMediaDeviceID(
+        device_id_salt_, security_origin, descriptor.device_id);
+    ::mojom::VideoInputDeviceCapabilitiesPtr capabilities =
+        ::mojom::VideoInputDeviceCapabilities::New();
+    capabilities->device_id = std::move(hmac_device_id);
+    capabilities->formats = GetVideoInputFormats(descriptor.device_id);
+    capabilities->facing_mode = ToFacingMode(descriptor.facing);
+#if defined(OS_ANDROID)
+    // On Android, the facing mode is not available in the |facing| field,
+    // but is available as part of the label.
+    // TODO(guidou): Remove this code once the |facing| field is supported
+    // on Android. See http://crbug.com/672856.
+    if (descriptor.GetNameAndModel().find("front") != std::string::npos)
+      capabilities->facing_mode = ::mojom::FacingMode::USER;
+    else if (descriptor.GetNameAndModel().find("back") != std::string::npos)
+      capabilities->facing_mode = ::mojom::FacingMode::ENVIRONMENT;
+#endif
+    if (descriptor.device_id == default_device_id) {

[tommi (sloooow) - chröme, 2017/01/27 16:37:00]

supernit: use of {} here and none above is inconsistent

[Guido Urdaneta, 2017/01/27 17:02:14]

My interpretation of the style guide is that braces are required when the
statement inside the if has more than one line. Is that incorrect?

[tommi (sloooow) - chröme, 2017/01/27 17:14:51]

you are absolutely correct, I withdraw my supernit

+      video_input_capabilities.insert(video_input_capabilities.begin(),
+                                      std::move(capabilities));
+    } else {
+      video_input_capabilities.push_back(std::move(capabilities));
+    }
+  }
+
+  client_callback.Run(std::move(video_input_capabilities));
+}
+
+media::VideoCaptureFormats MediaDevicesDispatcherHost::GetVideoInputFormats(
+    const std::string& device_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  media::VideoCaptureFormats formats;
+  media_stream_manager_->video_capture_manager()->GetDeviceFormatsInUse(
+      MEDIA_DEVICE_VIDEO_CAPTURE, device_id, &formats);
+  if (!formats.empty())
+    return formats;
+
+  media_stream_manager_->video_capture_manager()->GetDeviceSupportedFormats(
+      device_id, &formats);
+  return formats;
+}
+
 }  // namespace content