[MPArch Guest View] Support Media Access permissions

- Create Guest variants of the Media Access queries on the
GuestPageHolder::Delegate.
- Pass RenderFrameHost into SupportsStreamType.
- Look up the RenderFrameHost from the request object.

Bug: 40202416
Change-Id: Iac31b817892d7222c041b1a78a3e905de2a2f9b2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6157121
Reviewed-by: Mark Foltz <mfoltz@chromium.org>
Reviewed-by: Robbie McElrath <rmcelrath@chromium.org>
Reviewed-by: Kevin McNee <mcnee@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1405643}

chrome/browser/apps/guest_view/web_view_browsertest.cc

@@ -3340,16 +3340,12 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasAccessAllowCamera) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testAllowCamera",
              "web_view/permissions_test/embedder_has_permission",
              NEEDS_TEST_SERVER);
 }
 
 IN_PROC_BROWSER_TEST_P(WebViewTest, PermissionsAPIEmbedderHasAccessDenyCamera) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testDenyCamera",
              "web_view/permissions_test/embedder_has_permission",
              NEEDS_TEST_SERVER);
@@ -3357,8 +3353,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest, PermissionsAPIEmbedderHasAccessDenyCamera) {
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasAccessAllowMicrophone) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testAllowMicrophone",
              "web_view/permissions_test/embedder_has_permission",
              NEEDS_TEST_SERVER);
@@ -3366,24 +3360,18 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasAccessDenyMicrophone) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testDenyMicrophone",
              "web_view/permissions_test/embedder_has_permission",
              NEEDS_TEST_SERVER);
 }
 
 IN_PROC_BROWSER_TEST_P(WebViewTest, PermissionsAPIEmbedderHasAccessAllowMedia) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testAllowMedia",
              "web_view/permissions_test/embedder_has_permission",
              NEEDS_TEST_SERVER);
 }
 
 IN_PROC_BROWSER_TEST_P(WebViewTest, PermissionsAPIEmbedderHasAccessDenyMedia) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testDenyMedia",
              "web_view/permissions_test/embedder_has_permission",
              NEEDS_TEST_SERVER);
@@ -3556,8 +3544,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasNoAccessAllowCamera) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testAllowCamera",
              "web_view/permissions_test/embedder_has_no_permission",
              NEEDS_TEST_SERVER);
@@ -3565,8 +3551,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasNoAccessDenyCamera) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testDenyCamera",
              "web_view/permissions_test/embedder_has_no_permission",
              NEEDS_TEST_SERVER);
@@ -3574,8 +3558,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasNoAccessAllowMicrophone) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testAllowMicrophone",
              "web_view/permissions_test/embedder_has_no_permission",
              NEEDS_TEST_SERVER);
@@ -3583,8 +3565,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasNoAccessDenyMicrophone) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testDenyMicrophone",
              "web_view/permissions_test/embedder_has_no_permission",
              NEEDS_TEST_SERVER);
@@ -3592,8 +3572,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasNoAccessAllowMedia) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testAllowMedia",
              "web_view/permissions_test/embedder_has_no_permission",
              NEEDS_TEST_SERVER);
