Use fallback capabilities for devices that cannot list camera capabilities.

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>
@@ skipping 12 matching lines @@
 #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 {
 
+// Resolutions used if the source doesn't support capability enumeration.
+struct {
+  int width;
+  int height;
+} const kFallbackVideoResolutions[] = {{1920, 1080}, {1280, 720}, {960, 720},
+                                       {640, 480},   {640, 360},  {320, 240},
+                                       {320, 180}};
+
+// Frame rates for sources with no support for capability enumeration.
+const int kFallbackVideoFrameRates[] = {30, 60};
+
 MediaDeviceInfo TranslateDeviceInfo(bool has_permission,
                                     const std::string& device_id_salt,
                                     const std::string& group_id_salt,
                                     const url::Origin& security_origin,
                                     const MediaDeviceInfo& device_info) {
   return MediaDeviceInfo(
       GetHMACForMediaDeviceID(device_id_salt, security_origin,
                               device_info.device_id),
       has_permission ? device_info.label : std::string(),
       device_info.group_id.empty()
@@ skipping 309 matching lines @@
   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);
+    if (capabilities->formats.empty()) {
+      // The device does not seem to support capability enumeration. Compose
+      // a fallback list of capabilities.
+      for (const auto& resolution : kFallbackVideoResolutions) {
+        for (const auto frame_rate : kFallbackVideoFrameRates) {
+          capabilities->formats.push_back(media::VideoCaptureFormat(
+              gfx::Size(resolution.width, resolution.height), frame_rate,
+              media::PIXEL_FORMAT_I420));
+        }
+      }
+    }
     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;
@@ skipping 17 matching lines @@
       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