feat: session.setDisplayMediaRequestHandler

docs/api/session.md

@@ -553,6 +553,44 @@ session.fromPartition('some-partition').setPermissionCheckHandler((webContents,
 })
 ```
 
+#### `ses.setMediaRequestHandler(handler)`
+
+* `handler` Function | null
+  * `request` Object
+    * `frame` [WebFrameMain](web-frame-main.md) - frame that is requesting access to media
+    * `type` String - Type of request. Can be 'deviceAccess', 'deviceUpdate', 'generateStream' or 'openDevicePepperOnly'.
+    * `audioType` String - can be 'deviceAudioCapture', 'displayAudioCapture' or 'noService'.
+    * `videoType` String - can be 'deviceVideoCapture', 'displayVideoCapture', 'displayVideoCaptureThisTab' or 'noService'.
+    * `requestedAudioDeviceId` String -
+    * `requestedVideoDeviceId` String -
+    * `userGesture` Boolean - whether a user gesture was active when this request was triggered.
+  * `callback` Function
+    * `devices` Object[]
+      * `id` String - the id of the device being granted
+      * `name` String - the name of the device being granted
+      * `type` String - the type of the device being granted
+    * `result` String - the result of the request. Can be 'ok',
+      'permissionDenied', 'permissionDismissed', 'noHardware', or 'notSupported'.
+
+This handler will be called when web content requests access to media devices
+via the `navigator.mediaDevices` API. Use the
+[desktopCapturer](desktop-capturer.md) API to choose a device or devices to
+grant access to.
+
+```javascript
+const { session, desktopCapturer } = require('electron')
+
+session.defaultSession.setMediaRequestHandler((request, callback) => {
+  if (request.videoType === 'displayVideoCapture') {
+    desktopCapturer.getSources({ types: ['screen'] }).then((sources) => {
+      // Grant access to the first screen found.
+      const { id, name } = sources[0]
+      callback([{ id, name, type: request.type }], 'ok')
+    })
+  }
+})
+```
+
 #### `ses.clearHostResolverCache()`
 
 Returns `Promise<void>` - Resolves when the operation is complete.

shell/browser/api/electron_api_session.cc

@@ -35,6 +35,7 @@
 #include "content/public/browser/network_service_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "gin/arguments.h"
+#include "gin/data_object_builder.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "net/base/completion_repeating_callback.h"
@@ -52,6 +53,7 @@
 #include "shell/browser/api/electron_api_net_log.h"
 #include "shell/browser/api/electron_api_protocol.h"
 #include "shell/browser/api/electron_api_service_worker_context.h"
+#include "shell/browser/api/electron_api_web_frame_main.h"
 #include "shell/browser/api/electron_api_web_request.h"
 #include "shell/browser/browser.h"
 #include "shell/browser/electron_browser_context.h"
@@ -64,6 +66,7 @@
 #include "shell/common/gin_converters/callback_converter.h"
 #include "shell/common/gin_converters/content_converter.h"
 #include "shell/common/gin_converters/file_path_converter.h"
+#include "shell/common/gin_converters/frame_converter.h"
 #include "shell/common/gin_converters/gurl_converter.h"
 #include "shell/common/gin_converters/net_converter.h"
 #include "shell/common/gin_converters/value_converter.h"
@@ -242,6 +245,229 @@ struct Converter<network::mojom::SSLConfigPtr> {
   }
 };
 
+template <>
+struct Converter<content::MediaStreamRequest> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const content::MediaStreamRequest& request) {
+    content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
+        request.render_process_id, request.render_frame_id);
+    return gin::DataObjectBuilder(isolate)
+        .Set("frame", rfh)
+        .Set("securityOrigin", request.security_origin)
+        .Set("userGesture", request.user_gesture)
+        .Set("type", request.request_type)
+        .Set("requestedAudioDeviceId", request.requested_audio_device_id)
+        .Set("requestedVideoDeviceId", request.requested_video_device_id)
+        .Set("audioType", request.audio_type)
+        .Set("videoType", request.video_type)
+        .Set("disableLocalEcho", request.disable_local_echo)
+        .Set("requestPanTiltZoomPermission",
+             request.request_pan_tilt_zoom_permission)
+        .Build();
+  }
+};
+
+template <>
+struct Converter<blink::MediaStreamDevice> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::MediaStreamDevice* out) {
+    gin_helper::Dictionary dict;
+    if (!gin::ConvertFromV8(isolate, val, &dict))
+      return false;
+    blink::mojom::MediaStreamType type;
+    if (!dict.Get("type", &type))
+      return false;
+    std::string id;
+    if (!dict.Get("id", &id))
+      return false;
+    std::string name;
+    if (!dict.Get("name", &name))
+      return false;
+    *out = blink::MediaStreamDevice(type, id, name);
+    return true;
+  }
+};
+
+template <>
+struct Converter<blink::mojom::MediaStreamRequestResult> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::mojom::MediaStreamRequestResult* out) {
+    std::string type;
+    if (!gin::ConvertFromV8(isolate, val, &type))
+      return false;
+    if (type == "ok") {
+      *out = blink::mojom::MediaStreamRequestResult::OK;
+      return true;
+    }
+    if (type == "permissionDenied") {
+      *out = blink::mojom::MediaStreamRequestResult::PERMISSION_DENIED;
+      return true;
+    }
+    if (type == "permissionDismissed") {
+      *out = blink::mojom::MediaStreamRequestResult::PERMISSION_DISMISSED;
+      return true;
+    }
+    if (type == "invalidState") {
+      *out = blink::mojom::MediaStreamRequestResult::INVALID_STATE;
+      return true;
+    }
+    if (type == "noHardware") {
+      *out = blink::mojom::MediaStreamRequestResult::NO_HARDWARE;
+      return true;
+    }
+    if (type == "invalidSecurityOrigin") {
+      *out = blink::mojom::MediaStreamRequestResult::INVALID_SECURITY_ORIGIN;
+      return true;
+    }
+    if (type == "tabCaptureFailure") {
+      *out = blink::mojom::MediaStreamRequestResult::TAB_CAPTURE_FAILURE;
+      return true;
+    }
+    if (type == "screenCaptureFailure") {
+      *out = blink::mojom::MediaStreamRequestResult::SCREEN_CAPTURE_FAILURE;
+      return true;
+    }
+    if (type == "captureFailure") {
+      *out = blink::mojom::MediaStreamRequestResult::CAPTURE_FAILURE;
+      return true;
+    }
+    if (type == "constraintNotSatisfied") {
+      *out = blink::mojom::MediaStreamRequestResult::CONSTRAINT_NOT_SATISFIED;
+      return true;
+    }
+    if (type == "trackStartFailureAudio") {
+      *out = blink::mojom::MediaStreamRequestResult::TRACK_START_FAILURE_AUDIO;
+      return true;
+    }
+    if (type == "trackStartFailureVideo") {
+      *out = blink::mojom::MediaStreamRequestResult::TRACK_START_FAILURE_VIDEO;
+      return true;
+    }
+    if (type == "notSupported") {
+      *out = blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED;
+      return true;
+    }
+    if (type == "failedDueToShutdown") {
+      *out = blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN;
+      return true;
+    }
+    if (type == "killSwitchOn") {
+      *out = blink::mojom::MediaStreamRequestResult::KILL_SWITCH_ON;
+      return true;
+    }
+    if (type == "systemPermissionDenied") {
+      *out = blink::mojom::MediaStreamRequestResult::SYSTEM_PERMISSION_DENIED;
+      return true;
+    }
+    if (type == "deviceInUse") {
+      *out = blink::mojom::MediaStreamRequestResult::DEVICE_IN_USE;
+      return true;
+    }
+    return false;
+  }
+};
+
+template <>
+struct Converter<blink::MediaStreamRequestType> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const blink::MediaStreamRequestType& request_type) {
+    switch (request_type) {
+      case blink::MEDIA_DEVICE_ACCESS:
+        return gin::StringToV8(isolate, "deviceAccess");
+      case blink::MEDIA_DEVICE_UPDATE:
+        return gin::StringToV8(isolate, "deviceUpdate");
+      case blink::MEDIA_GENERATE_STREAM:
+        return gin::StringToV8(isolate, "generateStream");
+      case blink::MEDIA_OPEN_DEVICE_PEPPER_ONLY:
+        return gin::StringToV8(isolate, "openDevicePepperOnly");
+    }
+  }
+};
+
+template <>
+struct Converter<blink::mojom::MediaStreamType> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const blink::mojom::MediaStreamType& stream_type) {
+    switch (stream_type) {
+      case blink::mojom::MediaStreamType::NO_SERVICE:
+        return gin::StringToV8(isolate, "noService");
+      case blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE:
+        return gin::StringToV8(isolate, "deviceAudioCapture");
+      case blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE:
+        return gin::StringToV8(isolate, "deviceVideoCapture");
+      case blink::mojom::MediaStreamType::GUM_TAB_AUDIO_CAPTURE:
+        return gin::StringToV8(isolate, "gumTabAudioCapture");
+      case blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE:
+        return gin::StringToV8(isolate, "gumTabVideoCapture");
+      case blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE:
+        return gin::StringToV8(isolate, "gumDesktopVideoCapture");
+      case blink::mojom::MediaStreamType::GUM_DESKTOP_AUDIO_CAPTURE:
+        return gin::StringToV8(isolate, "gumDesktopAudioCapture");
+      case blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE:
+        return gin::StringToV8(isolate, "displayVideoCapture");
+      case blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE:
+        return gin::StringToV8(isolate, "displayAudioCapture");
+      case blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE_THIS_TAB:
+        return gin::StringToV8(isolate, "displayVideoCaptureThisTab");
+      case blink::mojom::MediaStreamType::NUM_MEDIA_TYPES:
+        return v8::Null(isolate);
+    }
+  }
+
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::mojom::MediaStreamType* out) {
+    std::string type;
+    if (!gin::ConvertFromV8(isolate, val, &type))
+      return false;
+    if (type == "noService") {
+      *out = blink::mojom::MediaStreamType::NO_SERVICE;
+      return true;
+    }
+    if (type == "deviceAudioCapture") {
+      *out = blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE;
+      return true;
+    }
+    if (type == "deviceVideoCapture") {
+      *out = blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE;
+      return true;
+    }
+    if (type == "gumTabAudioCapture") {
+      *out = blink::mojom::MediaStreamType::GUM_TAB_AUDIO_CAPTURE;
+      return true;
+    }
+    if (type == "gumTabVideoCapture") {
+      *out = blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE;
+      return true;
+    }
+    if (type == "gumDesktopVideoCapture") {
+      *out = blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE;
+      return true;
+    }
+    if (type == "gumDesktopAudioCapture") {
+      *out = blink::mojom::MediaStreamType::GUM_DESKTOP_AUDIO_CAPTURE;
+      return true;
+    }
+    if (type == "displayVideoCapture") {
+      *out = blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE;
+      return true;
+    }
+    if (type == "displayAudioCapture") {
+      *out = blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE;
+      return true;
+    }
+    if (type == "displayVideoCaptureThisTab") {
+      *out = blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE_THIS_TAB;
+      return true;
+    }
+    return false;
+  }
+};
+
 }  // namespace gin
 
 namespace electron {
@@ -644,6 +870,25 @@ void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val,
   permission_manager->SetPermissionCheckHandler(handler);
 }
 
+void Session::SetMediaRequestHandler(MediaRequestHandler handler) {
+  media_request_handler_ = handler;
+}
+
+bool Session::ChooseMediaDevice(const content::MediaStreamRequest& request,
+                                content::MediaResponseCallback callback) {
+  if (!media_request_handler_)
+    return false;
+  MediaResponseCallbackJs callbackJs = base::BindOnce(
+      [](content::MediaResponseCallback callback,
+         const blink::MediaStreamDevices& devices,
+         blink::mojom::MediaStreamRequestResult result) {
+        std::move(callback).Run(devices, result, nullptr);
+      },
+      std::move(callback));
+  media_request_handler_.Run(request, std::move(callbackJs));
+  return true;
+}
+
 v8::Local<v8::Promise> Session::ClearHostResolverCache(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
   gin_helper::Promise<void> promise(isolate);
@@ -1147,6 +1392,7 @@ gin::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
                  &Session::SetPermissionRequestHandler)
       .SetMethod("setPermissionCheckHandler",
                  &Session::SetPermissionCheckHandler)
+      .SetMethod("setMediaRequestHandler", &Session::SetMediaRequestHandler)
       .SetMethod("clearHostResolverCache", &Session::ClearHostResolverCache)
       .SetMethod("clearAuthCache", &Session::ClearAuthCache)
       .SetMethod("allowNTLMCredentialsForDomains",

shell/browser/api/electron_api_session.h

@@ -10,6 +10,7 @@
 
 #include "base/values.h"
 #include "content/public/browser/download_manager.h"
+#include "content/public/browser/media_stream_request.h"
 #include "electron/buildflags/buildflags.h"
 #include "gin/handle.h"
 #include "gin/wrappable.h"
@@ -153,6 +154,9 @@ class Session : public gin::Wrappable<Session>,
                            extensions::UnloadedExtensionReason reason) override;
 #endif
 
+  bool ChooseMediaDevice(const content::MediaStreamRequest& request,
+                         content::MediaResponseCallback callback);
+
  protected:
   Session(v8::Isolate* isolate, ElectronBrowserContext* browser_context);
   ~Session() override;
@@ -179,6 +183,15 @@ class Session : public gin::Wrappable<Session>,
   v8::Global<v8::Value> service_worker_context_;
   v8::Global<v8::Value> web_request_;
 
+  using MediaResponseCallbackJs =
+      base::OnceCallback<void(const blink::MediaStreamDevices& devices,
+                              blink::mojom::MediaStreamRequestResult result)>;
+  using MediaRequestHandler =
+      base::RepeatingCallback<void(const content::MediaStreamRequest&,
+                                   MediaResponseCallbackJs)>;
+  void SetMediaRequestHandler(MediaRequestHandler handler);
+  MediaRequestHandler media_request_handler_;
+
   v8::Isolate* isolate_;
 
   // The client id to enable the network throttler.