Support groupId constrainable properties in MediaDevices.getUserMedia()

This CL also adds support in MediaStreamTrack.applyConstraints().

Drive-by: Minor lint fixes.

Bug: 833333
Change-Id: I8636def42d9ed64c6f58777d44343e569e541bfb
Reviewed-on: https://chromium-review.googlesource.com/1021570Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Harald Alvestrand <hta@chromium.org>
Commit-Queue: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556124}

content/browser/renderer_host/media/media_devices_dispatcher_host.cc

@@ -196,7 +196,12 @@ void MediaDevicesDispatcherHost::GotDefaultVideoInputDeviceID(
     MediaDeviceSaltAndOrigin salt_and_origin,
     const std::string& default_device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  media_stream_manager_->video_capture_manager()->EnumerateDevices(
+  MediaDevicesManager::BoolDeviceTypes requested_types;
+  // Also request audio devices to make sure the heuristic to determine
+  // the video group ID works.
+  requested_types[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
+  media_stream_manager_->media_devices_manager()->EnumerateDevices(
+      requested_types,
       base::Bind(&MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities,
                  weak_factory_.GetWeakPtr(), base::Passed(&client_callback),
                  std::move(salt_and_origin), std::move(default_device_id)));
@@ -206,22 +211,26 @@ void MediaDevicesDispatcherHost::FinalizeGetVideoInputCapabilities(
     GetVideoInputCapabilitiesCallback client_callback,
     const MediaDeviceSaltAndOrigin& salt_and_origin,
     const std::string& default_device_id,
-    const media::VideoCaptureDeviceDescriptors& device_descriptors) {
+    const MediaDeviceEnumeration& enumeration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::vector<blink::mojom::VideoInputDeviceCapabilitiesPtr>
       video_input_capabilities;
-  for (const auto& descriptor : device_descriptors) {
+  for (const auto& device_info : enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT]) {
     std::string hmac_device_id =
         GetHMACForMediaDeviceID(salt_and_origin.device_id_salt,
-                                salt_and_origin.origin, descriptor.device_id);
+                                salt_and_origin.origin, device_info.device_id);
+    std::string hmac_group_id =
+        GetHMACForMediaDeviceID(salt_and_origin.group_id_salt,
+                                salt_and_origin.origin, device_info.group_id);
     blink::mojom::VideoInputDeviceCapabilitiesPtr capabilities =
         blink::mojom::VideoInputDeviceCapabilities::New();
     capabilities->device_id = std::move(hmac_device_id);
+    capabilities->group_id = std::move(hmac_group_id);
     capabilities->formats =
         media_stream_manager_->media_devices_manager()->GetVideoInputFormats(
-            descriptor.device_id, true /* try_in_use_first */);
-    capabilities->facing_mode = descriptor.facing;
-    if (descriptor.device_id == default_device_id) {
+            device_info.device_id, true /* try_in_use_first */);
+    capabilities->facing_mode = device_info.video_facing;
+    if (device_info.device_id == default_device_id) {
       video_input_capabilities.insert(video_input_capabilities.begin(),
                                       std::move(capabilities));
     } else {

content/browser/renderer_host/media/media_devices_dispatcher_host.h

@@ -74,7 +74,7 @@ class CONTENT_EXPORT MediaDevicesDispatcherHost
       GetVideoInputCapabilitiesCallback client_callback,
       const MediaDeviceSaltAndOrigin& salt_and_origin,
       const std::string& default_device_id,
-      const media::VideoCaptureDeviceDescriptors& device_descriptors);
+      const MediaDeviceEnumeration& enumeration);
 
   void GetDefaultAudioInputDeviceID(
       GetAudioInputCapabilitiesCallback client_callback,

content/renderer/media/stream/apply_constraints_processor.cc

@@ -247,6 +247,8 @@ VideoCaptureSettings ApplyConstraintsProcessor::SelectVideoSettings(
       blink::mojom::VideoInputDeviceCapabilities::New();
   device_capabilities->device_id =
       current_request_.Track().Source().Id().Ascii();
+  device_capabilities->group_id =
+      current_request_.Track().Source().GroupId().Ascii();
   device_capabilities->facing_mode =
       GetCurrentVideoSource() ? GetCurrentVideoSource()->device().video_facing
                               : media::MEDIA_VIDEO_FACING_NONE;

content/renderer/media/stream/media_stream_constraints_util_video_device.cc

@@ -47,11 +47,13 @@ blink::WebString ToWebString(media::VideoFacingMode facing_mode) {
 struct Candidate {
  public:
   Candidate(const std::string& device_id,
+            const std::string& group_id,
             const media::VideoCaptureFormat& format,
             media::VideoFacingMode facing_mode,
             media::PowerLineFrequency power_line_frequency,
             const base::Optional<bool>& noise_reduction)
       : device_id_(device_id),
+        group_id_(group_id),
         format_(format),
         facing_mode_(facing_mode),
         power_line_frequency_(power_line_frequency),
@@ -66,6 +68,9 @@ struct Candidate {
   blink::WebString GetDeviceId() const {
     return blink::WebString::FromASCII(device_id_.data());
   }
+  blink::WebString GetGroupId() const {
+    return blink::WebString::FromASCII(group_id_.data());
+  }
   blink::WebString GetVideoKind() const {
     return GetVideoKindForFormat(format_);
   }
@@ -73,6 +78,7 @@ struct Candidate {
   // Accessors.
   const media::VideoCaptureFormat& format() const { return format_; }
   const std::string& device_id() const { return device_id_; }
+  const std::string& group_id() const { return group_id_; }
   media::VideoFacingMode facing_mode() const { return facing_mode_; }
   media::PowerLineFrequency power_line_frequency() const {
     return power_line_frequency_;
@@ -83,6 +89,7 @@ struct Candidate {
 
  private:
   std::string device_id_;
+  std::string group_id_;
   media::VideoCaptureFormat format_;
   media::VideoFacingMode facing_mode_;
   media::PowerLineFrequency power_line_frequency_;
@@ -429,12 +436,16 @@ double NoiseReductionConstraintSourceDistance(
 // characteristics that have a fixed value.
 double DeviceSourceDistance(
     const std::string& device_id,
+    const std::string& group_id,
     media::VideoFacingMode facing_mode,
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name) {
   return StringConstraintSourceDistance(blink::WebString::FromASCII(device_id),
                                         constraint_set.device_id,
                                         failed_constraint_name) +
+         StringConstraintSourceDistance(blink::WebString::FromASCII(group_id),
+                                        constraint_set.group_id,
+                                        failed_constraint_name) +
          StringConstraintSourceDistance(ToWebString(facing_mode),
                                         constraint_set.facing_mode,
                                         failed_constraint_name);
@@ -483,8 +494,9 @@ double CandidateSourceDistance(
     const ConstrainedFormat& constrained_format,
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name) {
-  return DeviceSourceDistance(candidate.device_id(), candidate.facing_mode(),
-                              constraint_set, failed_constraint_name) +
+  return DeviceSourceDistance(candidate.device_id(), candidate.group_id(),
+                              candidate.facing_mode(), constraint_set,
+                              failed_constraint_name) +
          FormatSourceDistance(candidate.format(), constrained_format,
                               constraint_set, failed_constraint_name) +
          PowerLineFrequencyConstraintSourceDistance(
@@ -640,6 +652,8 @@ double CandidateFitnessDistance(
       constraint_set.aspect_ratio);
   fitness += StringConstraintFitnessDistance(candidate.GetDeviceId(),
                                              constraint_set.device_id);
+  fitness += StringConstraintFitnessDistance(candidate.GetGroupId(),
+                                             constraint_set.group_id);
   fitness += StringConstraintFitnessDistance(candidate.GetFacingMode(),
                                              constraint_set.facing_mode);
   fitness += StringConstraintFitnessDistance(candidate.GetVideoKind(),
@@ -799,9 +813,9 @@ VideoCaptureSettings SelectSettingsVideoDeviceCapture(
   const char* failed_constraint_name = result.failed_constraint_name();
 
   for (auto& device : capabilities.device_capabilities) {
-    double basic_device_distance =
-        DeviceSourceDistance(device->device_id, device->facing_mode,
-                             constraints.Basic(), &failed_constraint_name);
+    double basic_device_distance = DeviceSourceDistance(
+        device->device_id, device->group_id, device->facing_mode,
+        constraints.Basic(), &failed_constraint_name);
     if (!std::isfinite(basic_device_distance))
       continue;
 
@@ -843,8 +857,9 @@ VideoCaptureSettings SelectSettingsVideoDeviceCapture(
           // Custom distances must be added to the candidate distance vector
           // after all the spec-mandated values.
           DistanceVector advanced_custom_distance_vector;
-          Candidate candidate(device->device_id, format, device->facing_mode,
-                              power_line_frequency, noise_reduction);
+          Candidate candidate(device->device_id, device->group_id, format,
+                              device->facing_mode, power_line_frequency,
+                              noise_reduction);
           DistanceVector candidate_distance_vector;
           // First criteria for valid candidates is satisfaction of advanced
           // constraint sets.

content/renderer/media/stream/media_stream_constraints_util_video_device_unittest.cc

@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "base/optional.h"
+#include "base/stl_util.h"
 #include "content/renderer/media/stream/media_stream_video_source.h"
 #include "content/renderer/media/stream/mock_constraint_factory.h"
 #include "media/base/limits.h"
@@ -24,6 +25,12 @@ const char kDeviceID3[] = "fake_device_3";
 const char kDeviceID4[] = "fake_device_4";
 const char kDeviceID5[] = "fake_device_5";
 
+const char kGroupID1[] = "fake_group_1";
+const char kGroupID2[] = "fake_group_2";
+const char kGroupID3[] = "fake_group_3";
+const char kGroupID4[] = "fake_group_4";
+const char kGroupID5[] = "fake_group_5";
+
 void CheckTrackAdapterSettingsEqualsResolution(
     const VideoCaptureSettings& settings) {
   EXPECT_EQ(settings.Format().frame_size.width(),
@@ -73,6 +80,7 @@ class MediaStreamConstraintsUtilVideoDeviceTest : public testing::Test {
     blink::mojom::VideoInputDeviceCapabilitiesPtr device =
         blink::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kDeviceID1;
+    device->group_id = kGroupID1;
     device->facing_mode = media::MEDIA_VIDEO_FACING_NONE;
     device->formats = {
         media::VideoCaptureFormat(gfx::Size(200, 200), 40.0f,
@@ -88,6 +96,7 @@ class MediaStreamConstraintsUtilVideoDeviceTest : public testing::Test {
     // A low-resolution device.
     device = blink::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kDeviceID2;
+    device->group_id = kGroupID2;
     device->facing_mode = media::MEDIA_VIDEO_FACING_ENVIRONMENT;
     device->formats = {
         media::VideoCaptureFormat(gfx::Size(40, 30), 20.0f,
@@ -108,6 +117,7 @@ class MediaStreamConstraintsUtilVideoDeviceTest : public testing::Test {
     // A high-resolution device.
     device = blink::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kDeviceID3;
+    device->group_id = kGroupID3;
     device->facing_mode = media::MEDIA_VIDEO_FACING_USER;
     device->formats = {
         media::VideoCaptureFormat(gfx::Size(600, 400), 10.0f,
@@ -139,6 +149,7 @@ class MediaStreamConstraintsUtilVideoDeviceTest : public testing::Test {
     // A depth capture device.
     device = blink::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kDeviceID4;
+    device->group_id = kGroupID4;
     device->facing_mode = media::MEDIA_VIDEO_FACING_ENVIRONMENT;
     device->formats = {media::VideoCaptureFormat(gfx::Size(640, 480), 30.0f,
                                                  media::PIXEL_FORMAT_Y16)};
@@ -148,6 +159,7 @@ class MediaStreamConstraintsUtilVideoDeviceTest : public testing::Test {
     // be supported if no constraints are placed on the frame rate.
     device = blink::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kDeviceID5;
+    device->group_id = kGroupID5;
     device->facing_mode = media::MEDIA_VIDEO_FACING_NONE;
     device->formats = {
         media::VideoCaptureFormat(
@@ -227,6 +239,16 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, OverconstrainedOnDeviceID) {
             result.failed_constraint_name());
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, OverconstrainedOnGroupID) {
+  constraint_factory_.Reset();
+  constraint_factory_.basic().group_id.SetExact(
+      blink::WebString::FromASCII("NONEXISTING"));
+  auto result = SelectSettings();
+  EXPECT_FALSE(result.HasValue());
+  EXPECT_EQ(constraint_factory_.basic().group_id.GetName(),
+            result.failed_constraint_name());
+}
+
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, OverconstrainedOnFacingMode) {
   constraint_factory_.Reset();
   // No device in |capabilities_| has facing mode equal to LEFT.
@@ -436,6 +458,37 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryDeviceID) {
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryGroupID) {
+  constraint_factory_.Reset();
+  constraint_factory_.basic().group_id.SetExact(
+      blink::WebString::FromASCII(default_device_->group_id));
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  EXPECT_EQ(default_device_->device_id, result.device_id());
+  EXPECT_EQ(*default_closest_format_, result.Format());
+  EXPECT_EQ(media::PowerLineFrequency::FREQUENCY_DEFAULT,
+            result.PowerLineFrequency());
+  CheckTrackAdapterSettingsEqualsFormat(result);
+
+  constraint_factory_.basic().group_id.SetExact(
+      blink::WebString::FromASCII(low_res_device_->group_id));
+  result = SelectSettings();
+  EXPECT_EQ(low_res_device_->device_id, result.device_id());
+  EXPECT_EQ(*low_res_closest_format_, result.Format());
+  EXPECT_EQ(media::PowerLineFrequency::FREQUENCY_DEFAULT,
+            result.PowerLineFrequency());
+  CheckTrackAdapterSettingsEqualsFormat(result);
+
+  constraint_factory_.basic().group_id.SetExact(
+      blink::WebString::FromASCII(high_res_device_->group_id));
+  result = SelectSettings();
+  EXPECT_EQ(high_res_device_->device_id, result.device_id());
+  EXPECT_EQ(*high_res_closest_format_, result.Format());
+  EXPECT_EQ(media::PowerLineFrequency::FREQUENCY_DEFAULT,
+            result.PowerLineFrequency());
+  CheckTrackAdapterSettingsEqualsFormat(result);
+}
+
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryFacingMode) {
   constraint_factory_.Reset();
   constraint_factory_.basic().facing_mode.SetExact(
@@ -2127,13 +2180,13 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedDeviceID) {
   blink::WebString id_vector1[] = {blink::WebString::FromASCII(kDeviceID1),
                                    blink::WebString::FromASCII(kDeviceID2)};
   advanced1.device_id.SetExact(
-      blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1)));
+      blink::WebVector<blink::WebString>(id_vector1, base::size(id_vector1)));
   blink::WebString id_vector2[] = {blink::WebString::FromASCII(kDeviceID2),
                                    blink::WebString::FromASCII(kDeviceID3)};
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
   advanced2.device_id.SetExact(
-      blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2)));
+      blink::WebVector<blink::WebString>(id_vector2, base::size(id_vector2)));
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // kDeviceID2 must be selected because it is the only one that satisfies both
@@ -2142,6 +2195,28 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedDeviceID) {
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedGroupID) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  blink::WebString id_vector1[] = {blink::WebString::FromASCII(kGroupID1),
+                                   blink::WebString::FromASCII(kGroupID2)};
+  advanced1.group_id.SetExact(
+      blink::WebVector<blink::WebString>(id_vector1, base::size(id_vector1)));
+  blink::WebString id_vector2[] = {blink::WebString::FromASCII(kGroupID2),
+                                   blink::WebString::FromASCII(kGroupID3)};
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.group_id.SetExact(
+      blink::WebVector<blink::WebString>(id_vector2, base::size(id_vector2)));
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The device with group_id kGroupID2 must be selected because it is the only
+  // one that satisfies both advanced sets.
+  EXPECT_EQ(std::string(kDeviceID2), result.device_id());
+  CheckTrackAdapterSettingsEqualsFormat(result);
+}
+
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
        AdvancedContradictoryDeviceID) {
   constraint_factory_.Reset();
@@ -2150,13 +2225,36 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
   blink::WebString id_vector1[] = {blink::WebString::FromASCII(kDeviceID1),
                                    blink::WebString::FromASCII(kDeviceID2)};
   advanced1.device_id.SetExact(
-      blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1)));
+      blink::WebVector<blink::WebString>(id_vector1, base::size(id_vector1)));
   blink::WebString id_vector2[] = {blink::WebString::FromASCII(kDeviceID3),
                                    blink::WebString::FromASCII(kDeviceID4)};
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
   advanced2.device_id.SetExact(
-      blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2)));
+      blink::WebVector<blink::WebString>(id_vector2, base::size(id_vector2)));
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set.
+  EXPECT_EQ(std::string(kDeviceID1), result.device_id());
+  CheckTrackAdapterSettingsEqualsFormat(result);
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryGroupID) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  blink::WebString id_vector1[] = {blink::WebString::FromASCII(kGroupID1),
+                                   blink::WebString::FromASCII(kGroupID2)};
+  advanced1.group_id.SetExact(
+      blink::WebVector<blink::WebString>(id_vector1, base::size(id_vector1)));
+  blink::WebString id_vector2[] = {blink::WebString::FromASCII(kGroupID3),
+                                   blink::WebString::FromASCII(kGroupID4)};
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.group_id.SetExact(
+      blink::WebVector<blink::WebString>(id_vector2, base::size(id_vector2)));
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // The second advanced set must be ignored because it contradicts the first

third_party/WebKit/LayoutTests/external/wpt/mediacapture-streams/MediaDevices-getUserMedia.https.html

@@ -36,6 +36,34 @@ test(function () {
   //   list.deviceId
   //   list.groupId
   }, "mediaDevices.getUserMedia() is present on navigator");
+
+promise_test(t => {
+  return navigator.mediaDevices.enumerateDevices()
+    .then(t.step_func(async devices => {
+      for (var i in devices) {
+        await navigator.mediaDevices.getUserMedia(
+          {video: {groupId: {exact: devices[i].groupId}}})
+            .then(
+              t.step_func(stream => {
+                var found_device = devices.find(element => {
+                  return element.deviceId ==
+                           stream.getTracks()[0].getSettings().deviceId;
+                });
+                assert_true(undefined !== found_device);
+                assert_equals(found_device.kind, "videoinput");
+                assert_equals(found_device.groupId, devices[i].groupId);
+              }),
+              t.step_func(error => {
+                assert_equals(error.name, "OverconstrainedError");
+                assert_equals(error.constraint, "groupId");
+                var found_device = devices.find(element => {
+                  return element.kind == "videoinput" &&
+                        element.groupId == devices[i].groupId});
+                assert_true(undefined === found_device);
+              }));
+      }
+    }));
+}, 'groupId is correctly supported by getUserMedia() for video devices');
 </script>
 </body>
 </html>

third_party/WebKit/LayoutTests/external/wpt/mediacapture-streams/MediaStreamTrack-applyConstraints.https.html

+<!doctype html>
+<title>MediaStreamTrack applyConstraints</title>
+<p class="instructions">When prompted, accept to share your video stream.</p>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+  'use strict'
+
+  // https://w3c.github.io/mediacapture-main/#dom-mediastreamtrack-applyconstraints
+
+  promise_test(t => {
+    return navigator.mediaDevices.getUserMedia({ video: true })
+      .then(t.step_func(stream => {
+        return stream.getVideoTracks()[0].applyConstraints(
+          { groupId: { exact: "INVALID" } }).then(
+            t.unreached_func('Accepted invalid groupID'),
+            t.step_func(e => {
+              assert_equals(e.name, 'OverconstrainedError');
+              assert_equals(e.constraint, 'groupId');
+            }));
+      }));
+  }, 'applyConstraints rejects invalid groupID');
+
+  promise_test(t => {
+    return navigator.mediaDevices.getUserMedia({ video: true })
+      .then(t.step_func(stream => {
+        var track = stream.getVideoTracks()[0];
+        var groupId = track.getSettings().groupId;
+        return track.applyConstraints({ groupId: "INVALID" }).then(
+          t.step_func(() => {
+            assert_equals(track.getSettings().groupId, groupId);
+          }));
+      }));
+  }, 'applyConstraints accepts invalid ideal groupID, does not change setting');
+
+  promise_test(t => {
+    return navigator.mediaDevices.getUserMedia({ video: true })
+      .then(t.step_func(stream => {
+        var track = stream.getVideoTracks()[0];
+        var groupId = track.getSettings().groupId;
+        return navigator.mediaDevices.enumerateDevices().then(devices => {
+          var anotherDevice = devices.find(device => {
+            return device.kind == "videoinput" && device.groupId != groupId;
+          });
+          if (anotherDevice !== undefined) {
+            return track.applyConstraints(
+              { groupId: { exact: anotherDevice.groupId } }).then(
+                t.unreached_func(),
+                t.step_func(e => {
+                  assert_equals(e.name, 'OverconstrainedError');
+                  assert_equals(e.constraint, 'groupId');
+                }));
+          }
+        });
+      }));
+  }, 'applyConstraints rejects attempt to switch device using groupId');
+</script>

third_party/blink/public/platform/modules/mediastream/media_devices.mojom

@@ -28,6 +28,7 @@ struct MediaDeviceInfo {
 
 struct VideoInputDeviceCapabilities {
   string device_id;
+  string group_id;
   array<media.mojom.VideoCaptureFormat> formats;
   FacingMode facing_mode;
 };

third_party/blink/renderer/modules/mediastream/media_devices_test.cc

@@ -2,13 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "third_party/blink/renderer/modules/mediastream/media_devices.h"
+
+#include <memory>
+#include <utility>
+
 #include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/bindings/core/v8/exception_state.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_testing.h"
 #include "third_party/blink/renderer/core/testing/null_execution_context.h"
-#include "third_party/blink/renderer/modules/mediastream/media_devices.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream_constraints.h"
 #include "third_party/blink/renderer/platform/testing/testing_platform_support.h"
 
@@ -21,6 +25,8 @@ const char kFakeAudioInputDeviceId1[] = "fake_audio_input 1";
 const char kFakeAudioInputDeviceId2[] = "fake_audio_input 2";
 const char kFakeVideoInputDeviceId1[] = "fake_video_input 1";
 const char kFakeVideoInputDeviceId2[] = "fake_video_input 2";
+const char kFakeCommonGroupId1[] = "fake_group 1";
+const char kFakeVideoInputGroupId2[] = "fake_video_input_group 2";
 const char kFakeAudioOutputDeviceId1[] = "fake_audio_output 1";
 
 class MockMediaDevicesDispatcherHost
@@ -42,7 +48,7 @@ class MockMediaDevicesDispatcherHost
       device_info = mojom::blink::MediaDeviceInfo::New();
       device_info->device_id = kFakeAudioInputDeviceId1;
       device_info->label = "Fake Audio Input 1";
-      device_info->group_id = "fake_group 1";
+      device_info->group_id = kFakeCommonGroupId1;
       enumeration[static_cast<size_t>(MediaDeviceType::MEDIA_AUDIO_INPUT)]
           .push_back(std::move(device_info));
 
@@ -57,14 +63,14 @@ class MockMediaDevicesDispatcherHost
       device_info = mojom::blink::MediaDeviceInfo::New();
       device_info->device_id = kFakeVideoInputDeviceId1;
       device_info->label = "Fake Video Input 1";
-      device_info->group_id = "";
+      device_info->group_id = kFakeCommonGroupId1;
       enumeration[static_cast<size_t>(MediaDeviceType::MEDIA_VIDEO_INPUT)]
           .push_back(std::move(device_info));
 
       device_info = mojom::blink::MediaDeviceInfo::New();
       device_info->device_id = kFakeVideoInputDeviceId2;
       device_info->label = "Fake Video Input 2";
-      device_info->group_id = "";
+      device_info->group_id = kFakeVideoInputGroupId2;
       enumeration[static_cast<size_t>(MediaDeviceType::MEDIA_VIDEO_INPUT)]
           .push_back(std::move(device_info));
 
@@ -72,11 +78,13 @@ class MockMediaDevicesDispatcherHost
         mojom::blink::VideoInputDeviceCapabilitiesPtr capabilities =
             mojom::blink::VideoInputDeviceCapabilities::New();
         capabilities->device_id = kFakeVideoInputDeviceId1;
+        capabilities->group_id = kFakeCommonGroupId1;
         capabilities->facing_mode = blink::mojom::FacingMode::NONE;
         video_input_capabilities.push_back(std::move(capabilities));
 
         capabilities = mojom::blink::VideoInputDeviceCapabilities::New();
         capabilities->device_id = kFakeVideoInputDeviceId2;
+        capabilities->group_id = kFakeVideoInputGroupId2;
         capabilities->facing_mode = blink::mojom::FacingMode::USER;
         video_input_capabilities.push_back(std::move(capabilities));
       }
@@ -85,7 +93,7 @@ class MockMediaDevicesDispatcherHost
       device_info = mojom::blink::MediaDeviceInfo::New();
       device_info->device_id = kFakeAudioOutputDeviceId1;
       device_info->label = "Fake Audio Input 1";
-      device_info->group_id = "fake_group 1";
+      device_info->group_id = kFakeCommonGroupId1;
       enumeration[static_cast<size_t>(MediaDeviceType::MEDIA_AUDIO_OUTPUT)]
           .push_back(std::move(device_info));
     }
@@ -320,13 +328,13 @@ TEST_F(MediaDevicesTest, EnumerateDevices) {
   EXPECT_FALSE(device->deviceId().IsEmpty());
   EXPECT_EQ("videoinput", device->kind());
   EXPECT_FALSE(device->label().IsEmpty());
-  EXPECT_TRUE(device->groupId().IsEmpty());
+  EXPECT_FALSE(device->groupId().IsEmpty());
 
   device = device_infos()[3];
   EXPECT_FALSE(device->deviceId().IsEmpty());
   EXPECT_EQ("videoinput", device->kind());
   EXPECT_FALSE(device->label().IsEmpty());
-  EXPECT_TRUE(device->groupId().IsEmpty());
+  EXPECT_FALSE(device->groupId().IsEmpty());
 
   // Audio output device.
   device = device_infos()[4];
@@ -335,7 +343,8 @@ TEST_F(MediaDevicesTest, EnumerateDevices) {
   EXPECT_FALSE(device->label().IsEmpty());
   EXPECT_FALSE(device->groupId().IsEmpty());
 
-  // Verfify group IDs.
+  // Verify group IDs.
+  EXPECT_EQ(device_infos()[0]->groupId(), device_infos()[2]->groupId());
   EXPECT_EQ(device_infos()[0]->groupId(), device_infos()[4]->groupId());
   EXPECT_NE(device_infos()[1]->groupId(), device_infos()[4]->groupId());
 }