[PermissionOptions] Generalize PermissionRequestDescription

Refactor PermissionRequestDescription to hold PermissionDescriptorPtr.
Permissions with options can no longer be represented by a simple
PermissionType enum value, hence future infrastructure refactorings to
enable them will pass around PermissionDescriptorPtrs instead of mapping
PermissionDescriptorPts to PermissionTypes.

To reduce the complexity of this CL, it limits the scope of the
refactoring to PermissionRequestDescription, its creations and usages
and uses utility mapping functions to map
PermissionRequestDescriptionPtr usages of this object to the
PermissionTypes. I.e. it does not yet modify the infrastructure itself
yet to rely on PermissionRequestDescriptorPtr.

Since all ContentSetting permission types currently map to exactly one
PermissionDescriptorPtr and vice versa, the mapping for all content
setting permission types is unique and can rely on these mapping utility
functions. Permissions that want to make use of permission options in
the future, will create the correct PermissionRequestDescriptorPtr
instead of relying on the current mapping functions.

refactoring. We need to add mapping functions to reduce the scope of
this CL and avoid having to make all changes at once. These mapping
functions will not be necessary in fuchsia, as the infrastructure will
move to fully relying on a different type.

Bug: 405943540, 393053278
Fuchsia-Binary-Size: Increase is temporary. This CL is part of a large
Change-Id: I9d6e3e71385749787a973a61e41ce130665c860d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6387077
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Nate Fischer <ntfschr@chromium.org>
Commit-Queue: Florian Jacky <fjacky@chromium.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1443356}

android_webview/browser/aw_permission_manager.cc

