Add IPC to query capabilities of video input devices.

content/browser/renderer_host/media/media_devices_dispatcher_host.cc

Index: content/browser/renderer_host/media/media_devices_dispatcher_host.cc
diff --git a/content/browser/renderer_host/media/media_devices_dispatcher_host.cc b/content/browser/renderer_host/media/media_devices_dispatcher_host.cc
index c8e7b555c59225fc08c1b6476de5a9c208d847fa..5d43d4ae860017cc9911783863fc2da606652421 100644
--- a/content/browser/renderer_host/media/media_devices_dispatcher_host.cc
+++ b/content/browser/renderer_host/media/media_devices_dispatcher_host.cc
@@ -12,7 +12,9 @@
 #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"
@@ -147,6 +149,23 @@ void MediaDevicesDispatcherHost::EnumerateDevices(
                  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_,

[dcheng, 2017/01/20 07:56:50]

Hmm. +rockot... do you forsee replacing bad_message::ReceivedBadMessage with
mojo::ReportBadMessage?

[Guido Urdaneta, 2017/01/20 12:40:58]

Should I make this change or was this a question for rockot?

[dcheng, 2017/01/20 18:28:29]

This is a question for +rockot, I'm trying to understand what the long-term
plans are here. =)

[Ken Rockot(use gerrit already), 2017/01/20 18:34:36]

Yes, I think we should replace ReceivedBadMessage with ReportBadMessage. I'm not
sure there are any good reasons not to do so. Can you think of any?

ReportBadMessage doesn't have content dependencies or funky layering, its usage
is more flexible in general, it collects more useful data, and it's equally
effective at helping us shoot renderers.

+                                    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,
@@ -298,4 +317,68 @@ void MediaDevicesDispatcherHost::DevicesEnumerated(
   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_->media_devices_manager()->EnumerateDevices(
+      devices_to_enumerate,
+      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 MediaDeviceEnumeration& enumeration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
+      video_input_capabilities;
+  for (const auto& device_info : enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT]) {
+    MediaDeviceInfo translated_info = TranslateDeviceInfo(
+        true, device_id_salt_, group_id_salt_, security_origin, device_info);
+
+    ::mojom::VideoInputDeviceCapabilitiesPtr capabilities =
+        ::mojom::VideoInputDeviceCapabilities::New();
+    capabilities->device_id = std::move(translated_info.device_id);

[dcheng, 2017/01/20 18:28:29]

FWIW, this should normally be typemapped... that being said, this particular
instance looks rather tricky given Mojo's semantics around serialization. Since
Mojo serialization calls the getters multiple times, we'd have to build all this
information in a "context" object. I guess this is fine for now, but I hope we
can do something better in here after https://crbug.com/681080 is resolved.

+    capabilities->formats = GetVideoInputFormats(device_info.device_id);
+    capabilities->facing_mode = ::mojom::FacingMode::UNKNOWN;
+#if defined(OS_ANDROID)
+    // On Android, the facing mode is available as part of the label.
+    // TODO(guidou): Update this code once an API is available to get the
+    // facing mode in all platforms. See http://crbug.com/672856.
+    if (device_info.label.find("facing front") != std::string::npos)
+      capabilities->facing_mode = ::mojom::FacingMode::USER;
+    else if (device_info.label.find("facing back") != std::string::npos)
+      capabilities->facing_mode = ::mojom::FacingMode::ENVIRONMENT;
+#endif
+    if (device_info.device_id == default_device_id) {
+      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