Add observable settings for getDisplayMedia()

This CL adds observable settings to MediaStreamTrack objects returned by
getDisplayMedia() calls. These constrainable properties are set before
the stream is returned based on user choice.

Information about these settings are stored in DisplayMediaInformation
struct. It is set in the low level device selection and then parsed by
UserMediaProcessor before passing it to blink.

Bug: 326740
Change-Id: I81d5f2eb24d2c1a37df0fbe2d34bc469fa575bf1
Reviewed-on: https://chromium-review.googlesource.com/1185875Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Weiyong Yao <braveyao@chromium.org>
Commit-Queue: Emircan Uysaler <emircan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588162}

chrome/browser/media/webrtc/desktop_capture_devices_util.cc

@@ -8,15 +8,52 @@
 #include <utility>
 
 #include "base/strings/string_util.h"
+#include "build/build_config.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/ui/screen_capture_notification_ui.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/audio/audio_device_description.h"
+#include "media/base/display_media_information.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
+media::DisplayMediaInformation DesktopMediaIDToDisplayMediaInformation(
+    const content::DesktopMediaID& media_id) {
+  media::DisplayCaptureSurfaceType display_surface =
+      media::DisplayCaptureSurfaceType::MONITOR;
+  bool logical_surface = true;
+  media::CursorCaptureType cursor = media::CursorCaptureType::NEVER;
+#if defined(USE_AURA)
+  const bool uses_aura =
+      media_id.aura_id != content::DesktopMediaID::kNullId ? true : false;
+#else
+  const bool uses_aura = false;
+#endif  // defined(USE_AURA)
+  switch (media_id.type) {
+    case content::DesktopMediaID::TYPE_SCREEN:
+      display_surface = media::DisplayCaptureSurfaceType::MONITOR;
+      cursor = uses_aura ? media::CursorCaptureType::MOTION
+                         : media::CursorCaptureType::ALWAYS;
+      break;
+    case content::DesktopMediaID::TYPE_WINDOW:
+      display_surface = media::DisplayCaptureSurfaceType::WINDOW;
+      cursor = uses_aura ? media::CursorCaptureType::MOTION
+                         : media::CursorCaptureType::ALWAYS;
+      break;
+    case content::DesktopMediaID::TYPE_WEB_CONTENTS:
+      display_surface = media::DisplayCaptureSurfaceType::BROWSER;
+      cursor = media::CursorCaptureType::MOTION;
+      break;
+    case content::DesktopMediaID::TYPE_NONE:
+      break;
+  }
+
+  return media::DisplayMediaInformation(display_surface, logical_surface,
+                                        cursor);
+}
+
 base::string16 GetStopSharingUIString(
     const base::string16& application_title,
     const base::string16& registered_extension_name,
@@ -94,7 +131,7 @@ base::string16 GetStopSharingUIString(
 std::unique_ptr<content::MediaStreamUI> GetDevicesForDesktopCapture(
     content::WebContents* web_contents,
     content::MediaStreamDevices* devices,
-    content::DesktopMediaID media_id,
+    const content::DesktopMediaID& media_id,
     content::MediaStreamType devices_video_type,
     content::MediaStreamType devices_audio_type,
     bool capture_audio,
@@ -112,8 +149,10 @@ std::unique_ptr<content::MediaStreamUI> GetDevicesForDesktopCapture(
            << registered_extension_name;
 
   // Add selected desktop source to the list.
-  devices->push_back(content::MediaStreamDevice(
-      devices_video_type, media_id.ToString(), media_id.ToString()));
+  auto device = content::MediaStreamDevice(
+      devices_video_type, media_id.ToString(), media_id.ToString());
+  device.display_media_info = DesktopMediaIDToDisplayMediaInformation(media_id);
+  devices->push_back(device);
   if (capture_audio) {
     if (media_id.type == content::DesktopMediaID::TYPE_WEB_CONTENTS) {
       content::WebContentsMediaCaptureId web_id = media_id.web_contents_id;

chrome/browser/media/webrtc/desktop_capture_devices_util.h

@@ -18,7 +18,7 @@
 std::unique_ptr<content::MediaStreamUI> GetDevicesForDesktopCapture(
     content::WebContents* web_contents,
     content::MediaStreamDevices* devices,
-    content::DesktopMediaID media_id,
+    const content::DesktopMediaID& media_id,
     content::MediaStreamType devices_video_type,
     content::MediaStreamType devices_audio_type,
     bool capture_audio,

chrome/browser/media/webrtc/display_media_access_handler_unittest.cc

@@ -93,6 +93,7 @@ TEST_F(DisplayMediaAccessHandlerTest, PermissionGiven) {
   EXPECT_EQ(content::MEDIA_DEVICE_OK, result);
   EXPECT_EQ(1u, devices.size());
   EXPECT_EQ(content::MEDIA_DISPLAY_VIDEO_CAPTURE, devices[0].type);
+  EXPECT_TRUE(devices[0].display_media_info.has_value());
 }
 
 TEST_F(DisplayMediaAccessHandlerTest, PermissionDenied) {

content/browser/renderer_host/media/media_stream_manager.cc

@@ -55,6 +55,7 @@
 #include "media/audio/audio_system.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/channel_layout.h"
+#include "media/base/display_media_information.h"
 #include "media/base/media_switches.h"
 #include "media/capture/video/create_video_capture_device_factory.h"
 #include "media/capture/video/fake_video_capture_device.h"
@@ -190,14 +191,20 @@ MediaStreamType AdjustAudioStreamTypeBasedOnCommandLineSwitches(
                                               : MEDIA_NO_SERVICE;
 }
 
-// Returns DesktopMediaID with fake initializers if
-// |kUseFakeDeviceForMediaStream| is set. Returns the default DesktopMediaID
-// otherwise.
-DesktopMediaID FindDesktopMediaIDFromFakeDeviceConfig() {
+// Returns MediaStreamDevice built with DesktopMediaID with fake
+// initializers if |kUseFakeDeviceForMediaStream| is set. Returns a
+// MediaStreamDevice with default DesktopMediaID otherwise.
+MediaStreamDevice MediaStreamDeviceFromFakeDeviceConfig() {
   // TODO(emircan): When getDisplayMedia() accepts constraints, pick
   // the corresponding type.
-  DesktopMediaID media_id =
-      DesktopMediaID(DesktopMediaID::TYPE_SCREEN, DesktopMediaID::kNullId);
+  DesktopMediaID media_id(DesktopMediaID::TYPE_SCREEN, DesktopMediaID::kNullId);
+
+  MediaStreamDevice device(MEDIA_DISPLAY_VIDEO_CAPTURE, media_id.ToString(),
+                           media_id.ToString());
+  media::DisplayCaptureSurfaceType display_surface =
+      media::DisplayCaptureSurfaceType::MONITOR;
+  device.display_media_info = media::DisplayMediaInformation(
+      display_surface, true, media::CursorCaptureType::NEVER);
 
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
@@ -210,26 +217,31 @@ DesktopMediaID FindDesktopMediaIDFromFakeDeviceConfig() {
                 switches::kUseFakeDeviceForMediaStream),
             &config);
     if (config.empty())
-      return media_id;
+      return device;
 
     DesktopMediaID::Type desktop_media_type = DesktopMediaID::TYPE_NONE;
     switch (config[0].display_media_type) {
       case media::FakeVideoCaptureDevice::DisplayMediaType::ANY:
-        desktop_media_type = DesktopMediaID::TYPE_SCREEN;
-        break;
       case media::FakeVideoCaptureDevice::DisplayMediaType::MONITOR:
         desktop_media_type = DesktopMediaID::TYPE_SCREEN;
+        display_surface = media::DisplayCaptureSurfaceType::MONITOR;
         break;
       case media::FakeVideoCaptureDevice::DisplayMediaType::WINDOW:
         desktop_media_type = DesktopMediaID::TYPE_WINDOW;
+        display_surface = media::DisplayCaptureSurfaceType::WINDOW;
         break;
       case media::FakeVideoCaptureDevice::DisplayMediaType::BROWSER:
         desktop_media_type = DesktopMediaID::TYPE_WEB_CONTENTS;
+        display_surface = media::DisplayCaptureSurfaceType::BROWSER;
         break;
     }
     media_id = DesktopMediaID(desktop_media_type, DesktopMediaID::kFakeId);
   }
-  return media_id;
+  device = MediaStreamDevice(MEDIA_DISPLAY_VIDEO_CAPTURE, media_id.ToString(),
+                             media_id.ToString());
+  device.display_media_info = media::DisplayMediaInformation(
+      display_surface, true, media::CursorCaptureType::NEVER);
+  return device;
 }
 
 }  // namespace
@@ -1089,10 +1101,7 @@ void MediaStreamManager::PostRequestToUI(
 
     if (request->video_type() == MEDIA_DISPLAY_VIDEO_CAPTURE) {
       DCHECK(devices.empty());
-      DesktopMediaID media_id = FindDesktopMediaIDFromFakeDeviceConfig();
-      devices.push_back(MediaStreamDevice(MEDIA_DISPLAY_VIDEO_CAPTURE,
-                                          media_id.ToString(),
-                                          media_id.ToString()));
+      devices.push_back(MediaStreamDeviceFromFakeDeviceConfig());
     }
     std::unique_ptr<FakeMediaStreamUIProxy> fake_ui = fake_ui_factory_.Run();
     fake_ui->SetAvailableDevices(devices);

content/browser/renderer_host/media/media_stream_manager_unittest.cc

@@ -436,6 +436,7 @@ TEST_F(MediaStreamManagerTest, GetDisplayMediaRequest) {
   run_loop_.Run();
 
   EXPECT_EQ(MEDIA_DISPLAY_VIDEO_CAPTURE, video_device.type);
+  EXPECT_TRUE(video_device.display_media_info.has_value());
   EXPECT_CALL(*media_observer_, OnMediaRequestStateChanged(
                                     _, _, _, _, MEDIA_DISPLAY_VIDEO_CAPTURE,
                                     MEDIA_REQUEST_STATE_CLOSING));

content/common/media/media_stream_param_traits.h

@@ -8,6 +8,7 @@
 #include "content/common/content_export.h"
 #include "content/public/common/media_stream_request.h"
 #include "ipc/ipc_message_macros.h"
+#include "media/base/display_media_information.h"
 #include "media/base/ipc/media_param_traits.h"
 #include "media/capture/ipc/capture_param_traits.h"
 
@@ -20,6 +21,18 @@ IPC_ENUM_TRAITS_MAX_VALUE(content::MediaStreamType,
 IPC_ENUM_TRAITS_MAX_VALUE(media::VideoFacingMode,
                           media::NUM_MEDIA_VIDEO_FACING_MODES - 1)
 
+IPC_ENUM_TRAITS_MAX_VALUE(media::DisplayCaptureSurfaceType,
+                          media::DisplayCaptureSurfaceType::LAST)
+
+IPC_ENUM_TRAITS_MAX_VALUE(media::CursorCaptureType,
+                          media::CursorCaptureType::LAST)
+
+IPC_STRUCT_TRAITS_BEGIN(media::DisplayMediaInformation)
+  IPC_STRUCT_TRAITS_MEMBER(display_surface)
+  IPC_STRUCT_TRAITS_MEMBER(logical_surface)
+  IPC_STRUCT_TRAITS_MEMBER(cursor)
+IPC_STRUCT_TRAITS_END()
+
 IPC_STRUCT_TRAITS_BEGIN(content::MediaStreamDevice)
   IPC_STRUCT_TRAITS_MEMBER(type)
   IPC_STRUCT_TRAITS_MEMBER(id)
@@ -30,4 +43,5 @@ IPC_STRUCT_TRAITS_BEGIN(content::MediaStreamDevice)
   IPC_STRUCT_TRAITS_MEMBER(input)
   IPC_STRUCT_TRAITS_MEMBER(session_id)
   IPC_STRUCT_TRAITS_MEMBER(camera_calibration)
+  IPC_STRUCT_TRAITS_MEMBER(display_media_info)
 IPC_STRUCT_TRAITS_END()

content/public/common/media_stream_request.h

@@ -15,6 +15,7 @@
 #include "base/callback_forward.h"
 #include "content/common/content_export.h"
 #include "media/base/audio_parameters.h"
+#include "media/base/display_media_information.h"
 #include "media/base/video_facing.h"
 #include "media/capture/video/video_capture_device_descriptor.h"
 #include "ui/gfx/native_widget_types.h"
@@ -146,6 +147,9 @@ struct CONTENT_EXPORT MediaStreamDevice {
 
   // This field is optional and available only for some camera models.
   base::Optional<CameraCalibration> camera_calibration;
+
+  // This field is optional and available only for display media devices.
+  base::Optional<media::DisplayMediaInformation> display_media_info;
 };
 
 using MediaStreamDevices = std::vector<MediaStreamDevice>;

content/renderer/media/stream/media_stream_constraints_util_video_device.cc

@@ -13,6 +13,7 @@
 #include "content/renderer/media/stream/media_stream_constraints_util.h"
 #include "content/renderer/media/stream/media_stream_constraints_util_sets.h"
 #include "content/renderer/media/stream/media_stream_video_source.h"
+#include "media/base/display_media_information.h"
 #include "media/base/limits.h"
 #include "third_party/blink/public/platform/web_media_constraints.h"
 #include "third_party/blink/public/platform/web_string.h"
@@ -793,6 +794,33 @@ blink::WebMediaStreamTrack::FacingMode ToWebFacingMode(
   }
 }
 
+blink::WebMediaStreamTrack::DisplayCaptureSurfaceType ToWebDisplaySurface(
+    media::DisplayCaptureSurfaceType display_surface) {
+  switch (display_surface) {
+    case media::DisplayCaptureSurfaceType::MONITOR:
+      return blink::WebMediaStreamTrack::DisplayCaptureSurfaceType::kMonitor;
+    case media::DisplayCaptureSurfaceType::WINDOW:
+      return blink::WebMediaStreamTrack::DisplayCaptureSurfaceType::kWindow;
+    case media::DisplayCaptureSurfaceType::APPLICATION:
+      return blink::WebMediaStreamTrack::DisplayCaptureSurfaceType::
+          kApplication;
+    case media::DisplayCaptureSurfaceType::BROWSER:
+      return blink::WebMediaStreamTrack::DisplayCaptureSurfaceType::kBrowser;
+  }
+}
+
+blink::WebMediaStreamTrack::CursorCaptureType ToWebCursorCaptureType(
+    media::CursorCaptureType cursor) {
+  switch (cursor) {
+    case media::CursorCaptureType::NEVER:
+      return blink::WebMediaStreamTrack::CursorCaptureType::kNever;
+    case media::CursorCaptureType::ALWAYS:
+      return blink::WebMediaStreamTrack::CursorCaptureType::kAlways;
+    case media::CursorCaptureType::MOTION:
+      return blink::WebMediaStreamTrack::CursorCaptureType::kMotion;
+  }
+}
+
 VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities() = default;
 VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities(
     VideoDeviceCaptureCapabilities&& other) = default;

content/renderer/media/stream/media_stream_constraints_util_video_device.h

@@ -17,17 +17,23 @@
 namespace blink {
 class WebString;
 class WebMediaConstraints;
-}
+}  // namespace blink
 
 namespace content {
 
 // Calculates and returns videoKind value for |format|.
 // See https://w3c.github.io/mediacapture-depth.
-blink::WebString CONTENT_EXPORT
-GetVideoKindForFormat(const media::VideoCaptureFormat& format);
+CONTENT_EXPORT blink::WebString GetVideoKindForFormat(
+    const media::VideoCaptureFormat& format);
 
-blink::WebMediaStreamTrack::FacingMode CONTENT_EXPORT
-ToWebFacingMode(media::VideoFacingMode video_facing);
+CONTENT_EXPORT blink::WebMediaStreamTrack::FacingMode ToWebFacingMode(
+    media::VideoFacingMode video_facing);
+
+CONTENT_EXPORT blink::WebMediaStreamTrack::DisplayCaptureSurfaceType
+ToWebDisplaySurface(media::DisplayCaptureSurfaceType display_surface);
+
+CONTENT_EXPORT blink::WebMediaStreamTrack::CursorCaptureType
+ToWebCursorCaptureType(media::CursorCaptureType cursor);
 
 struct CONTENT_EXPORT VideoDeviceCaptureCapabilities {
   VideoDeviceCaptureCapabilities();

content/renderer/media/stream/media_stream_video_track.cc

@@ -390,6 +390,12 @@ void MediaStreamVideoTrack::GetSettings(
     settings.focal_length_x = calibration->focal_length_x;
     settings.focal_length_y = calibration->focal_length_y;
   }
+  if (source_->device().display_media_info.has_value()) {
+    const auto& info = source_->device().display_media_info.value();
+    settings.display_surface = ToWebDisplaySurface(info.display_surface);
+    settings.logical_surface = info.logical_surface;
+    settings.cursor = ToWebCursorCaptureType(info.cursor);
+  }
 }
 
 void MediaStreamVideoTrack::OnReadyStateChanged(

media/base/BUILD.gn

@@ -133,6 +133,8 @@ jumbo_source_set("base") {
     "demuxer_memory_limit.h",
     "demuxer_stream.cc",
     "demuxer_stream.h",
+    "display_media_information.cc",
+    "display_media_information.h",
     "djb2.cc",
     "djb2.h",
     "eme_constants.h",

media/base/display_media_information.cc

+// Copyright 2018 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 "media/base/display_media_information.h"
+
+namespace media {
+
+DisplayMediaInformation::DisplayMediaInformation() = default;
+
+DisplayMediaInformation::DisplayMediaInformation(
+    DisplayCaptureSurfaceType display_surface,
+    bool logical_surface,
+    CursorCaptureType cursor)
+    : display_surface(display_surface),
+      logical_surface(logical_surface),
+      cursor(cursor) {}
+
+}  // namespace media

media/base/display_media_information.h

+// Copyright 2018 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.
+
+#ifndef MEDIA_BASE_DISPLAY_MEDIA_INFORMATION_H_
+#define MEDIA_BASE_DISPLAY_MEDIA_INFORMATION_H_
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+// Following the enums listed at
+// https://w3c.github.io/mediacapture-screen-share/#extensions-to-mediatrackconstraintset.
+
+// Describes the different types of display surface.
+enum class DisplayCaptureSurfaceType {
+  MONITOR,
+  WINDOW,
+  APPLICATION,
+  BROWSER,
+  LAST = BROWSER
+};
+
+// Describes the conditions under which the cursor is captured.
+enum class CursorCaptureType { NEVER, ALWAYS, MOTION, LAST = MOTION };
+
+struct MEDIA_EXPORT DisplayMediaInformation {
+  DisplayMediaInformation();
+  DisplayMediaInformation(DisplayCaptureSurfaceType display_surface,
+                          bool logical_surface,
+                          CursorCaptureType cursor);
+
+  DisplayCaptureSurfaceType display_surface =
+      DisplayCaptureSurfaceType::MONITOR;
+  bool logical_surface = false;
+  CursorCaptureType cursor = CursorCaptureType::NEVER;
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_DISPLAY_MEDIA_INFORMATION_H_

third_party/WebKit/LayoutTests/external/wpt/screen-capture/getdisplaymedia.https-expected.txt

@@ -5,5 +5,6 @@ PASS getDisplayMedia() with video false
 FAIL getDisplayMedia() with audio true promise_test: Unhandled rejection with value: object "TypeError: Failed to execute 'getDisplayMedia' on 'Navigator': Audio is not supported"
 PASS getDisplayMedia() with audio false
 PASS getDisplayMedia() call with non-bool constraint
+PASS getDisplayMedia() with getSettings
 Harness: the test ran to completion.
 

third_party/WebKit/LayoutTests/external/wpt/screen-capture/getdisplaymedia.https.html

@@ -74,4 +74,18 @@ promise_test(function() {
       });
 }, 'getDisplayMedia() call with non-bool constraint');
 
+// Content shell picks a fake desktop device by default.
+promise_test(function() {
+  assert_idl_attribute(navigator, 'getDisplayMedia');
+
+  return navigator.getDisplayMedia({video: true}).then(function(s) {
+    assert_equals(s.getVideoTracks().length, 1);
+    assert_equals(s.getAudioTracks().length, 0);
+    var settings = s.getVideoTracks()[0].getSettings();
+    assert_equals(settings.displaySurface, "monitor");
+    assert_equals(settings.logicalSurface, true);
+    assert_equals(settings.cursor, "never");
+  });
+}, 'getDisplayMedia() with getSettings');
+
 </script>

third_party/blink/public/platform/web_media_stream_track.h

@@ -43,6 +43,13 @@ class WebString;
 class WebMediaStreamTrack {
  public:
   enum class FacingMode { kNone, kUser, kEnvironment, kLeft, kRight };
+  enum class DisplayCaptureSurfaceType {
+    kMonitor,
+    kWindow,
+    kApplication,
+    kBrowser
+  };
+  enum class CursorCaptureType { kNever, kAlways, kMotion };
 
   struct Settings {
     bool HasFrameRate() const { return frame_rate >= 0.0; }
@@ -85,6 +92,11 @@ class WebMediaStreamTrack {
     double focal_length_y = -1.0;
     double depth_near = -1.0;
     double depth_far = -1.0;
+
+    // Screen Capture extensions
+    base::Optional<DisplayCaptureSurfaceType> display_surface;
+    base::Optional<bool> logical_surface;
+    base::Optional<CursorCaptureType> cursor;
   };
 
   class TrackData {

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

@@ -493,6 +493,42 @@ void MediaStreamTrack::getSettings(MediaTrackSettings& settings) {
 
   if (image_capture_)
     image_capture_->GetMediaTrackSettings(settings);
+
+  if (platform_settings.display_surface) {
+    WTF::String value;
+    switch (platform_settings.display_surface.value()) {
+      case WebMediaStreamTrack::DisplayCaptureSurfaceType::kMonitor:
+        value = "monitor";
+        break;
+      case WebMediaStreamTrack::DisplayCaptureSurfaceType::kWindow:
+        value = "window";
+        break;
+      case WebMediaStreamTrack::DisplayCaptureSurfaceType::kApplication:
+        value = "application";
+        break;
+      case WebMediaStreamTrack::DisplayCaptureSurfaceType::kBrowser:
+        value = "browser";
+        break;
+    }
+    settings.setDisplaySurface(value);
+  }
+  if (platform_settings.logical_surface)
+    settings.setLogicalSurface(platform_settings.logical_surface.value());
+  if (platform_settings.cursor) {
+    WTF::String value;
+    switch (platform_settings.cursor.value()) {
+      case WebMediaStreamTrack::CursorCaptureType::kNever:
+        value = "never";
+        break;
+      case WebMediaStreamTrack::CursorCaptureType::kAlways:
+        value = "always";
+        break;
+      case WebMediaStreamTrack::CursorCaptureType::kMotion:
+        value = "motion";
+        break;
+    }
+    settings.setCursor(value);
+  }
 }
 
 ScriptPromise MediaStreamTrack::applyConstraints(

third_party/blink/renderer/modules/mediastream/media_track_settings.idl

@@ -48,4 +48,10 @@ dictionary MediaTrackSettings {
     double            sharpness;
     double            zoom;
     boolean           torch;
+
+    // Screen Capture API
+    // https://w3c.github.io/mediacapture-screen-share
+    [RuntimeEnabled=GetDisplayMedia] DOMString displaySurface;
+    [RuntimeEnabled=GetDisplayMedia] boolean logicalSurface;
+    [RuntimeEnabled=GetDisplayMedia] DOMString cursor;
 };