@@ -263,7 +263,8 @@ void AwPermissionManager::RequestPermissions(
     base::OnceCallback<void(const std::vector<PermissionStatus>&)> callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  auto const& permissions = request_description.permissions;
+  auto const& permissions = blink::PermissionDescriptorToPermissionTypes(
+      request_description.permissions);
   if (permissions.empty()) {
     std::move(callback).Run(std::vector<PermissionStatus>());
     return;

android_webview/browser/aw_permission_manager_unittest.cc

@@ -14,6 +14,7 @@
 #include "base/functional/callback_helpers.h"
 #include "base/memory/raw_ptr.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/permissions/permission_utils.h"
 #include "url/gurl.h"
@@ -233,8 +234,10 @@ class AwPermissionManagerTest : public testing::Test {
     CHECK(manager);
     manager->RequestPermissions(
         rfh,
-        content::PermissionRequestDescription(permissions, user_gesture,
-                                              requesting_origin),
+        content::PermissionRequestDescription(
+            content::PermissionDescriptorUtil::
+                CreatePermissionDescriptorForPermissionTypes(permissions),
+            user_gesture, requesting_origin),
         std::move(callback));
   }
 

chrome/browser/chrome_back_forward_cache_browsertest.cc

@@ -34,6 +34,7 @@
 #include "components/page_load_metrics/browser/observers/core/uma_page_load_metrics_observer.h"
 #include "components/permissions/permission_manager.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_features.h"
@@ -244,7 +245,10 @@ IN_PROC_BROWSER_TEST_F(ChromeBackForwardCacheBrowserTest,
       ->RequestPermissionFromCurrentDocument(
           rfh_a.get(),
           content::PermissionRequestDescription(
-              blink::PermissionType::GEOLOCATION, /* user_gesture = */ true),
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::GEOLOCATION),
+              /* user_gesture = */ true),
           callback.Get());
 
   // Ensure |rfh_a| is evicted from the cache because it is not allowed to

chrome/browser/geolocation/geolocation_permission_context_delegate_unittest.cc

@@ -13,6 +13,7 @@
 #include "components/permissions/permission_manager.h"
 #include "components/permissions/permission_request_manager.h"
 #include "components/permissions/test/mock_permission_prompt_factory.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/permission_result.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -77,7 +78,10 @@ class GeolocationPermissionContextDelegateTests
     PermissionManagerFactory::GetForProfile(profile())
         ->RequestPermissionsFromCurrentDocument(
             render_frame_host,
-            content::PermissionRequestDescription(permission, user_gesture),
+            content::PermissionRequestDescription(
+                content::PermissionDescriptorUtil::
+                    CreatePermissionDescriptorForPermissionType(permission),
+                user_gesture),
             base::BindOnce(
                 [](base::OnceCallback<void(blink::mojom::PermissionStatus)>
                        callback,

chrome/browser/guest_view/web_view/chrome_web_view_permission_helper_delegate.cc

@@ -20,6 +20,7 @@
 #include "components/permissions/permission_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
@@ -356,7 +357,10 @@ void ChromeWebViewPermissionHelperDelegate::OnGeolocationPermissionResponse(
       ->RequestPermissionFromCurrentDocument(
           web_view_guest()->embedder_rfh(),
           content::PermissionRequestDescription(
-              blink::PermissionType::GEOLOCATION, user_gesture),
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::GEOLOCATION),
+              user_gesture),
           std::move(callback));
 }
 

chrome/browser/permissions/permission_request_manager_browsertest.cc

@@ -41,6 +41,7 @@
 #include "components/permissions/test/mock_permission_ui_selector.h"
 #include "components/permissions/test/permission_request_observer.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
@@ -1375,8 +1376,11 @@ IN_PROC_BROWSER_TEST_F(PermissionRequestManagerWithFencedFrameTest,
       browser()->profile()->GetPermissionController();
   permission_controller->RequestPermissionFromCurrentDocument(
       fenced_frame_host,
-      content::PermissionRequestDescription(blink::PermissionType::SENSORS,
-                                            /* user_gesture = */ true),
+      content::PermissionRequestDescription(
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::SENSORS),
+          /* user_gesture = */ true),
       callback.Get());
   ASSERT_TRUE(console_observer.Wait());
   ASSERT_EQ(1u, console_observer.messages().size());

chrome/browser/printing/web_api/web_printing_service_chromeos.cc

@@ -20,6 +20,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "components/permissions/permission_request_data.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "printing/backend/cups_ipp_constants.h"
 #include "printing/backend/print_backend.h"
@@ -214,7 +215,9 @@ void WebPrintingServiceChromeOS::GetPrinters(GetPrintersCallback callback) {
       ->RequestPermissionFromCurrentDocument(
           &render_frame_host(),
           content::PermissionRequestDescription(
-              blink::PermissionType::WEB_PRINTING),
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::WEB_PRINTING)),
           base::BindOnce(
               &WebPrintingServiceChromeOS::OnPermissionDecidedForGetPrinters,
               weak_factory_.GetWeakPtr(), std::move(callback)));

chrome/browser/push_messaging/push_messaging_service_impl.cc

@@ -55,6 +55,7 @@
 #include "content/public/browser/child_process_host.h"
 #include "content/public/browser/devtools_background_services_context.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_result.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -817,7 +818,10 @@ void PushMessagingServiceImpl::SubscribeFromDocument(
   profile_->GetPermissionController()->RequestPermissionFromCurrentDocument(
       render_frame_host,
       content::PermissionRequestDescription(
-          blink::PermissionType::NOTIFICATIONS, user_gesture),
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::NOTIFICATIONS),
+          user_gesture),
       base::BindOnce(&PushMessagingServiceImpl::DoSubscribe,
                      weak_factory_.GetWeakPtr(), std::move(app_identifier),
                      std::move(options), std::move(callback), render_process_id,

chrome/browser/ui/exclusive_access/exclusive_access_permission_manager.cc

@@ -10,6 +10,7 @@
 #include "content/public/browser/global_routing_id.h"
 #include "content/public/browser/media_session.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/blink/public/common/permissions/permission_utils.h"
@@ -111,7 +112,9 @@ void ExclusiveAccessPermissionManager::RequestPermissions(
   requests.waiting_responses += requests.pending.size();
   for (PermissionRequest& request : requests.pending) {
     content::PermissionRequestDescription description(
-        request.type, web_contents->HasRecentInteraction());
+        content::PermissionDescriptorUtil::
+            CreatePermissionDescriptorForPermissionType(request.type),
+        web_contents->HasRecentInteraction());
     GetPermissionController(web_contents.get())
         ->RequestPermissionsFromCurrentDocument(
             rfh, std::move(description),

chrome/browser/ui/exclusive_access/exclusive_access_permission_manager_unittest.cc

@@ -9,7 +9,6 @@
 #include "base/time/time.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "content/public/browser/permission_controller.h"
-#include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/permission_result.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -64,7 +63,8 @@ class ExclusiveAccessPermissionManagerTest : public BrowserWithTestWindowTest {
                 base::OnceCallback<void(
                     const std::vector<blink::mojom::PermissionStatus>&)>
                     callback) {
-              switch (description.permissions.at(0)) {
+              switch (blink::PermissionDescriptorToPermissionType(
+                  description.permissions.at(0))) {
                 case blink::PermissionType::POINTER_LOCK:
                   if (pointer_lock_response) {
                     std::move(callback).Run({*pointer_lock_response});

chrome/browser/web_applications/web_install_service_impl.cc

@@ -18,6 +18,7 @@
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/blink/public/common/permissions/permission_utils.h"
@@ -146,7 +147,6 @@ void WebInstallServiceImpl::RequestWebInstallPermission(
   }
 
   // Check if the permission status is already set.
-  std::vector<blink::PermissionType> permission_requests;
   content::PermissionResult permission_status =
       permission_controller->GetPermissionResultForCurrentDocument(
           blink::PermissionType::WEB_APP_INSTALLATION, &render_frame_host());
@@ -162,7 +162,6 @@ void WebInstallServiceImpl::RequestWebInstallPermission(
     case PermissionStatus::ASK:
       break;
   }
-  permission_requests.push_back(blink::PermissionType::WEB_APP_INSTALLATION);
 
   GURL requesting_origin =
       render_frame_host().GetLastCommittedOrigin().GetURL();
@@ -170,7 +169,10 @@ void WebInstallServiceImpl::RequestWebInstallPermission(
   permission_controller->RequestPermissionsFromCurrentDocument(
       &render_frame_host(),
       content::PermissionRequestDescription(
-          permission_requests, /*user_gesture=*/true, requesting_origin),
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::WEB_APP_INSTALLATION),
+          /*user_gesture=*/true, requesting_origin),
       std::move(callback));
 }
 

components/permissions/BUILD.gn

@@ -109,7 +109,6 @@ source_set("permissions") {
     "permission_usage_session.cc",
     "permission_usage_session.h",
     "permission_util.cc",
-    "permission_util.h",
     "permissions_client.cc",
     "permissions_client.h",
     "pref_names.cc",

components/permissions/contexts/camera_pan_tilt_zoom_permission_context.cc

@@ -12,6 +12,7 @@
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "services/network/public/mojom/permissions_policy/permissions_policy_feature.mojom-shared.h"
@@ -82,7 +83,10 @@ void CameraPanTiltZoomPermissionContext::RequestPermission(
       ->RequestPermissionFromCurrentDocument(
           render_frame_host,
           content::PermissionRequestDescription(
-              blink::PermissionType::VIDEO_CAPTURE, request_data.user_gesture),
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::VIDEO_CAPTURE),
+              request_data.user_gesture),
           base::BindOnce(&CallbackWrapper, std::move(callback)));
 }
 

components/permissions/permission_manager.cc

@@ -67,14 +67,14 @@ class PermissionManager::PendingRequest {
  public:
   PendingRequest(
       content::RenderFrameHost* render_frame_host,
-      const std::vector<ContentSettingsType>& permissions,
+      std::vector<blink::mojom::PermissionDescriptorPtr> permissions,
       base::OnceCallback<void(const std::vector<ContentSetting>&)> callback)
       : render_process_id_(render_frame_host->GetProcess()->GetDeprecatedID()),
         render_frame_id_(render_frame_host->GetRoutingID()),
         callback_(std::move(callback)),
-        permissions_(permissions),
+        remaining_results_(permissions.size()),
         results_(permissions.size(), CONTENT_SETTING_BLOCK),
-        remaining_results_(permissions.size()) {}
+        permissions_(std::move(permissions)) {}
 
   void SetContentSetting(int permission_id, ContentSetting content_setting) {
     DCHECK(!IsComplete());
@@ -92,7 +92,10 @@ class PermissionManager::PendingRequest {
     return std::move(callback_);
   }
 
-  std::vector<ContentSettingsType> permissions() const { return permissions_; }
+  const std::vector<blink::mojom::PermissionDescriptorPtr>& permissions()
+      const {
+    return permissions_;
+  }
 
   std::vector<ContentSetting> results() const { return results_; }
 
@@ -100,9 +103,9 @@ class PermissionManager::PendingRequest {
   int render_process_id_;
   int render_frame_id_;
   base::OnceCallback<void(const std::vector<ContentSetting>&)> callback_;
-  std::vector<ContentSettingsType> permissions_;
-  std::vector<ContentSetting> results_;
   size_t remaining_results_;
+  std::vector<ContentSetting> results_;
+  std::vector<blink::mojom::PermissionDescriptorPtr> permissions_;
 };
 
 // Object to track the callback passed to
@@ -225,31 +228,35 @@ void PermissionManager::RequestPermissionsInternal(
     const content::PermissionRequestDescription& request_description,
     base::OnceCallback<void(const std::vector<PermissionStatus>&)>
         permission_status_callback) {
-  std::vector<ContentSettingsType> permissions;
-  std::ranges::transform(request_description.permissions,
-                         back_inserter(permissions),
-                         PermissionUtil::PermissionTypeToContentSettingsType);
+  std::vector<blink::mojom::PermissionDescriptorPtr> permissions;
+  permissions.reserve(request_description.permissions.size());
+  for (const auto& permission : request_description.permissions) {
+    permissions.push_back(permission.Clone());
+  }
 
   base::OnceCallback<void(const std::vector<ContentSetting>&)> callback =
       base::BindOnce(&PermissionStatusVectorCallbackWrapper,
                      std::move(permission_status_callback));
 
-  if (permissions.empty()) {
+  if (request_description.permissions.empty()) {
     std::move(callback).Run(std::vector<ContentSetting>());
     return;
   }
 
   auto request_local_id = request_local_id_generator_.GenerateNextId();
   pending_requests_.AddWithID(
-      std::make_unique<PendingRequest>(render_frame_host, permissions,
-                                       std::move(callback)),
+      std::make_unique<PendingRequest>(
+          render_frame_host, std::move(permissions), std::move(callback)),
       request_local_id);
 
   const PermissionRequestID request_id(render_frame_host, request_local_id);
   const GURL embedding_origin = GetEmbeddingOrigin(
       render_frame_host, request_description.requesting_origin);
-  for (size_t i = 0; i < permissions.size(); ++i) {
-    const ContentSettingsType permission = permissions[i];
+  for (size_t i = 0; i < request_description.permissions.size(); ++i) {
+    const ContentSettingsType permission =
+        PermissionUtil::PermissionTypeToContentSettingsType(
+            blink::PermissionDescriptorToPermissionType(
+                request_description.permissions[i]));
     const GURL canonical_requesting_origin = PermissionUtil::GetCanonicalOrigin(
         permission, request_description.requesting_origin, embedding_origin);
 

components/permissions/permission_manager_unittest.cc

@@ -20,6 +20,7 @@
 #include "components/permissions/test/permission_test_util.h"
 #include "components/permissions/test/test_permissions_client.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/permission_result.h"
 #include "content/public/common/content_client.h"
@@ -145,7 +146,8 @@ class PermissionManagerTest : public content::RenderViewHostTestHarness {
     GetPermissionManager()->RequestPermissionsFromCurrentDocument(
         rfh,
         std::move(content::PermissionRequestDescription(
-            std::vector(1, type),
+            content::PermissionDescriptorUtil::
+                CreatePermissionDescriptorForPermissionType(type),
             /*user_gesture=*/true, rfh->GetLastCommittedOrigin().GetURL())),
         base::BindOnce(
             [](base::OnceCallback<void(PermissionStatus)> callback,
@@ -164,8 +166,9 @@ class PermissionManagerTest : public content::RenderViewHostTestHarness {
     GetPermissionManager()->RequestPermissionsFromCurrentDocument(
         rfh,
         content::PermissionRequestDescription(
-            type, /*user_gesture=*/true,
-            rfh->GetLastCommittedOrigin().GetURL()),
+            content::PermissionDescriptorUtil::
+                CreatePermissionDescriptorForPermissionType(type),
+            /*user_gesture=*/true, rfh->GetLastCommittedOrigin().GetURL()),
         base::BindOnce(
             [](base::OnceCallback<void(PermissionStatus)> callback,
                const std::vector<PermissionStatus>& state) {

components/webrtc/media_stream_devices_controller.cc

@@ -14,6 +14,7 @@
 #include "components/permissions/permission_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_result.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -90,7 +91,7 @@ void MediaStreamDevicesController::RequestPermissions(
       new MediaStreamDevicesController(web_contents, enumerator, request,
                                        std::move(callback)));
 
-  std::vector<blink::PermissionType> permission_types;
+  std::vector<blink::mojom::PermissionDescriptorPtr> permission_types;
 
   content::PermissionController* permission_controller =
       web_contents->GetBrowserContext()->GetPermissionController();
@@ -114,7 +115,9 @@ void MediaStreamDevicesController::RequestPermissions(
       return;
     }
 
-    permission_types.push_back(blink::PermissionType::AUDIO_CAPTURE);
+    permission_types.push_back(content::PermissionDescriptorUtil::
+                                   CreatePermissionDescriptorForPermissionType(
+                                       blink::PermissionType::AUDIO_CAPTURE));
     requested_audio_capture_device_ids = request.requested_audio_device_ids;
   }
   if (controller->ShouldRequestVideo()) {
@@ -133,7 +136,9 @@ void MediaStreamDevicesController::RequestPermissions(
       return;
     }
 
-    permission_types.push_back(blink::PermissionType::VIDEO_CAPTURE);
+    permission_types.push_back(content::PermissionDescriptorUtil::
+                                   CreatePermissionDescriptorForPermissionType(
+                                       blink::PermissionType::VIDEO_CAPTURE));
     requested_video_capture_device_ids = request.requested_video_device_ids;
 
     bool has_pan_tilt_zoom_camera = controller->HasAvailableDevices(
@@ -154,12 +159,15 @@ void MediaStreamDevicesController::RequestPermissions(
         return;
       }
 
-      permission_types.push_back(blink::PermissionType::CAMERA_PAN_TILT_ZOOM);
+      permission_types.push_back(
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::CAMERA_PAN_TILT_ZOOM));
     }
   }
 
   content::PermissionRequestDescription permission_request_description{
-      permission_types, request.user_gesture};
+      std::move(permission_types), request.user_gesture};
   permission_request_description.requested_audio_capture_device_ids =
       requested_audio_capture_device_ids;
   permission_request_description.requested_video_capture_device_ids =

components/webrtc/media_stream_devices_controller_unittest.cc

@@ -8,6 +8,7 @@
 #include "base/test/test_future.h"
 #include "components/webrtc/media_stream_devices_util.h"
 #include "content/public/browser/global_routing_id.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/browser_test_utils.h"
@@ -160,13 +161,20 @@ class MediaStreamDevicesControllerTest : public testing::Test {
           };
         });
 
-    std::vector<blink::PermissionType> expected_permissions;
+    std::vector<blink::mojom::PermissionDescriptorPtr> expected_permissions;
     if (request_audio) {
-      expected_permissions.push_back(blink::PermissionType::AUDIO_CAPTURE);
+      expected_permissions.push_back(
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::AUDIO_CAPTURE));
     }
     if (request_video) {
-      expected_permissions.push_back(blink::PermissionType::VIDEO_CAPTURE);
+      expected_permissions.push_back(
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::VIDEO_CAPTURE));
     }
+
     content::PermissionRequestDescription expected_description{
         std::move(expected_permissions), false};
     expected_description.requested_audio_capture_device_ids =

content/browser/BUILD.gn

@@ -1380,6 +1380,7 @@ source_set("browser") {
     "media/capture/desktop_capture_device_uma_types.h",
     "media/capture/desktop_streams_registry_impl.cc",
     "media/capture/desktop_streams_registry_impl.h",
+    "permissions/permission_descriptor_util.cc",
 
     # TODO(crbug.com/202736352): This is built even if enable_screen_capture is
     # false. Consider better separation of the screen capture and the other

content/browser/font_access/font_access_manager.cc

@@ -23,6 +23,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/global_routing_id.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
@@ -125,8 +126,11 @@ void FontAccessManager::EnumerateLocalFonts(
 
   permission_controller->RequestPermissionFromCurrentDocument(
       rfh,
-      PermissionRequestDescription(blink::PermissionType::LOCAL_FONTS,
-                                   /*user_gesture=*/true),
+      PermissionRequestDescription(
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::LOCAL_FONTS),
+          /*user_gesture=*/true),
       base::BindOnce(&FontAccessManager::DidRequestPermission,
                      weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }

content/browser/font_access/font_access_test_utils.cc

@@ -17,7 +17,8 @@ void TestFontAccessPermissionManager::RequestPermissionsFromCurrentDocument(
     const PermissionRequestDescription& request_description,
     base::OnceCallback<void(const std::vector<blink::mojom::PermissionStatus>&)>
         callback) {
-  EXPECT_EQ(request_description.permissions[0],
+  EXPECT_EQ(blink::PermissionDescriptorToPermissionType(
+                request_description.permissions[0]),
             blink::PermissionType::LOCAL_FONTS);
   EXPECT_TRUE(request_description.user_gesture);
   request_callback_.Run(std::move(callback));

content/browser/generic_sensor/frame_sensor_provider_proxy.cc

@@ -10,10 +10,10 @@
 #include "content/browser/renderer_host/render_frame_host_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "services/device/public/mojom/sensor_provider.mojom-shared.h"
-#include "third_party/blink/public/common/permissions/permission_utils.h"
 #include "third_party/blink/public/mojom/permissions/permission_status.mojom.h"
 
 using device::mojom::SensorType;
@@ -89,7 +89,10 @@ void FrameSensorProviderProxy::GetSensor(device::mojom::SensorType type,
       ->GetPermissionController()
       ->RequestPermissionFromCurrentDocument(
           &render_frame_host(),
-          PermissionRequestDescription(blink::PermissionType::SENSORS),
+          PermissionRequestDescription(
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::SENSORS)),
           base::BindOnce(
               &FrameSensorProviderProxy::OnPermissionRequestCompleted,
               weak_factory_.GetWeakPtr(), type, std::move(callback)));

content/browser/generic_sensor/web_contents_sensor_provider_proxy_unittest.cc

@@ -34,7 +34,8 @@ class TestPermissionManager : public MockPermissionManager {
           void(const std::vector<blink::mojom::PermissionStatus>&)> callback)
       override {
     ASSERT_EQ(request_description.permissions.size(), 1ul);
-    ASSERT_EQ(request_description.permissions[0],
+    ASSERT_EQ(blink::PermissionDescriptorToPermissionType(
+                  request_description.permissions[0]),
               blink::PermissionType::SENSORS);
     std::move(callback).Run({blink::mojom::PermissionStatus::GRANTED});
   }

content/browser/geolocation/geolocation_service_impl.cc

@@ -10,6 +10,7 @@
 #include "content/browser/permissions/permission_controller_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -45,8 +46,11 @@ void GeolocationServiceImplContext::RequestPermission(
       ->GetPermissionController()
       ->RequestPermissionFromCurrentDocument(
           render_frame_host,
-          PermissionRequestDescription(blink::PermissionType::GEOLOCATION,
-                                       user_gesture),
+          PermissionRequestDescription(
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::GEOLOCATION),
+              user_gesture),
           base::BindOnce(&GeolocationServiceImplContext::HandlePermissionStatus,
                          weak_factory_.GetWeakPtr(), std::move(callback)));
 }

content/browser/geolocation/geolocation_service_impl_unittest.cc

@@ -58,7 +58,8 @@ class TestPermissionManager : public MockPermissionManager {
           void(const std::vector<blink::mojom::PermissionStatus>&)> callback)
       override {
     ASSERT_EQ(request_description.permissions.size(), 1u);
-    EXPECT_EQ(request_description.permissions[0],
+    EXPECT_EQ(blink::PermissionDescriptorToPermissionType(
+                  request_description.permissions[0]),
               blink::PermissionType::GEOLOCATION);
     EXPECT_TRUE(request_description.user_gesture);
     request_callback_.Run(std::move(callback));

content/browser/media/captured_surface_control_permission_manager.cc

@@ -12,6 +12,7 @@
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_features.h"
 #include "media/base/media_switches.h"
@@ -93,7 +94,10 @@ void CheckPermissionOnUIThread(
   permission_controller->RequestPermissionFromCurrentDocument(
       capturer_rfhi,
       PermissionRequestDescription(
-          blink::PermissionType::CAPTURED_SURFACE_CONTROL, user_gesture),
+          content::PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionType(
+                  blink::PermissionType::CAPTURED_SURFACE_CONTROL),
+          user_gesture),
       WrapCallback(std::move(callback)));
 }
 

content/browser/media/key_system_support_impl.cc

@@ -8,6 +8,7 @@
 #include "content/browser/permissions/permission_util.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 
 namespace content {
@@ -118,7 +119,9 @@ void KeySystemSupportImpl::InitializePermissions() {
       ->RequestPermissionFromCurrentDocument(
           &render_frame_host(),
           PermissionRequestDescription(
-              blink::PermissionType::PROTECTED_MEDIA_IDENTIFIER,
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionType(
+                      blink::PermissionType::PROTECTED_MEDIA_IDENTIFIER),
               render_frame_host().HasTransientUserActivation()),
           base::BindOnce(&KeySystemSupportImpl::
                              OnProtectedMediaIdentifierPermissionInitialized,

content/browser/media/key_system_support_impl_unittest.cc

@@ -13,6 +13,7 @@
 #include "base/test/bind.h"
 #include "base/test/gmock_callback_support.h"
 #include "base/test/mock_callback.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/mock_permission_controller.h"
 #include "content/public/test/test_browser_context.h"
@@ -133,7 +134,9 @@ class KeySystemSupportImplTest : public RenderViewHostTestHarness {
             RequestPermissionFromCurrentDocument(
                 main_rfh(),
                 PermissionRequestDescription(
-                    blink::PermissionType::PROTECTED_MEDIA_IDENTIFIER,
+                    PermissionDescriptorUtil::
+                        CreatePermissionDescriptorForPermissionType(
+                            blink::PermissionType::PROTECTED_MEDIA_IDENTIFIER),
                     main_rfh()->HasTransientUserActivation()),
                 _))
         .WillByDefault(RunOnceCallback<2>(permission_status));

content/browser/permissions/permission_controller_impl.cc

@@ -14,7 +14,6 @@
 #include "content/public/browser/disallow_activation_reason.h"
 #include "content/public/browser/permission_controller.h"
 #include "content/public/browser/permission_controller_delegate.h"
-#include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/permission_result.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -135,7 +134,7 @@ PermissionResult VerifyContextOfCurrentDocument(
 }
 
 bool IsRequestAllowed(
-    const std::vector<blink::PermissionType>& permissions,
+    const std::vector<blink::mojom::PermissionDescriptorPtr>& permissions,
     RenderFrameHost* render_frame_host,
     base::OnceCallback<void(const std::vector<PermissionStatus>&)>& callback) {
   if (!render_frame_host) {
@@ -156,16 +155,18 @@ bool IsRequestAllowed(
 
   // Verify each permission independently to generate proper warning messages.
   bool is_permission_allowed = true;
-  for (PermissionType permission : permissions) {
+  for (const auto& permission : permissions) {
+    PermissionType permission_type =
+        blink::PermissionDescriptorToPermissionType(permission);
     PermissionResult result =
-        VerifyContextOfCurrentDocument(permission, render_frame_host);
+        VerifyContextOfCurrentDocument(permission_type, render_frame_host);
 
     if (result.status == PermissionStatus::DENIED) {
       switch (result.source) {
         case PermissionStatusSource::FENCED_FRAME:
           render_frame_host->GetOutermostMainFrame()->AddMessageToConsole(
               blink::mojom::ConsoleMessageLevel::kWarning,
-              blink::GetPermissionString(permission) +
+              blink::GetPermissionString(permission_type) +
                   " permission has been blocked because it was requested "
                   "inside a fenced frame. Fenced frames don't currently "
                   "support permission requests.");
@@ -174,7 +175,7 @@ bool IsRequestAllowed(
         case PermissionStatusSource::FEATURE_POLICY:
           render_frame_host->GetOutermostMainFrame()->AddMessageToConsole(
               blink::mojom::ConsoleMessageLevel::kWarning,
-              blink::GetPermissionString(permission) +
+              blink::GetPermissionString(permission_type) +
                   " permission has been blocked because of a permissions "
                   "policy applied to the current document. See "
                   "https://goo.gl/EuHzyv for more details.");
@@ -253,14 +254,16 @@ std::vector<std::optional<blink::mojom::PermissionStatus>> OverridePermissions(
     PermissionRequestDescription& description,
     RenderFrameHost* render_frame_host,
     const PermissionOverrides& permission_overrides) {
-  std::vector<blink::PermissionType> permissions_without_overrides;
+  std::vector<blink::mojom::PermissionDescriptorPtr>
+      permissions_without_overrides;
   std::vector<std::optional<blink::mojom::PermissionStatus>> results;
   const url::Origin& origin = render_frame_host->GetLastCommittedOrigin();
   for (const auto& permission : description.permissions) {
     std::optional<blink::mojom::PermissionStatus> override_status =
-        permission_overrides.Get(origin, permission);
+        permission_overrides.Get(
+            origin, blink::PermissionDescriptorToPermissionType(permission));
     if (!override_status) {
-      permissions_without_overrides.push_back(permission);
+      permissions_without_overrides.push_back(permission.Clone());
     }
     results.push_back(override_status);
   }
@@ -428,8 +431,11 @@ void PermissionControllerImpl::RequestPermissions(
     return;
   }
 
-  for (PermissionType permission : request_description.permissions) {
-    NotifySchedulerAboutPermissionRequest(render_frame_host, permission);
+  for (const blink::mojom::PermissionDescriptorPtr& permission :
+       request_description.permissions) {
+    NotifySchedulerAboutPermissionRequest(
+        render_frame_host,
+        blink::PermissionDescriptorToPermissionType(permission));
   }
 
   std::vector<std::optional<blink::mojom::PermissionStatus>> override_results =
@@ -475,8 +481,10 @@ void PermissionControllerImpl::RequestPermissionsFromCurrentDocument(
     return;
   }
 
-  for (PermissionType permission : request_description.permissions) {
-    NotifySchedulerAboutPermissionRequest(render_frame_host, permission);
+  for (const auto& permission : request_description.permissions) {
+    NotifySchedulerAboutPermissionRequest(
+        render_frame_host,
+        blink::PermissionDescriptorToPermissionType(permission));
   }
 
   request_description.requesting_origin =

content/browser/permissions/permission_controller_impl_unittest.cc

@@ -11,6 +11,7 @@
 #include "base/test/mock_callback.h"
 #include "content/public/browser/permission_controller.h"
 #include "content/public/browser/permission_controller_delegate.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/mock_permission_manager.h"
 #include "content/public/test/navigation_simulator.h"
@@ -280,19 +281,24 @@ TEST_F(PermissionControllerImplTest,
       if (test_case.expect_death) {
         // Death tests cannot track these expectations but arguments should be
         // forwarded to ensure death occurs.
-        ON_CALL(*mock_manager(), RequestPermissionsFromCurrentDocument(
-                                     rfh,
-                                     PermissionRequestDescription(
-                                         test_case.delegated_permissions,
-                                         /*user_gesture*/ true, GURL(kTestUrl)),
-                                     testing::_))
+        ON_CALL(*mock_manager(),
+                RequestPermissionsFromCurrentDocument(
+                    rfh,
+                    PermissionRequestDescription(
+                        content::PermissionDescriptorUtil::
+                            CreatePermissionDescriptorForPermissionTypes(
+                                test_case.delegated_permissions),
+                        /*user_gesture*/ true, GURL(kTestUrl)),
+                    testing::_))
             .WillByDefault(testing::Invoke(forward_callbacks));
       } else {
         EXPECT_CALL(*mock_manager(),
                     RequestPermissionsFromCurrentDocument(
                         rfh,
                         PermissionRequestDescription(
-                            test_case.delegated_permissions,
+                            content::PermissionDescriptorUtil::
+                                CreatePermissionDescriptorForPermissionTypes(
+                                    test_case.delegated_permissions),
                             /*user_gesture*/ true, GURL(kTestUrl)),
                         testing::_))
             .WillOnce(testing::Invoke(forward_callbacks));
@@ -309,8 +315,11 @@ TEST_F(PermissionControllerImplTest,
       EXPECT_DEATH_IF_SUPPORTED(
           PermissionControllerRequestPermissionsFromCurrentDocument(
               rfh,
-              PermissionRequestDescription(kTypesToQuery,
-                                           /*user_gesture*/ true),
+              PermissionRequestDescription(
+                  content::PermissionDescriptorUtil::
+                      CreatePermissionDescriptorForPermissionTypes(
+                          kTypesToQuery),
+                  /*user_gesture*/ true),
               callback.Get()),
           "");
     } else {
@@ -319,7 +328,10 @@ TEST_F(PermissionControllerImplTest,
                   Run(testing::ElementsAreArray(test_case.expected_results)));
       PermissionControllerRequestPermissionsFromCurrentDocument(
           rfh,
-          PermissionRequestDescription(kTypesToQuery, /*user_gesture*/ true),
+          PermissionRequestDescription(
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionTypes(kTypesToQuery),
+              /*user_gesture*/ true),
           callback.Get());
     }
   }
@@ -368,20 +380,25 @@ TEST_F(PermissionControllerImplTest,
         // Death tests cannot track these expectations but arguments should be
         // forwarded to ensure death occurs.
         ON_CALL(*mock_manager(),
-                RequestPermissions(rfh,
-                                   PermissionRequestDescription(
-                                       test_case.delegated_permissions,
-                                       /*user_gesture*/ true, GURL(kTestUrl)),
-                                   testing::_))
+                RequestPermissions(
+                    rfh,
+                    PermissionRequestDescription(
+                        content::PermissionDescriptorUtil::
+                            CreatePermissionDescriptorForPermissionTypes(
+                                test_case.delegated_permissions),
+                        /*user_gesture*/ true, GURL(kTestUrl)),
+                    testing::_))
             .WillByDefault(testing::Invoke(forward_callbacks));
       } else {
-        EXPECT_CALL(
-            *mock_manager(),
-            RequestPermissions(rfh,
-                               PermissionRequestDescription(
-                                   test_case.delegated_permissions,
-                                   /*user_gesture*/ true, GURL(kTestUrl)),
-                               testing::_))
+        EXPECT_CALL(*mock_manager(),
+                    RequestPermissions(
+                        rfh,
+                        PermissionRequestDescription(
+                            content::PermissionDescriptorUtil::
+                                CreatePermissionDescriptorForPermissionTypes(
+                                    test_case.delegated_permissions),
+                            /*user_gesture*/ true, GURL(kTestUrl)),
+                        testing::_))
             .WillOnce(testing::Invoke(forward_callbacks));
       }
     } else {
@@ -396,8 +413,11 @@ TEST_F(PermissionControllerImplTest,
       EXPECT_DEATH_IF_SUPPORTED(
           PermissionControllerRequestPermissions(
               rfh,
-              PermissionRequestDescription(kTypesToQuery, /*user_gesture*/ true,
-                                           GURL(kTestUrl)),
+              PermissionRequestDescription(
+                  content::PermissionDescriptorUtil::
+                      CreatePermissionDescriptorForPermissionTypes(
+                          kTypesToQuery),
+                  /*user_gesture*/ true, GURL(kTestUrl)),
               callback.Get()),
           "");
     } else {
@@ -406,8 +426,10 @@ TEST_F(PermissionControllerImplTest,
                   Run(testing::ElementsAreArray(test_case.expected_results)));
       PermissionControllerRequestPermissions(
           rfh,
-          PermissionRequestDescription(kTypesToQuery, /*user_gesture*/ true,
-                                       GURL(kTestUrl)),
+          PermissionRequestDescription(
+              content::PermissionDescriptorUtil::
+                  CreatePermissionDescriptorForPermissionTypes(kTypesToQuery),
+              /*user_gesture*/ true, GURL(kTestUrl)),
           callback.Get());
     }
   }

content/browser/permissions/permission_descriptor_util.cc

@@ -0,0 +1,191 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/public/browser/permission_descriptor_util.h"
+
+namespace {
+static blink::mojom::PermissionDescriptorPtr CreatePermissionDescriptor(
+    blink::mojom::PermissionName name) {
+  auto descriptor = blink::mojom::PermissionDescriptor::New();
+  descriptor->name = name;
+  return descriptor;
+}
+
+static blink::mojom::PermissionDescriptorPtr CreateMidiPermissionDescriptor(
+    bool sysex) {
+  auto descriptor =
+      CreatePermissionDescriptor(blink::mojom::PermissionName::MIDI);
+  auto midi_extension = blink::mojom::MidiPermissionDescriptor::New();
+  midi_extension->sysex = sysex;
+  descriptor->extension = blink::mojom::PermissionDescriptorExtension::NewMidi(
+      std::move(midi_extension));
+  return descriptor;
+}
+
+static blink::mojom::PermissionDescriptorPtr
+CreateClipboardPermissionDescriptor(blink::mojom::PermissionName name,
+                                    bool has_user_gesture,
+                                    bool will_be_sanitized) {
+  auto descriptor = CreatePermissionDescriptor(name);
+  auto clipboard_extension = blink::mojom::ClipboardPermissionDescriptor::New(
+      has_user_gesture, will_be_sanitized);
+  descriptor->extension =
+      blink::mojom::PermissionDescriptorExtension::NewClipboard(
+          std::move(clipboard_extension));
+  return descriptor;
+}
+
+static blink::mojom::PermissionDescriptorPtr
+CreateVideoCapturePermissionDescriptor(bool pan_tilt_zoom) {
+  auto descriptor =
+      CreatePermissionDescriptor(blink::mojom::PermissionName::VIDEO_CAPTURE);
+  auto camera_device_extension =
+      blink::mojom::CameraDevicePermissionDescriptor::New(pan_tilt_zoom);
+  descriptor->extension =
+      blink::mojom::PermissionDescriptorExtension::NewCameraDevice(
+          std::move(camera_device_extension));
+  return descriptor;
+}
+
+static blink::mojom::PermissionDescriptorPtr
+CreateFullscreenPermissionDescriptor(bool allow_without_user_gesture) {
+  auto descriptor =
+      CreatePermissionDescriptor(blink::mojom::PermissionName::FULLSCREEN);
+  auto fullscreen_extension = blink::mojom::FullscreenPermissionDescriptor::New(
+      allow_without_user_gesture);
+  descriptor->extension =
+      blink::mojom::PermissionDescriptorExtension::NewFullscreen(
+          std::move(fullscreen_extension));
+  return descriptor;
+}
+}  // namespace
+
+namespace content {
+
+// static
+blink::mojom::PermissionDescriptorPtr
+content::PermissionDescriptorUtil::CreatePermissionDescriptorForPermissionType(
+    blink::PermissionType permission_type) {
+  switch (permission_type) {
+    case blink::PermissionType::MIDI_SYSEX:
+      return CreateMidiPermissionDescriptor(/*sysex=*/true);
+    case blink::PermissionType::NOTIFICATIONS:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::NOTIFICATIONS);
+    case blink::PermissionType::GEOLOCATION:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::GEOLOCATION);
+    case blink::PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::PROTECTED_MEDIA_IDENTIFIER);
+    case blink::PermissionType::MIDI:
+      return CreateMidiPermissionDescriptor(false);
+    case blink::PermissionType::DURABLE_STORAGE:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::DURABLE_STORAGE);
+    case blink::PermissionType::AUDIO_CAPTURE:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::AUDIO_CAPTURE);
+    case blink::PermissionType::VIDEO_CAPTURE:
+      return CreateVideoCapturePermissionDescriptor(/*pan_tilt_zoom=*/false);
+    case blink::PermissionType::BACKGROUND_SYNC:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::BACKGROUND_SYNC);
+    case blink::PermissionType::SENSORS:
+      return CreatePermissionDescriptor(blink::mojom::PermissionName::SENSORS);
+    case blink::PermissionType::PAYMENT_HANDLER:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::PAYMENT_HANDLER);
+    case blink::PermissionType::BACKGROUND_FETCH:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::BACKGROUND_FETCH);
+    case blink::PermissionType::IDLE_DETECTION:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::IDLE_DETECTION);
+    case blink::PermissionType::PERIODIC_BACKGROUND_SYNC:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::PERIODIC_BACKGROUND_SYNC);
+    case blink::PermissionType::WAKE_LOCK_SCREEN:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::SCREEN_WAKE_LOCK);
+    case blink::PermissionType::WAKE_LOCK_SYSTEM:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::SYSTEM_WAKE_LOCK);
+    case blink::PermissionType::NFC:
+      return CreatePermissionDescriptor(blink::mojom::PermissionName::NFC);
+    case blink::PermissionType::CLIPBOARD_READ_WRITE:
+      return CreateClipboardPermissionDescriptor(
+          blink::mojom::PermissionName::CLIPBOARD_WRITE, false, false);
+    case blink::PermissionType::CLIPBOARD_SANITIZED_WRITE:
+      return CreateClipboardPermissionDescriptor(
+          blink::mojom::PermissionName::CLIPBOARD_WRITE, true, true);
+    case blink::PermissionType::VR:
+      return CreatePermissionDescriptor(blink::mojom::PermissionName::VR);
+    case blink::PermissionType::AR:
+      return CreatePermissionDescriptor(blink::mojom::PermissionName::AR);
+    case blink::PermissionType::STORAGE_ACCESS_GRANT:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::STORAGE_ACCESS);
+    case blink::PermissionType::CAMERA_PAN_TILT_ZOOM:
+      return CreateVideoCapturePermissionDescriptor(true);
+    case blink::PermissionType::WINDOW_MANAGEMENT:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::WINDOW_MANAGEMENT);
+    case blink::PermissionType::LOCAL_FONTS:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::LOCAL_FONTS);
+    case blink::PermissionType::DISPLAY_CAPTURE:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::DISPLAY_CAPTURE);
+    case blink::PermissionType::TOP_LEVEL_STORAGE_ACCESS:
+      NOTREACHED();
+    case blink::PermissionType::CAPTURED_SURFACE_CONTROL:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::CAPTURED_SURFACE_CONTROL);
+    case blink::PermissionType::SMART_CARD:
+      NOTREACHED();
+    case blink::PermissionType::WEB_PRINTING:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::WEB_PRINTING);
+    case blink::PermissionType::SPEAKER_SELECTION:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::SPEAKER_SELECTION);
+    case blink::PermissionType::KEYBOARD_LOCK:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::KEYBOARD_LOCK);
+    case blink::PermissionType::POINTER_LOCK:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::POINTER_LOCK);
+    case blink::PermissionType::AUTOMATIC_FULLSCREEN:
+      return CreateFullscreenPermissionDescriptor(
+          /*allow_without_user_gesture=*/true);
+    case blink::PermissionType::HAND_TRACKING:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::HAND_TRACKING);
+    case blink::PermissionType::WEB_APP_INSTALLATION:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::WEB_APP_INSTALLATION);
+    case blink::PermissionType::LOCAL_NETWORK_ACCESS:
+      return CreatePermissionDescriptor(
+          blink::mojom::PermissionName::LOCAL_NETWORK_ACCESS);
+    case blink::PermissionType::NUM:
+      NOTREACHED();
+  }
+  NOTREACHED();
+}
+
+// static
+std::vector<blink::mojom::PermissionDescriptorPtr>
+PermissionDescriptorUtil::CreatePermissionDescriptorForPermissionTypes(
+    const std::vector<blink::PermissionType>& permission_types) {
+  std::vector<blink::mojom::PermissionDescriptorPtr> descriptors;
+  descriptors.reserve(permission_types.size());
+  for (const auto& permission_type : permission_types) {
+    descriptors.emplace_back(
+        CreatePermissionDescriptorForPermissionType(permission_type));
+  }
+  return descriptors;
+}
+
+}  // namespace content

content/browser/permissions/permission_service_impl.cc

@@ -76,38 +76,37 @@ void EmbeddedPermissionRequestCallbackWrapper(
       PermissionStatusToEmbeddedPermissionControlResult(statuses[0]));
 }
 
-// Helper converts the given vector `PermissionDescriptorPtr` to vector
-// `PermissionType`. Checks and returns empty vector if there's duplicate
-// permission in the input vector.
-std::vector<blink::PermissionType> GetPermissionTypesAndCheckDuplicates(
+// Helper which returns true if there are any duplicate or invalid permissions.
+bool HasDuplicatesOrInvalidPermissions(
     const std::vector<PermissionDescriptorPtr>& permissions) {
   std::vector<blink::PermissionType> types(permissions.size());
   std::set<blink::PermissionType> duplicates_check;
   for (size_t i = 0; i < types.size(); ++i) {
-    auto type = blink::PermissionDescriptorToPermissionType(permissions[i]);
+    auto type =
+        blink::MaybePermissionDescriptorToPermissionType(permissions[i]);
     if (!type) {
-      return std::vector<blink::PermissionType>();
+      return true;
     }
 
     types[i] = *type;
 
     bool inserted = duplicates_check.insert(types[i]).second;
     if (!inserted) {
-      return std::vector<blink::PermissionType>();
+      return true;
     }
   }
-
-  return types;
+  return false;
 }
 
 // Helper check if permission types are all supported by Page Embedded
 // Permission.
 bool CheckPageEmbeddedPermissionTypes(
-    const std::vector<blink::PermissionType>& permission_types) {
-  for (auto permission_type : permission_types) {
-    if (permission_type != blink::PermissionType::GEOLOCATION &&
-        permission_type != blink::PermissionType::AUDIO_CAPTURE &&
-        permission_type != blink::PermissionType::VIDEO_CAPTURE) {
+    const std::vector<PermissionDescriptorPtr>& permissions) {
+  for (const auto& permission_type : permissions) {
+    auto type = blink::PermissionDescriptorToPermissionType(permission_type);
+    if (type != blink::PermissionType::GEOLOCATION &&
+        type != blink::PermissionType::AUDIO_CAPTURE &&
+        type != blink::PermissionType::VIDEO_CAPTURE) {
       return false;
     }
   }
@@ -118,9 +117,10 @@ bool CheckPageEmbeddedPermissionTypes(
 
 class PermissionServiceImpl::PendingRequest {
  public:
-  PendingRequest(std::vector<blink::PermissionType> types,
-                 RequestPermissionsCallback callback)
-      : callback_(std::move(callback)), request_size_(types.size()) {}
+  PendingRequest(
+      const std::vector<blink::mojom::PermissionDescriptorPtr>& requests,
+      RequestPermissionsCallback callback)
+      : callback_(std::move(callback)), request_size_(requests.size()) {}
 
   ~PendingRequest() {
     if (callback_.is_null())
@@ -209,18 +209,23 @@ void PermissionServiceImpl::RequestPageEmbeddedPermission(
   }
 
   if (auto* browser_context = context_->GetBrowserContext()) {
-    std::vector<blink::PermissionType> permission_types =
-        GetPermissionTypesAndCheckDuplicates(descriptor->permissions);
-    if (permission_types.empty() ||
-        !CheckPageEmbeddedPermissionTypes(permission_types)) {
+    if (HasDuplicatesOrInvalidPermissions(descriptor->permissions) ||
+        !CheckPageEmbeddedPermissionTypes(descriptor->permissions)) {
       ReceivedBadMessage();
       return;
     }
 
+    std::vector<PermissionDescriptorPtr> permission_descriptors;
+    permission_descriptors.reserve(descriptor->permissions.size());
+
+    for (PermissionDescriptorPtr& permission : descriptor->permissions) {
+      permission_descriptors.push_back(permission.Clone());
+    }
+
     RequestPermissionsInternal(
-        browser_context, descriptor->permissions,
+        browser_context,
         PermissionRequestDescription(
-            permission_types, /*user_gesture=*/true,
+            std::move(permission_descriptors), /*user_gesture=*/true,
             /*requesting_origin=*/GURL(),
             /*embedded_permission_element_initiated=*/true,
             /*anchor_element_position=*/descriptor->element_position),
@@ -265,24 +270,22 @@ void PermissionServiceImpl::RequestPermissions(
     return;
   }
 
-  std::vector<blink::PermissionType> permission_types =
-      GetPermissionTypesAndCheckDuplicates(permissions);
-  if (permission_types.empty()) {
+  if (HasDuplicatesOrInvalidPermissions(permissions)) {
     ReceivedBadMessage();
     return;
   }
 
   RequestPermissionsInternal(
-      browser_context, permissions,
-      PermissionRequestDescription(permission_types, user_gesture),
+      browser_context,
+      PermissionRequestDescription(std::move(permissions), user_gesture),
       std::move(callback));
 }
 
 void PermissionServiceImpl::RequestPermissionsInternal(
     BrowserContext* browser_context,
-    const std::vector<PermissionDescriptorPtr>& permissions,
     PermissionRequestDescription request_description,
     RequestPermissionsCallback callback) {
+  const auto& permissions = request_description.permissions;
   std::unique_ptr<PendingRequest> pending_request =
       std::make_unique<PendingRequest>(request_description.permissions,
                                        std::move(callback));
@@ -331,7 +334,7 @@ void PermissionServiceImpl::RevokePermission(
     PermissionDescriptorPtr permission,
     PermissionStatusCallback callback) {
   auto permission_type =
-      blink::PermissionDescriptorToPermissionType(permission);
+      blink::MaybePermissionDescriptorToPermissionType(permission);
   if (!permission_type) {
     ReceivedBadMessage();
     return;
@@ -354,7 +357,7 @@ void PermissionServiceImpl::AddPermissionObserver(
     PermissionDescriptorPtr permission,
     PermissionStatus last_known_status,
     mojo::PendingRemote<blink::mojom::PermissionObserver> observer) {
-  auto type = blink::PermissionDescriptorToPermissionType(permission);
+  auto type = blink::MaybePermissionDescriptorToPermissionType(permission);
   if (!type) {
     ReceivedBadMessage();
     return;
@@ -376,7 +379,7 @@ void PermissionServiceImpl::AddPageEmbeddedPermissionObserver(
         bad_message::PSI_ADD_PAGE_EMBEDDED_PERMISSION_OBSERVER_WITHOUT_FEATURE);
     return;
   }
-  auto type = blink::PermissionDescriptorToPermissionType(permission);
+  auto type = blink::MaybePermissionDescriptorToPermissionType(permission);
   if (!type) {
     ReceivedBadMessage();
     return;
@@ -391,7 +394,7 @@ void PermissionServiceImpl::NotifyEventListener(
     blink::mojom::PermissionDescriptorPtr permission,
     const std::string& event_type,
     bool is_added) {
-  auto type = blink::PermissionDescriptorToPermissionType(permission);
+  auto type = blink::MaybePermissionDescriptorToPermissionType(permission);
   if (!type) {
     ReceivedBadMessage();
     return;
@@ -420,7 +423,7 @@ void PermissionServiceImpl::NotifyEventListener(
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatus(
     const PermissionDescriptorPtr& permission) {
-  auto type = blink::PermissionDescriptorToPermissionType(permission);
+  auto type = blink::MaybePermissionDescriptorToPermissionType(permission);
   if (!type) {
     ReceivedBadMessage();
     return PermissionStatus::DENIED;
@@ -428,9 +431,13 @@ PermissionStatus PermissionServiceImpl::GetPermissionStatus(
   if (PermissionUtil::IsDomainOverride(permission) &&
       context_->render_frame_host()) {
     BrowserContext* browser_context = context_->GetBrowserContext();
-    if (browser_context &&
-        PermissionUtil::ValidateDomainOverride(
-            {type.value()}, context_->render_frame_host(), permission)) {
+
+    std::vector<blink::mojom::PermissionDescriptorPtr>
+        permisison_descriptor_ptr_array;
+    permisison_descriptor_ptr_array.emplace_back(permission->Clone());
+    if (browser_context && PermissionUtil::ValidateDomainOverride(
+                               permisison_descriptor_ptr_array,
+                               context_->render_frame_host(), permission)) {
       return PermissionControllerImpl::FromBrowserContext(browser_context)
           ->GetPermissionStatusForEmbeddedRequester(
               *type, context_->render_frame_host(),
@@ -477,7 +484,7 @@ PermissionStatus PermissionServiceImpl::GetCombinedPermissionAndDeviceStatus(
     return PermissionStatus::DENIED;
   }
 
-  auto type = blink::PermissionDescriptorToPermissionType(permission);
+  auto type = blink::MaybePermissionDescriptorToPermissionType(permission);
   if (!type) {
     ReceivedBadMessage();
     return PermissionStatus::DENIED;

content/browser/permissions/permission_service_impl.h

@@ -81,7 +81,6 @@ class PermissionServiceImpl : public blink::mojom::PermissionService {
 
   void RequestPermissionsInternal(
       BrowserContext* browser_context,
-      const std::vector<blink::mojom::PermissionDescriptorPtr>& permissions,
       PermissionRequestDescription request_description,
       RequestPermissionsCallback callback);
 

content/browser/permissions/permission_util.cc

@@ -71,7 +71,7 @@ const url::Origin& PermissionUtil::ExtractDomainOverride(
 }
 
 bool PermissionUtil::ValidateDomainOverride(
-    const std::vector<blink::PermissionType>& types,
+    const std::vector<blink::mojom::PermissionDescriptorPtr>& types,
     RenderFrameHost* rfh,
     const blink::mojom::PermissionDescriptorPtr& descriptor) {
   if (types.size() > 1) {

content/browser/permissions/permission_util.h

@@ -44,7 +44,7 @@ class PermissionUtil {
   // mechanism is currently only used by one permission type, specifically
   // storage access requests on behalf of another domain.
   CONTENT_EXPORT static bool ValidateDomainOverride(
-      const std::vector<blink::PermissionType>& types,
+      const std::vector<blink::mojom::PermissionDescriptorPtr>& types,
       RenderFrameHost* rfh,
       const blink::mojom::PermissionDescriptorPtr& descriptor);
 };

content/browser/permissions/permission_util_unittest.cc

@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 #include "content/browser/permissions/permission_util.h"
+
 #include "base/test/scoped_feature_list.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/web_contents_tester.h"
@@ -58,10 +60,14 @@ TEST_F(PermissionUtilTest, TestInvalidDomainOverrideFeatureDisabled) {
       {}, nullptr, blink::mojom::PermissionDescriptor::New()));
 }
 TEST_F(PermissionUtilTest, TestInvalidDomainOverrideMultiRequest) {
+  std::vector<blink::mojom::PermissionDescriptorPtr> descriptors;
+  descriptors.emplace_back(
+      PermissionDescriptorUtil::CreatePermissionDescriptorForPermissionType(
+          blink::PermissionType::STORAGE_ACCESS_GRANT));
+  descriptors.emplace_back(descriptors.front()->Clone());
+
   EXPECT_FALSE(PermissionUtil::ValidateDomainOverride(
-      {blink::PermissionType::STORAGE_ACCESS_GRANT,
-       blink::PermissionType::STORAGE_ACCESS_GRANT},
-      nullptr, blink::mojom::PermissionDescriptor::New()));
+      descriptors, nullptr, blink::mojom::PermissionDescriptor::New()));
 }
 TEST_F(PermissionUtilTest, TestInvalidDomainOverrideNullRfh) {
   content::BrowserTaskEnvironment task_environment;
@@ -76,9 +82,13 @@ TEST_F(PermissionUtilTest, TestInvalidDomainOverrideNullRfh) {
       WebContentsTester::For(web_contents.get());
   web_contents_tester->NavigateAndCommit(GURL("https://example.xyz"));
 
+  std::vector<blink::mojom::PermissionDescriptorPtr> descriptors;
+  descriptors.emplace_back(
+      PermissionDescriptorUtil::CreatePermissionDescriptorForPermissionType(
+          blink::PermissionType::STORAGE_ACCESS_GRANT));
+
   EXPECT_FALSE(PermissionUtil::ValidateDomainOverride(
-      {blink::PermissionType::STORAGE_ACCESS_GRANT}, nullptr,
-      blink::mojom::PermissionDescriptor::New()));
+      descriptors, nullptr, blink::mojom::PermissionDescriptor::New()));
 }
 
 TEST_F(PermissionUtilTest, TestValidDomainOverride) {
@@ -105,9 +115,13 @@ TEST_F(PermissionUtilTest, TestValidDomainOverride) {
       blink::mojom::PermissionDescriptorExtension::NewTopLevelStorageAccess(
           std::move(top_level_storage_access_extension));
 
+  std::vector<blink::mojom::PermissionDescriptorPtr> descriptors;
+  descriptors.emplace_back(
+      PermissionDescriptorUtil::CreatePermissionDescriptorForPermissionType(
+          blink::PermissionType::STORAGE_ACCESS_GRANT));
+
   EXPECT_TRUE(PermissionUtil::ValidateDomainOverride(
-      {blink::PermissionType::STORAGE_ACCESS_GRANT},
-      web_contents->GetPrimaryMainFrame(), descriptor));
+      descriptors, web_contents->GetPrimaryMainFrame(), descriptor));
 }
 
 TEST_F(PermissionUtilTest, TestSameOriginInvalidDomainOverride) {
@@ -133,8 +147,11 @@ TEST_F(PermissionUtilTest, TestSameOriginInvalidDomainOverride) {
       blink::mojom::PermissionDescriptorExtension::NewTopLevelStorageAccess(
           std::move(top_level_storage_access_extension));
 
+  std::vector<blink::mojom::PermissionDescriptorPtr> descriptors;
+  descriptors.emplace_back(
+      PermissionDescriptorUtil::CreatePermissionDescriptorForPermissionType(
+          blink::PermissionType::STORAGE_ACCESS_GRANT));
   EXPECT_FALSE(PermissionUtil::ValidateDomainOverride(
-      {blink::PermissionType::STORAGE_ACCESS_GRANT},
-      web_contents->GetPrimaryMainFrame(), descriptor));
+      descriptors, web_contents->GetPrimaryMainFrame(), descriptor));
 }
 }  // namespace content

content/browser/push_messaging/push_messaging_manager.cc

@@ -27,6 +27,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_host.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_switches.h"
@@ -346,7 +347,10 @@ void PushMessagingManager::Register(PushMessagingManager::RegisterData data) {
               ->RequestPermissionFromCurrentDocument(
                   render_frame_host_impl,
                   PermissionRequestDescription(
-                      blink::PermissionType::NOTIFICATIONS, user_gesture),
+                      PermissionDescriptorUtil::
+                          CreatePermissionDescriptorForPermissionType(
+                              blink::PermissionType::NOTIFICATIONS),
+                      user_gesture),
                   base::BindOnce(
                       &PushMessagingManager::DidRequestPermissionInIncognito,
                       AsWeakPtr(), std::move(data)));

content/browser/storage_partition_impl.cc

@@ -116,6 +116,7 @@
 #include "content/public/browser/login_delegate.h"
 #include "content/public/browser/network_service_instance.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_result.h"
 #include "content/public/browser/private_aggregation_data_model.h"
 #include "content/public/browser/private_network_device_delegate.h"
@@ -2261,7 +2262,9 @@ void StoragePartitionImpl::OnLocalNetworkAccessPermissionRequired(
     permission_controller->RequestPermissionFromCurrentDocument(
         rfh,
         PermissionRequestDescription(
-            blink::PermissionType::LOCAL_NETWORK_ACCESS),
+            content::PermissionDescriptorUtil::
+                CreatePermissionDescriptorForPermissionType(
+                    blink::PermissionType::LOCAL_NETWORK_ACCESS)),
         base::BindOnce(
             [](OnLocalNetworkAccessPermissionRequiredCallback cb,
                PermissionStatus status) {

content/browser/xr/service/vr_service_impl.cc

@@ -28,6 +28,7 @@
 #include "content/browser/xr/webxr_internals/webxr_internals_handler_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/permission_request_description.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -577,8 +578,10 @@ void VRServiceImpl::DoRequestPermissions(
 
   permission_controller->RequestPermissionsFromCurrentDocument(
       render_frame_host_,
-      PermissionRequestDescription(request_permissions,
-                                   /*user_gesture=*/true),
+      PermissionRequestDescription(
+          PermissionDescriptorUtil::
+              CreatePermissionDescriptorForPermissionTypes(request_permissions),
+          /*user_gesture=*/true),
       std::move(result_callback));
 }
 

content/public/browser/BUILD.gn

@@ -317,6 +317,7 @@ source_set("browser_sources") {
     "permission_controller.h",
     "permission_controller_delegate.cc",
     "permission_controller_delegate.h",
+    "permission_descriptor_util.h",
     "permission_overrides.cc",
     "permission_overrides.h",
     "permission_request_description.cc",

content/public/browser/permission_descriptor_util.h

@@ -0,0 +1,37 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_PUBLIC_BROWSER_PERMISSION_DESCRIPTOR_UTIL_H_
+#define CONTENT_PUBLIC_BROWSER_PERMISSION_DESCRIPTOR_UTIL_H_
+
+#include "content/common/content_export.h"
+#include "third_party/blink/public/common/permissions/permission_utils.h"
+#include "third_party/blink/public/mojom/permissions/permission.mojom.h"
+
+namespace content {
+
+class PermissionDescriptorUtil {
+ public:
+  // Utility function that creates a default `PermissionDescriptorPtr` for the a
+  // PermissionType. Used only for
+  // simple ContentSetting types without options while refactorings to support
+  // permission options are performed.
+  // TODO(https://crbug.com/406755622): Remove mapping function
+  CONTENT_EXPORT static blink::mojom::PermissionDescriptorPtr
+  CreatePermissionDescriptorForPermissionType(
+      blink::PermissionType permission_type);
+
+  // Utility function that creates a vector of default
+  // `PermissionDescriptorPtr`s for a vector of `PermissionType. Used only for
+  // simple ContentSetting types without options while refactorings to support
+  // permission options are performed.
+  // TODO(https://crbug.com/406755622): Remove mapping function
+  CONTENT_EXPORT static std::vector<blink::mojom::PermissionDescriptorPtr>
+  CreatePermissionDescriptorForPermissionTypes(
+      const std::vector<blink::PermissionType>& permission_types);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_BROWSER_PERMISSION_DESCRIPTOR_UTIL_H_

content/public/browser/permission_request_description.cc

@@ -7,12 +7,12 @@
 namespace content {
 
 PermissionRequestDescription::PermissionRequestDescription(
-    const std::vector<blink::PermissionType>& permissions,
+    std::vector<blink::mojom::PermissionDescriptorPtr> permissions,
     bool user_gesture,
     const GURL& requesting_origin,
     bool embedded_permission_element_initiated,
     const std::optional<gfx::Rect>& anchor_element_position)
-    : permissions(permissions),
+    : permissions(std::move(permissions)),
       user_gesture(user_gesture),
       requesting_origin(requesting_origin),
       embedded_permission_element_initiated(
@@ -20,20 +20,33 @@ PermissionRequestDescription::PermissionRequestDescription(
       anchor_element_position(anchor_element_position) {}
 
 PermissionRequestDescription::PermissionRequestDescription(
-    blink::PermissionType permission,
+    blink::mojom::PermissionDescriptorPtr permission,
     bool user_gesture,
     const GURL& requesting_origin,
     bool embedded_permission_element_initiated,
     const std::optional<gfx::Rect>& anchor_element_position)
-    : PermissionRequestDescription(
-          std::vector<blink::PermissionType>{permission},
-          user_gesture,
-          requesting_origin,
-          embedded_permission_element_initiated,
-          anchor_element_position) {}
+    : user_gesture(user_gesture),
+      requesting_origin(requesting_origin),
+      embedded_permission_element_initiated(
+          embedded_permission_element_initiated),
+      anchor_element_position(anchor_element_position) {
+  permissions.push_back(std::move(permission));
+}
 
 PermissionRequestDescription::PermissionRequestDescription(
-    const PermissionRequestDescription&) = default;
+    const PermissionRequestDescription& other) {
+  for (const auto& permission : other.permissions) {
+    permissions.push_back(permission.Clone());
+  }
+  user_gesture = other.user_gesture;
+  requesting_origin = other.requesting_origin;
+  embedded_permission_element_initiated =
+      other.embedded_permission_element_initiated;
+  anchor_element_position = other.anchor_element_position;
+  requested_audio_capture_device_ids = other.requested_audio_capture_device_ids;
+  requested_video_capture_device_ids = other.requested_video_capture_device_ids;
+}
+
 PermissionRequestDescription& PermissionRequestDescription::operator=(
     PermissionRequestDescription&&) = default;
 PermissionRequestDescription::PermissionRequestDescription(

content/public/browser/permission_request_description.h

@@ -10,6 +10,7 @@
 
 #include "content/common/content_export.h"
 #include "third_party/blink/public/common/permissions/permission_utils.h"
+#include "third_party/blink/public/mojom/permissions/permission.mojom.h"
 #include "third_party/blink/public/mojom/permissions/permission_status.mojom.h"
 #include "ui/gfx/geometry/rect.h"
 #include "url/gurl.h"
@@ -20,14 +21,14 @@ namespace content {
 // permission from a renderer, including important contextual information.
 struct CONTENT_EXPORT PermissionRequestDescription {
   explicit PermissionRequestDescription(
-      const std::vector<blink::PermissionType>& permissions,
+      std::vector<blink::mojom::PermissionDescriptorPtr> permissions,
       bool user_gesture = false,
       const GURL& requesting_origin = GURL(),
       bool embedded_permission_element_initiated = false,
       const std::optional<gfx::Rect>& anchor_element_position = std::nullopt);
 
   explicit PermissionRequestDescription(
-      blink::PermissionType permission,
+      blink::mojom::PermissionDescriptorPtr permissions,
       bool user_gesture = false,
       const GURL& requesting_origin = GURL(),
       bool embedded_permission_element_initiated = false,
@@ -46,7 +47,7 @@ struct CONTENT_EXPORT PermissionRequestDescription {
   bool operator==(const PermissionRequestDescription& other) const;
 
   // Define the list of permissions we will request.
-  std::vector<blink::PermissionType> permissions;
+  std::vector<blink::mojom::PermissionDescriptorPtr> permissions;
 
   // Indicates the request is initiated by a user gesture.
   bool user_gesture;

content/shell/browser/shell_permission_manager.cc

@@ -103,9 +103,11 @@ void ShellPermissionManager::RequestPermissions(
   }
   std::vector<blink::mojom::PermissionStatus> result;
   for (const auto& permission : request_description.permissions) {
-    result.push_back(IsAllowlistedPermissionType(permission)
-                         ? blink::mojom::PermissionStatus::GRANTED
-                         : blink::mojom::PermissionStatus::DENIED);
+    result.push_back(
+        IsAllowlistedPermissionType(
+            blink::PermissionDescriptorToPermissionType(permission))
+            ? blink::mojom::PermissionStatus::GRANTED
+            : blink::mojom::PermissionStatus::DENIED);
   }
   std::move(callback).Run(result);
 }
@@ -129,9 +131,11 @@ void ShellPermissionManager::RequestPermissionsFromCurrentDocument(
   }
   std::vector<blink::mojom::PermissionStatus> result;
   for (const auto& permission : request_description.permissions) {
-    result.push_back(IsAllowlistedPermissionType(permission)
-                         ? blink::mojom::PermissionStatus::GRANTED
-                         : blink::mojom::PermissionStatus::DENIED);
+    result.push_back(
+        IsAllowlistedPermissionType(
+            blink::PermissionDescriptorToPermissionType(permission))
+            ? blink::mojom::PermissionStatus::GRANTED
+            : blink::mojom::PermissionStatus::DENIED);
   }
   std::move(callback).Run(result);
 }

content/web_test/browser/web_test_permission_manager.cc

@@ -164,7 +164,8 @@ void WebTestPermissionManager::RequestPermissions(
       render_frame_host->GetMainFrame());
   for (const auto& permission : request_description.permissions) {
     result.push_back(GetPermissionStatusForRequestPermission(
-        permission, request_description.requesting_origin, embedding_origin));
+        blink::PermissionDescriptorToPermissionType(permission),
+        request_description.requesting_origin, embedding_origin));
   }
 
   std::move(callback).Run(result);
@@ -204,7 +205,8 @@ void WebTestPermissionManager::RequestPermissionsFromCurrentDocument(
       render_frame_host->GetMainFrame());
   for (const auto& permission : request_description.permissions) {
     result.push_back(GetPermissionStatusForRequestPermission(
-        permission, request_description.requesting_origin, embedding_origin));
+        blink::PermissionDescriptorToPermissionType(permission),
+        request_description.requesting_origin, embedding_origin));
   }
 
   std::move(callback).Run(result);
@@ -386,7 +388,7 @@ void WebTestPermissionManager::SetPermission(
     const GURL& url,
     const GURL& embedding_url,
     blink::test::mojom::PermissionAutomation::SetPermissionCallback callback) {
-  auto type = blink::PermissionDescriptorToPermissionType(descriptor);
+  auto type = blink::MaybePermissionDescriptorToPermissionType(descriptor);
   if (!type) {
     std::move(callback).Run(false);
     return;

fuchsia_web/webengine/browser/frame_impl.cc

@@ -44,6 +44,7 @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_descriptor_util.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
@@ -1469,11 +1470,13 @@ void FrameImpl::RequestMediaAccessPermission(
     content::MediaResponseCallback callback) {
   DCHECK_EQ(web_contents_.get(), web_contents);
 
-  std::vector<blink::PermissionType> permissions;
+  std::vector<blink::mojom::PermissionDescriptorPtr> permissions;
 
   if (request.audio_type ==
       blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE) {
-    permissions.push_back(blink::PermissionType::AUDIO_CAPTURE);
+    permissions.push_back(content::PermissionDescriptorUtil::
+                              CreatePermissionDescriptorForPermissionType(
+                                  blink::PermissionType::AUDIO_CAPTURE));
   } else if (request.audio_type != blink::mojom::MediaStreamType::NO_SERVICE) {
     std::move(callback).Run(
         blink::mojom::StreamDevicesSet(),
@@ -1483,7 +1486,9 @@ void FrameImpl::RequestMediaAccessPermission(
 
   if (request.video_type ==
       blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE) {
-    permissions.push_back(blink::PermissionType::VIDEO_CAPTURE);
+    permissions.push_back(content::PermissionDescriptorUtil::
+                              CreatePermissionDescriptorForPermissionType(
+                                  blink::PermissionType::VIDEO_CAPTURE));
   } else if (request.video_type != blink::mojom::MediaStreamType::NO_SERVICE) {
     std::move(callback).Run(
         blink::mojom::StreamDevicesSet(),
@@ -1512,10 +1517,10 @@ void FrameImpl::RequestMediaAccessPermission(
   content::PermissionController* permission_controller =
       web_contents_->GetBrowserContext()->GetPermissionController();
   DCHECK(permission_controller);
-
   permission_controller->RequestPermissionsFromCurrentDocument(
       render_frame_host,
-      content::PermissionRequestDescription(permissions, request.user_gesture),
+      content::PermissionRequestDescription(std::move(permissions),
+                                            request.user_gesture),
       base::BindOnce(&HandleMediaPermissionsRequestResult, request,
                      std::move(callback)));
 }

fuchsia_web/webengine/browser/web_engine_permission_delegate.cc

@@ -26,7 +26,8 @@ void WebEnginePermissionDelegate::RequestPermissions(
   FrameImpl* frame = FrameImpl::FromRenderFrameHost(render_frame_host);
   DCHECK(frame);
   frame->permission_controller()->RequestPermissions(
-      request_description.permissions,
+      blink::PermissionDescriptorToPermissionTypes(
+          request_description.permissions),
       url::Origin::Create(request_description.requesting_origin),
       std::move(callback));
 }
@@ -48,9 +49,9 @@ void WebEnginePermissionDelegate::RequestPermissionsFromCurrentDocument(
   FrameImpl* frame = FrameImpl::FromRenderFrameHost(render_frame_host);
   DCHECK(frame);
   frame->permission_controller()->RequestPermissions(
-      request_description.permissions,
-      render_frame_host->GetLastCommittedOrigin(),
-      std::move(callback));
+      blink::PermissionDescriptorToPermissionTypes(
+          request_description.permissions),
+      render_frame_host->GetLastCommittedOrigin(), std::move(callback));
 }
 
 blink::mojom::PermissionStatus WebEnginePermissionDelegate::GetPermissionStatus(

third_party/blink/common/permissions/permission_utils.cc

@@ -204,7 +204,7 @@ const std::vector<PermissionType>& GetAllPermissionTypes() {
   return *kAllPermissionTypes;
 }
 
-std::optional<PermissionType> PermissionDescriptorToPermissionType(
+std::optional<PermissionType> MaybePermissionDescriptorToPermissionType(
     const PermissionDescriptorPtr& descriptor) {
   return PermissionDescriptorInfoToPermissionType(
       descriptor->name,
@@ -220,6 +220,27 @@ std::optional<PermissionType> PermissionDescriptorToPermissionType(
           descriptor->extension->get_fullscreen()->allow_without_user_gesture);
 }
 
+PermissionType PermissionDescriptorToPermissionType(
+    const PermissionDescriptorPtr& descriptor) {
+  auto permission_type_optional =
+      MaybePermissionDescriptorToPermissionType(descriptor);
+  CHECK(permission_type_optional.has_value());
+  return permission_type_optional.value();
+}
+
+std::vector<PermissionType> PermissionDescriptorToPermissionTypes(
+    const std::vector<PermissionDescriptorPtr>& descriptors) {
+  std::vector<PermissionType> permission_types;
+  permission_types.reserve(descriptors.size());
+
+  for (const auto& descriptor : descriptors) {
+    permission_types.emplace_back(
+        PermissionDescriptorToPermissionType(descriptor));
+  }
+
+  return permission_types;
+}
+
 std::optional<PermissionType> PermissionDescriptorInfoToPermissionType(
     mojom::PermissionName name,
     bool midi_sysex,

third_party/blink/public/common/permissions/permission_utils.h

@@ -82,11 +82,24 @@ BLINK_COMMON_EXPORT std::string GetPermissionString(PermissionType permission);
 // Get a list of all permission types.
 BLINK_COMMON_EXPORT const std::vector<PermissionType>& GetAllPermissionTypes();
 
-// Given |descriptor|, set |permission_type| to a corresponding PermissionType.
+// Given `PermissionDescriptorPtr`, return the corresponding `PermissionType` if
+// it exists.
 BLINK_COMMON_EXPORT std::optional<PermissionType>
-PermissionDescriptorToPermissionType(
+MaybePermissionDescriptorToPermissionType(
     const mojom::PermissionDescriptorPtr& descriptor);
 
+// Given `PermissionDescriptorPtr`, either return the corresponding
+// `PermissionType` or trigger a CHECK() failure.
+BLINK_COMMON_EXPORT PermissionType PermissionDescriptorToPermissionType(
+    const mojom::PermissionDescriptorPtr& descriptor);
+
+// Given a vector of `PermissionDescriptorPtr`s, return a vector of the
+// corresponding `PermissionType`s. Triggers a CHECK() failure if any
+// `PermissionDescriptorPtr` can't be mapped.
+BLINK_COMMON_EXPORT std::vector<PermissionType>
+PermissionDescriptorToPermissionTypes(
+    const std::vector<mojom::PermissionDescriptorPtr>& descriptors);
+
 // Ideally this would be an equivalent function to
 // |PermissionDescriptorToPermissionType| but for a
 // `mojom::blink::PermissionDescriptorPtr` descriptor. But unfortunately mojo