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 "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "url/origin.h"
 
@@ skipping 114 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_,

[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,
     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_->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