@@ -3601,8 +3579,6 @@ IN_PROC_BROWSER_TEST_P(WebViewTest,
 
 IN_PROC_BROWSER_TEST_P(WebViewTest,
                        PermissionsAPIEmbedderHasNoAccessDenyMedia) {
-  SKIP_FOR_MPARCH();  // TODO(crbug.com/40202416): Enable test for MPArch.
-
   TestHelper("testDenyMedia",
              "web_view/permissions_test/embedder_has_no_permission",
              NEEDS_TEST_SERVER);

chrome/browser/controlled_frame/controlled_frame_media_access_handler.cc

@@ -54,18 +54,14 @@ ControlledFrameMediaAccessHandler::~ControlledFrameMediaAccessHandler() =
     default;
 
 bool ControlledFrameMediaAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType type,
     const extensions::Extension* extension) {
-  if (!web_contents || extension) {
+  if (!render_frame_host || extension) {
     return false;
   }
-
-  // TODO(b/40238394): |GuestView| should be looked up from |RenderFrameHost|
-  // instead of |WebContents|. To fix this, |SupportsStreamType| could pass
-  // |RenderFrameHost| instead of |WebContents|.
   extensions::WebViewGuest* web_view =
-      extensions::WebViewGuest::FromWebContents(web_contents);
+      extensions::WebViewGuest::FromRenderFrameHost(render_frame_host);
 
   bool is_controlled_frame = web_view && web_view->attached() &&
                              web_view->IsOwnedByControlledFrameEmbedder();

chrome/browser/controlled_frame/controlled_frame_media_access_handler.h

@@ -42,7 +42,7 @@ class ControlledFrameMediaAccessHandler : public MediaAccessHandler {
   ~ControlledFrameMediaAccessHandler() override;
 
   // MediaAccessHandler implementation:
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

chrome/browser/media/chromeos_login_and_lock_media_access_handler.cc

@@ -13,7 +13,9 @@
 #include "chromeos/ash/components/settings/cros_settings.h"
 #include "chromeos/ash/components/settings/cros_settings_names.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
+#include "components/guest_view/browser/guest_view_base.h"
 #include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
 #include "url/gurl.h"
 
 ChromeOSLoginAndLockMediaAccessHandler::
@@ -23,9 +25,12 @@ ChromeOSLoginAndLockMediaAccessHandler::
     ~ChromeOSLoginAndLockMediaAccessHandler() = default;
 
 bool ChromeOSLoginAndLockMediaAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType type,
     const extensions::Extension* extension) {
+  auto* web_contents = guest_view::GuestViewBase::GetTopLevelWebContents(
+      content::WebContents::FromRenderFrameHost(render_frame_host));
+
   if (!web_contents)
     return false;
   // Check if the `web_contents` corresponds to the login screen.

chrome/browser/media/chromeos_login_and_lock_media_access_handler.h

@@ -15,7 +15,7 @@ class ChromeOSLoginAndLockMediaAccessHandler : public MediaAccessHandler {
   ~ChromeOSLoginAndLockMediaAccessHandler() override;
 
   // MediaAccessHandler implementation.
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

chrome/browser/media/extension_media_access_handler.cc

@@ -47,7 +47,7 @@ ExtensionMediaAccessHandler::ExtensionMediaAccessHandler() = default;
 ExtensionMediaAccessHandler::~ExtensionMediaAccessHandler() = default;
 
 bool ExtensionMediaAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType type,
     const extensions::Extension* extension) {
   return extension &&

chrome/browser/media/extension_media_access_handler.h

@@ -14,7 +14,7 @@ class ExtensionMediaAccessHandler : public MediaAccessHandler {
   ~ExtensionMediaAccessHandler() override;
 
   // MediaAccessHandler implementation.
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

chrome/browser/media/media_access_handler.h

@@ -27,7 +27,7 @@ class MediaAccessHandler {
   virtual ~MediaAccessHandler() = default;
 
   // Check if the media stream type is supported by MediaAccessHandler.
-  virtual bool SupportsStreamType(content::WebContents* web_contents,
+  virtual bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                                   const blink::mojom::MediaStreamType type,
                                   const extensions::Extension* extension) = 0;
 

chrome/browser/media/webrtc/desktop_capture_access_handler.cc

@@ -310,7 +310,7 @@ void DesktopCaptureAccessHandler::ProcessScreenCaptureAccessRequest(
 }
 
 bool DesktopCaptureAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType type,
     const extensions::Extension* extension) {
   return type == blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE ||

chrome/browser/media/webrtc/desktop_capture_access_handler.h

@@ -50,7 +50,7 @@ class DesktopCaptureAccessHandler : public CaptureAccessHandlerBase,
   ~DesktopCaptureAccessHandler() override;
 
   // MediaAccessHandler implementation.
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

chrome/browser/media/webrtc/display_media_access_handler.cc

@@ -99,7 +99,7 @@ DisplayMediaAccessHandler::DisplayMediaAccessHandler(
 DisplayMediaAccessHandler::~DisplayMediaAccessHandler() = default;
 
 bool DisplayMediaAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType stream_type,
     const extensions::Extension* extension) {
   return stream_type == blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE ||

chrome/browser/media/webrtc/display_media_access_handler.h

@@ -41,7 +41,7 @@ class DisplayMediaAccessHandler : public CaptureAccessHandlerBase,
   ~DisplayMediaAccessHandler() override;
 
   // MediaAccessHandler implementation.
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType stream_type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

chrome/browser/media/webrtc/media_capture_devices_dispatcher.cc

@@ -68,18 +68,6 @@ using blink::MediaStreamDevices;
 using content::BrowserThread;
 using content::MediaCaptureDevices;
 
-namespace {
-
-content::WebContents* WebContentsFromIds(int render_process_id,
-                                         int render_frame_id) {
-  content::WebContents* web_contents =
-      content::WebContents::FromRenderFrameHost(
-          content::RenderFrameHost::FromID(render_process_id, render_frame_id));
-  return web_contents;
-}
-
-}  // namespace
-
 MediaCaptureDevicesDispatcher* MediaCaptureDevicesDispatcher::GetInstance() {
   return base::Singleton<MediaCaptureDevicesDispatcher>::get();
 }
@@ -158,10 +146,13 @@ void MediaCaptureDevicesDispatcher::ProcessMediaAccessRequest(
   }
 #endif
 
+  auto* render_frame_host = content::RenderFrameHost::FromID(
+      request.render_process_id, request.render_frame_id);
+
   for (const auto& handler : media_access_handlers_) {
-    if (handler->SupportsStreamType(web_contents, request.video_type,
+    if (handler->SupportsStreamType(render_frame_host, request.video_type,
                                     extension) ||
-        handler->SupportsStreamType(web_contents, request.audio_type,
+        handler->SupportsStreamType(render_frame_host, request.audio_type,
                                     extension)) {
       handler->HandleRequest(web_contents, request, std::move(callback),
                              extension);
@@ -200,9 +191,7 @@ bool MediaCaptureDevicesDispatcher::CheckMediaAccessPermission(
     const extensions::Extension* extension) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (const auto& handler : media_access_handlers_) {
-    if (handler->SupportsStreamType(
-            content::WebContents::FromRenderFrameHost(render_frame_host), type,
-            extension)) {
+    if (handler->SupportsStreamType(render_frame_host, type, extension)) {
       return handler->CheckMediaAccessPermission(
           render_frame_host, security_origin, type, extension);
     }
@@ -349,9 +338,9 @@ void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
     content::MediaRequestState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (const auto& handler : media_access_handlers_) {
-    if (handler->SupportsStreamType(
-            WebContentsFromIds(render_process_id, render_frame_id), stream_type,
-            nullptr)) {
+    if (handler->SupportsStreamType(content::RenderFrameHost::FromID(
+                                        render_process_id, render_frame_id),
+                                    stream_type, nullptr)) {
       handler->UpdateMediaRequestState(render_process_id, render_frame_id,
                                        page_request_id, stream_type, state);
       break;
@@ -424,9 +413,9 @@ void MediaCaptureDevicesDispatcher::UpdateVideoScreenCaptureStatus(
   DCHECK(blink::IsVideoScreenCaptureMediaType(stream_type));
 
   for (const auto& handler : media_access_handlers_) {
-    if (handler->SupportsStreamType(
-            WebContentsFromIds(render_process_id, render_frame_id), stream_type,
-            nullptr)) {
+    if (handler->SupportsStreamType(content::RenderFrameHost::FromID(
+                                        render_process_id, render_frame_id),
+                                    stream_type, nullptr)) {
       handler->UpdateVideoScreenCaptureStatus(
           render_process_id, render_frame_id, page_request_id, is_secure);
       break;

chrome/browser/media/webrtc/media_capture_devices_dispatcher_unittest.cc

@@ -25,7 +25,7 @@ class MockMediaAccessHandler : public MediaAccessHandler {
       const blink::mojom::MediaStreamType supported_type)
       : supported_type_(supported_type) {}
 
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override {
     return supported_type_ == type;

chrome/browser/media/webrtc/permission_bubble_media_access_handler.cc

@@ -131,7 +131,7 @@ PermissionBubbleMediaAccessHandler::~PermissionBubbleMediaAccessHandler() =
     default;
 
 bool PermissionBubbleMediaAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType type,
     const extensions::Extension* extension) {
   return type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE ||

chrome/browser/media/webrtc/permission_bubble_media_access_handler.h

@@ -29,7 +29,7 @@ class PermissionBubbleMediaAccessHandler
   ~PermissionBubbleMediaAccessHandler() override;
 
   // MediaAccessHandler implementation.
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

chrome/browser/media/webrtc/tab_capture_access_handler.cc

@@ -99,7 +99,7 @@ TabCaptureAccessHandler::TabCaptureAccessHandler() = default;
 TabCaptureAccessHandler::~TabCaptureAccessHandler() = default;
 
 bool TabCaptureAccessHandler::SupportsStreamType(
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     const blink::mojom::MediaStreamType type,
     const extensions::Extension* extension) {
   return type == blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE ||

chrome/browser/media/webrtc/tab_capture_access_handler.h

@@ -20,7 +20,7 @@ class TabCaptureAccessHandler : public CaptureAccessHandlerBase {
   ~TabCaptureAccessHandler() override;
 
   // MediaAccessHandler implementation.
-  bool SupportsStreamType(content::WebContents* web_contents,
+  bool SupportsStreamType(content::RenderFrameHost* render_frame_host,
                           const blink::mojom::MediaStreamType type,
                           const extensions::Extension* extension) override;
   bool CheckMediaAccessPermission(

components/guest_view/browser/DEPS

@@ -8,6 +8,7 @@ include_rules = [
   "+third_party/blink/public/common/page/page_zoom.h",
   "+third_party/blink/public/common/input/web_gesture_event.h",
   "+third_party/blink/public/common/input/web_input_event.h",
+  "+third_party/blink/public/mojom/mediastream/media_stream.mojom.h",
 ]
 
 specific_include_rules = {

components/guest_view/browser/guest_view_base.cc

@@ -30,6 +30,7 @@
 #include "content/public/common/content_features.h"
 #include "third_party/blink/public/common/input/web_gesture_event.h"
 #include "third_party/blink/public/common/page/page_zoom.h"
+#include "third_party/blink/public/mojom/mediastream/media_stream.mojom.h"
 
 using content::WebContents;
 
@@ -720,6 +721,21 @@ void GuestViewBase::GuestOpenURL(
 
 void GuestViewBase::GuestClose() {}
 
+void GuestViewBase::GuestRequestMediaAccessPermission(
+    const content::MediaStreamRequest& request,
+    content::MediaResponseCallback callback) {
+  std::move(callback).Run(blink::mojom::StreamDevicesSet(),
+                          blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED,
+                          std::unique_ptr<content::MediaStreamUI>());
+}
+
+bool GuestViewBase::GuestCheckMediaAccessPermission(
+    content::RenderFrameHost* render_frame_host,
+    const url::Origin& security_origin,
+    blink::mojom::MediaStreamType type) {
+  return false;
+}
+
 void GuestViewBase::LoadProgressChanged(double progress) {
   if (base::FeatureList::IsEnabled(features::kGuestViewMPArch)) {
     // The load state of the embedder does not affect the load state of the

components/guest_view/browser/guest_view_base.h

@@ -468,6 +468,13 @@ class GuestViewBase : public content::BrowserPluginGuestDelegate,
                     base::OnceCallback<void(content::NavigationHandle&)>
                         navigation_handle_callback) override;
   void GuestClose() override;
+  void GuestRequestMediaAccessPermission(
+      const content::MediaStreamRequest& request,
+      content::MediaResponseCallback callback) override;
+  bool GuestCheckMediaAccessPermission(
+      content::RenderFrameHost* render_frame_host,
+      const url::Origin& security_origin,
+      blink::mojom::MediaStreamType type) override;
 
   // WebContentsDelegate implementation.
   void ActivateContents(content::WebContents* contents) final;

content/browser/renderer_host/media/media_stream_ui_proxy.cc

@@ -159,8 +159,11 @@ void MediaStreamUIProxy::Core::RequestAccess(
     return;
   }
 
+  RenderFrameHostImpl* host = RenderFrameHostImpl::FromID(
+      request->render_process_id, request->render_frame_id);
+
   render_delegate->RequestMediaAccessPermission(
-      *request,
+      host, *request,
       base::BindOnce(&Core::ProcessAccessRequestResponse, weak_this_,
                      request->render_process_id, request->render_frame_id));
 }

content/browser/renderer_host/media/media_stream_ui_proxy_unittest.cc

@@ -38,7 +38,8 @@ namespace content {
 namespace {
 class MockRenderFrameHostDelegate : public RenderFrameHostDelegate {
  public:
-  void RequestMediaAccessPermission(const MediaStreamRequest& request,
+  void RequestMediaAccessPermission(RenderFrameHostImpl* render_frame_host,
+                                    const MediaStreamRequest& request,
                                     MediaResponseCallback callback) override {
     return RequestMediaAccessPermission(request, &callback);
   }
@@ -632,7 +633,8 @@ class MediaStreamUIProxyPermissionsPolicyTest
  private:
   class TestRFHDelegate : public RenderFrameHostDelegate {
    public:
-    void RequestMediaAccessPermission(const MediaStreamRequest& request,
+    void RequestMediaAccessPermission(RenderFrameHostImpl* render_frame_host,
+                                      const MediaStreamRequest& request,
                                       MediaResponseCallback callback) override {
       blink::mojom::StreamDevicesSet stream_devices_set;
       stream_devices_set.stream_devices.emplace_back(

content/browser/renderer_host/render_frame_host_delegate.cc

@@ -49,6 +49,7 @@ bool RenderFrameHostDelegate::DidAddMessageToConsole(
 }
 
 void RenderFrameHostDelegate::RequestMediaAccessPermission(
+    RenderFrameHostImpl* render_frame_host,
     const MediaStreamRequest& request,
     MediaResponseCallback callback) {
   LOG(ERROR) << "RenderFrameHostDelegate::RequestMediaAccessPermission: "

content/browser/renderer_host/render_frame_host_delegate.h

@@ -289,8 +289,10 @@ class CONTENT_EXPORT RenderFrameHostDelegate {
   // The render frame has requested access to media devices listed in
   // |request|, and the client should grant or deny that permission by
   // calling |callback|.
-  virtual void RequestMediaAccessPermission(const MediaStreamRequest& request,
-                                            MediaResponseCallback callback);
+  virtual void RequestMediaAccessPermission(
+      RenderFrameHostImpl* render_frame_host,
+      const MediaStreamRequest& request,
+      MediaResponseCallback callback);
 
   // Called when a renderer requests to select an audio output device.
   // |request| contains parameters for audio output device selection.

content/browser/web_contents/web_contents_impl.cc

@@ -5385,6 +5385,7 @@ void WebContentsImpl::CreateMediaPlayerHostForRenderFrameHost(
 }
 
 void WebContentsImpl::RequestMediaAccessPermission(
+    RenderFrameHostImpl* render_frame_host,
     const MediaStreamRequest& request,
     MediaResponseCallback callback) {
   OPTIONAL_TRACE_EVENT2("content",
@@ -5392,14 +5393,22 @@ void WebContentsImpl::RequestMediaAccessPermission(
                         "render_process_id", request.render_process_id,
                         "render_frame_id", request.render_frame_id);
 
-  if (delegate_) {
+  if (GuestPageHolderImpl* guest =
+          render_frame_host
+              ? GuestPageHolderImpl::FromRenderFrameHost(*render_frame_host)
+              : nullptr) {
+    if (auto* delegate = guest->delegate()) {
+      delegate->GuestRequestMediaAccessPermission(request, std::move(callback));
+      return;
+    }
+  } else if (delegate_) {
     delegate_->RequestMediaAccessPermission(this, request, std::move(callback));
-  } else {
-    std::move(callback).Run(
-        blink::mojom::StreamDevicesSet(),
-        blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
-        std::unique_ptr<MediaStreamUI>());
+    return;
   }
+  std::move(callback).Run(
+      blink::mojom::StreamDevicesSet(),
+      blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
+      std::unique_ptr<MediaStreamUI>());
 }
 
 void WebContentsImpl::ProcessSelectAudioOutput(
@@ -5426,6 +5435,15 @@ bool WebContentsImpl::CheckMediaAccessPermission(
 
   DCHECK(type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE ||
          type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE);
+
+  if (auto* guest =
+          GuestPageHolderImpl::FromRenderFrameHost(*render_frame_host)) {
+    if (auto* delegate = guest->delegate()) {
+      return delegate->GuestCheckMediaAccessPermission(render_frame_host,
+                                                       security_origin, type);
+    }
+    return false;
+  }
   return delegate_ && delegate_->CheckMediaAccessPermission(
                           render_frame_host, security_origin, type);
 }

content/browser/web_contents/web_contents_impl.h

@@ -959,7 +959,8 @@ class CONTENT_EXPORT WebContentsImpl
       RenderFrameHostImpl* frame_host,
       mojo::PendingAssociatedReceiver<media::mojom::MediaPlayerHost> receiver)
       override;
-  void RequestMediaAccessPermission(const MediaStreamRequest& request,
+  void RequestMediaAccessPermission(RenderFrameHostImpl* render_frame_host,
+                                    const MediaStreamRequest& request,
                                     MediaResponseCallback callback) override;
 
   void ProcessSelectAudioOutput(const SelectAudioOutputRequest& request,

content/browser/web_contents/web_contents_impl_unittest.cc

@@ -3383,7 +3383,7 @@ TEST_F(WebContentsImplTest, RequestMediaAccessPermissionNoDelegate) {
       /*captured_surface_control_active=*/false);
   bool callback_run = false;
   contents()->RequestMediaAccessPermission(
-      dummy_request,
+      contents()->GetPrimaryMainFrame(), dummy_request,
       base::BindLambdaForTesting(
           [&callback_run](
               const blink::mojom::StreamDevicesSet& stream_devices_set,

content/public/browser/guest_page_holder.h

@@ -12,6 +12,7 @@
 #include "base/process/kill.h"
 #include "base/supports_user_data.h"
 #include "content/common/content_export.h"
+#include "content/public/browser/media_stream_request.h"
 #include "ui/base/window_open_disposition.h"
 #include "url/gurl.h"
 
@@ -101,6 +102,19 @@ class GuestPageHolder : public base::SupportsUserData {
     // Close the current window.
     virtual void GuestClose() = 0;
 
+    // Asks permission to use the camera and/or microphone.
+    // See `WebContentsDelegate::RequestMediaAccessPermission`
+    virtual void GuestRequestMediaAccessPermission(
+        const MediaStreamRequest& request,
+        MediaResponseCallback callback) = 0;
+
+    // Checks if we have permission to access the microphone or camera.
+    // See `WebContentsDelegate::CheckMediaAccessPermission`
+    virtual bool GuestCheckMediaAccessPermission(
+        RenderFrameHost* render_frame_host,
+        const url::Origin& security_origin,
+        blink::mojom::MediaStreamType type) = 0;
+
     // TODO(40202416): Guest implementations need to be informed of several
     // other events that they currently get through primary main frame specific
     // WebContentsObserver methods (e.g.

extensions/browser/guest_view/web_view/web_view_guest.cc

@@ -878,6 +878,31 @@ void WebViewGuest::GuestClose() {
       std::make_unique<GuestViewEvent>(webview::kEventClose, std::move(args)));
 }
 
+void WebViewGuest::GuestRequestMediaAccessPermission(
+    const content::MediaStreamRequest& request,
+    content::MediaResponseCallback callback) {
+  if (IsOwnedByControlledFrameEmbedder()) {
+    web_view_permission_helper_->RequestMediaAccessPermissionForControlledFrame(
+        web_contents(), request, std::move(callback));
+    return;
+  }
+  web_view_permission_helper_->RequestMediaAccessPermission(
+      request, std::move(callback));
+}
+
+bool WebViewGuest::GuestCheckMediaAccessPermission(
+    content::RenderFrameHost* render_frame_host,
+    const url::Origin& security_origin,
+    blink::mojom::MediaStreamType type) {
+  if (IsOwnedByControlledFrameEmbedder()) {
+    return web_view_permission_helper_
+        ->CheckMediaAccessPermissionForControlledFrame(render_frame_host,
+                                                       security_origin, type);
+  }
+  return web_view_permission_helper_->CheckMediaAccessPermission(
+      render_frame_host, security_origin, type);
+}
+
 void WebViewGuest::CreateNewGuestWebViewWindow(
     const content::OpenURLParams& params) {
   GuestViewManager* guest_manager =
@@ -1493,13 +1518,7 @@ void WebViewGuest::RequestMediaAccessPermission(
     content::MediaResponseCallback callback) {
   CHECK(!base::FeatureList::IsEnabled(features::kGuestViewMPArch));
 
-  if (IsOwnedByControlledFrameEmbedder()) {
-    web_view_permission_helper_->RequestMediaAccessPermissionForControlledFrame(
-        source, request, std::move(callback));
-    return;
-  }
-  web_view_permission_helper_->RequestMediaAccessPermission(
-      source, request, std::move(callback));
+  GuestRequestMediaAccessPermission(request, std::move(callback));
 }
 
 bool WebViewGuest::CheckMediaAccessPermission(
@@ -1508,13 +1527,8 @@ bool WebViewGuest::CheckMediaAccessPermission(
     blink::mojom::MediaStreamType type) {
   CHECK(!base::FeatureList::IsEnabled(features::kGuestViewMPArch));
 
-  if (IsOwnedByControlledFrameEmbedder()) {
-    return web_view_permission_helper_
-        ->CheckMediaAccessPermissionForControlledFrame(render_frame_host,
-                                                       security_origin, type);
-  }
-  return web_view_permission_helper_->CheckMediaAccessPermission(
-      render_frame_host, security_origin, type);
+  return GuestCheckMediaAccessPermission(render_frame_host, security_origin,
+                                         type);
 }
 
 void WebViewGuest::CanDownload(const GURL& url,

extensions/browser/guest_view/web_view/web_view_guest.h

@@ -236,6 +236,13 @@ class WebViewGuest : public guest_view::GuestView<WebViewGuest> {
                     base::OnceCallback<void(content::NavigationHandle&)>
                         navigation_handle_callback) final;
   void GuestClose() final;
+  void GuestRequestMediaAccessPermission(
+      const content::MediaStreamRequest& request,
+      content::MediaResponseCallback callback) final;
+  bool GuestCheckMediaAccessPermission(
+      content::RenderFrameHost* render_frame_host,
+      const url::Origin& security_origin,
+      blink::mojom::MediaStreamType type) final;
 
   // GuestpageHolder::Delegate implementation.
   bool GuestHandleContextMenu(content::RenderFrameHost& render_frame_host,

extensions/browser/guest_view/web_view/web_view_permission_helper.cc

@@ -189,7 +189,6 @@ WebViewPermissionHelper* WebViewPermissionHelper::FromRenderFrameHostId(
 }
 
 void WebViewPermissionHelper::RequestMediaAccessPermission(
-    content::WebContents* source,
     const content::MediaStreamRequest& request,
     content::MediaResponseCallback callback) {
   base::Value::Dict request_info;

extensions/browser/guest_view/web_view/web_view_permission_helper.h

@@ -68,8 +68,7 @@ class WebViewPermissionHelper {
   static WebViewPermissionHelper* FromRenderFrameHostId(
       const content::GlobalRenderFrameHostId& render_frame_host_id);
 
-  void RequestMediaAccessPermission(content::WebContents* source,
-                                    const content::MediaStreamRequest& request,
+  void RequestMediaAccessPermission(const content::MediaStreamRequest& request,
                                     content::MediaResponseCallback callback);
 
   void RequestMediaAccessPermissionForControlledFrame(