Media Capture Depth Stream Extensions API: videoKind settings and constraint.

content/renderer/media/media_stream_constraints_util_video_source_unittest.cc

 // Copyright 2017 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/renderer/media/media_stream_constraints_util_video_source.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/optional.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 
 namespace content {
 
 namespace {
 
 const char kDeviceID1[] = "fake_device_1";
 const char kDeviceID2[] = "fake_device_2";
 const char kDeviceID3[] = "fake_device_3";
+const char kDeviceID4[] = "fake_device_4";
 }
 
 class MediaStreamConstraintsUtilVideoSourceTest : public testing::Test {
  public:
   void SetUp() override {
     // Default device. It is default because it is the first in the enumeration.
     ::mojom::VideoInputDeviceCapabilitiesPtr device =
         ::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kDeviceID1;
     device->facing_mode = ::mojom::FacingMode::NONE;
@@ skipping 45 matching lines @@
             media::PIXEL_FORMAT_I420),
         media::VideoCaptureFormat(gfx::Size(1280, 720), 60.0f,
                                   media::PIXEL_FORMAT_I420),
         media::VideoCaptureFormat(gfx::Size(1920, 1080), 60.0f,
                                   media::PIXEL_FORMAT_I420),
         media::VideoCaptureFormat(gfx::Size(2304, 1536), 10.0f,
                                   media::PIXEL_FORMAT_I420),
     };
     capabilities_.device_capabilities.push_back(std::move(device));
 
+    // A depth capture device.
+    device = ::mojom::VideoInputDeviceCapabilities::New();
+    device->device_id = kDeviceID4;
+    device->facing_mode = ::mojom::FacingMode::ENVIRONMENT;
+    device->formats = {media::VideoCaptureFormat(gfx::Size(640, 480), 30.0f,
+                                                 media::PIXEL_FORMAT_Y16)};
+    capabilities_.device_capabilities.push_back(std::move(device));
+
     capabilities_.power_line_capabilities = {
         media::PowerLineFrequency::FREQUENCY_DEFAULT,
         media::PowerLineFrequency::FREQUENCY_50HZ,
         media::PowerLineFrequency::FREQUENCY_60HZ,
     };
 
     default_device_ = capabilities_.device_capabilities[0].get();
     low_res_device_ = capabilities_.device_capabilities[1].get();
     high_res_device_ = capabilities_.device_capabilities[2].get();
     default_closest_format_ = &default_device_->formats[1];
@@ skipping 49 matching lines @@
   constraint_factory_.Reset();
   // No device in |capabilities_| has facing mode equal to LEFT.
   constraint_factory_.basic().facingMode.setExact(
       blink::WebString::fromASCII("left"));
   auto result = SelectSettings();
   EXPECT_FALSE(result.has_value());
   EXPECT_EQ(constraint_factory_.basic().facingMode.name(),
             result.failed_constraint_name);
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoSourceTest, OverconstrainedOnVideoKind) {
+  constraint_factory_.Reset();
+  // No device in |capabilities_| has video kind infrared.
+  constraint_factory_.basic().videoKind.setExact(
+      blink::WebString::fromASCII("infrared"));
+  auto result = SelectSettings();
+  EXPECT_FALSE(result.has_value());
+  EXPECT_EQ(constraint_factory_.basic().videoKind.name(),
+            result.failed_constraint_name);
+}
+
 TEST_F(MediaStreamConstraintsUtilVideoSourceTest, OverconstrainedOnHeight) {
   constraint_factory_.Reset();
   constraint_factory_.basic().height.setExact(123467890);
   auto result = SelectSettings();
   EXPECT_FALSE(result.has_value());
   EXPECT_EQ(constraint_factory_.basic().height.name(),
             result.failed_constraint_name);
 
   constraint_factory_.Reset();
   constraint_factory_.basic().height.setMin(123467890);
@@ skipping 156 matching lines @@
   EXPECT_TRUE(result.has_value());
   EXPECT_EQ(::mojom::FacingMode::USER, result.settings.facing_mode());
   // Only the high-res device supports user facing mode. Should select default
   // settings for everything else.
   EXPECT_EQ(high_res_device_->device_id, result.settings.device_id());
   EXPECT_EQ(*high_res_closest_format_, result.settings.format());
   EXPECT_EQ(media::PowerLineFrequency::FREQUENCY_DEFAULT,
             result.settings.power_line_frequency());
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoSourceTest, MandatoryVideoKind) {
+  constraint_factory_.Reset();
+  constraint_factory_.basic().videoKind.setExact(
+      blink::WebString::fromASCII("depth"));
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.has_value());
+  EXPECT_EQ(kDeviceID4, result.settings.device_id());
+  EXPECT_EQ(media::PIXEL_FORMAT_Y16, result.settings.format().pixel_format);
+
+  constraint_factory_.basic().videoKind.setExact(
+      blink::WebString::fromASCII("color"));
+  result = SelectSettings();
+  EXPECT_TRUE(result.has_value());
+  EXPECT_EQ(default_device_->device_id, result.settings.device_id());
+}
+
 TEST_F(MediaStreamConstraintsUtilVideoSourceTest, MandatoryPowerLineFrequency) {
   constraint_factory_.Reset();
   const media::PowerLineFrequency kPowerLineFrequencies[] = {
       media::PowerLineFrequency::FREQUENCY_50HZ,
       media::PowerLineFrequency::FREQUENCY_60HZ};
   for (auto power_line_frequency : kPowerLineFrequencies) {
     constraint_factory_.basic().googPowerLineFrequency.setExact(
         static_cast<long>(power_line_frequency));
     auto result = SelectSettings();
     EXPECT_TRUE(result.has_value());
@@ skipping 925 matching lines @@
   constraint_factory_.Reset();
   constraint_factory_.basic().height.setExact(100);
   VideoCaptureCapabilities capabilities;
   auto result = SelectVideoCaptureSourceSettings(
       capabilities, constraint_factory_.CreateWebMediaConstraints());
   EXPECT_FALSE(result.has_value());
   EXPECT_TRUE(std::string(result.failed_constraint_name).empty());
 }
 
 }  // namespace content