42 files changed, 1502 insertions, 525 deletions
diff --git a/examples/webenginequick/quicknanobrowser/BrowserWindow.qml b/examples/webenginequick/quicknanobrowser/BrowserWindow.qml
index e2cb71fb3..2c5b3d86e 100644
--- a/examples/webenginequick/quicknanobrowser/BrowserWindow.qml
+++ b/examples/webenginequick/quicknanobrowser/BrowserWindow.qml
@@ -648,10 +648,9 @@ ApplicationWindow {
                         findBar.reset();
                 }
 
-                onFeaturePermissionRequested: function(securityOrigin, feature) {
-                    featurePermissionDialog.securityOrigin = securityOrigin;
-                    featurePermissionDialog.feature = feature;
-                    featurePermissionDialog.visible = true;
+                onPermissionRequested: function(permission) {
+                    permissionDialog.permission = permission;
+                    permissionDialog.visible = true;
                 }
                 onWebAuthUxRequested: function(request) {
                     webAuthDialog.init(request);
@@ -736,7 +735,7 @@ ApplicationWindow {
         }
     }
     Dialog {
-        id: featurePermissionDialog
+        id: permissionDialog
         anchors.centerIn: parent
         width: Math.min(browserWindow.width, browserWindow.height) / 3 * 2
         contentWidth: mainTextForPermissionDialog.width
@@ -744,59 +743,58 @@ ApplicationWindow {
         standardButtons: Dialog.No | Dialog.Yes
         title: "Permission Request"
 
-        property var feature;
-        property url securityOrigin;
+        property var permission;
 
         contentItem: Item {
             Label {
                 id: mainTextForPermissionDialog
-                text: featurePermissionDialog.questionForFeature()
+                text: permissionDialog.questionForFeature()
             }
         }
 
-        onAccepted: currentWebView && currentWebView.grantFeaturePermission(securityOrigin, feature, true)
-        onRejected: currentWebView && currentWebView.grantFeaturePermission(securityOrigin, feature, false)
+        onAccepted: permission.grant()
+        onRejected: permission.deny()
         onVisibleChanged: {
             if (visible)
                 width = contentWidth + 20;
         }
 
         function questionForFeature() {
-            var question = "Allow " + securityOrigin + " to "
+            var question = "Allow " + permission.origin + " to "
 
-            switch (feature) {
-            case WebEngineView.Geolocation:
+            switch (permission.feature) {
+            case WebEnginePermission.Geolocation:
                 question += "access your location information?";
                 break;
-            case WebEngineView.MediaAudioCapture:
+            case WebEnginePermission.MediaAudioCapture:
                 question += "access your microphone?";
                 break;
-            case WebEngineView.MediaVideoCapture:
+            case WebEnginePermission.MediaVideoCapture:
                 question += "access your webcam?";
                 break;
-            case WebEngineView.MediaVideoCapture:
+            case WebEnginePermission.MediaAudioVideoCapture:
                 question += "access your microphone and webcam?";
                 break;
-            case WebEngineView.MouseLock:
+            case WebEnginePermission.MouseLock:
                 question += "lock your mouse cursor?";
                 break;
-            case WebEngineView.DesktopVideoCapture:
+            case WebEnginePermission.DesktopVideoCapture:
                 question += "capture video of your desktop?";
                 break;
-            case WebEngineView.DesktopAudioVideoCapture:
+            case WebEnginePermission.DesktopAudioVideoCapture:
                 question += "capture audio and video of your desktop?";
                 break;
-            case WebEngineView.Notifications:
+            case WebEnginePermission.Notifications:
                 question += "show notification on your desktop?";
                 break;
-            case WebEngineView.ClipboardReadWrite:
+            case WebEnginePermission.ClipboardReadWrite:
                 question += "read from and write to your clipboard?";
                 break;
-            case WebEngineView.LocalFontsAccess:
+            case WebEnginePermission.LocalFontsAccess:
                 question += "access the fonts stored on your machine?";
                 break;
             default:
-                question += "access unknown or unsupported feature [" + feature + "] ?";
+                question += "access unknown or unsupported feature [" + permission.feature + "] ?";
                 break;
             }
 
diff --git a/examples/webenginequick/quicknanobrowser/doc/src/quicknanobrowser.qdoc b/examples/webenginequick/quicknanobrowser/doc/src/quicknanobrowser.qdoc
index 1e00402ff..cff4d3354 100644
--- a/examples/webenginequick/quicknanobrowser/doc/src/quicknanobrowser.qdoc
+++ b/examples/webenginequick/quicknanobrowser/doc/src/quicknanobrowser.qdoc
@@ -96,25 +96,22 @@
     \skipto Dialog {
     \printuntil /^\ {4}\}/
 
-    \section1 Handling Feature Permission Requests
+    \section1 Handling Permission Requests
 
-    We use the \c onFeaturePermissionRequested() signal handler to handle requests for
-    accessing a certain feature or device. The \c securityOrigin parameter identifies the
-    requester web site, and the \c feature parameter is the requested feature. We use these
-    to construct the message of the dialog:
+    We use the \c onPermissionRequested() signal handler to handle requests for
+    accessing a certain feature or device. The \c permission parameter is an object of the
+    WebEnginePermission type, which can be used to handle the incoming request. We temporarily store
+    this object, since we need to use it to construct the message of the dialog:
 
     \quotefromfile webenginequick/quicknanobrowser/BrowserWindow.qml
-    \skipto onFeaturePermissionRequested
+    \skipto onPermissionRequested
     \printuntil }
 
-    We show a dialog where the user is asked to grant or deny access. The custom
+    We display a dialog where the user is asked to grant or deny access. The custom
     \c questionForFeature() JavaScript function generates a human-readable question about
     the request.
-    If users select \uicontrol Yes, we call the \l{WebEngineView::}{grantFeaturePermission()}
-    method with a third \c true parameter to grant the \c securityOrigin web site the permission
-    to access the \c feature.
-    If users select \uicontrol No, we call the same method but with the \c false parameter to
-    deny access:
+    If user selects \uicontrol Yes, we call the \l{webEnginePermission::grant}{grant()}
+    method, and if they select \uicontrol No we call \l{webEnginePermission::deny}{deny()}.
 
     \skipto id: sslDialog
     \skipto Dialog {
diff --git a/examples/webenginewidgets/maps/doc/src/maps.qdoc b/examples/webenginewidgets/maps/doc/src/maps.qdoc
index 0175f8b65..f9bd19bfc 100644
--- a/examples/webenginewidgets/maps/doc/src/maps.qdoc
+++ b/examples/webenginewidgets/maps/doc/src/maps.qdoc
@@ -48,10 +48,10 @@
     \printuntil setCentralWidget
 
     We then proceed to connect a lambda function to the \l
-    QWebEnginePage::featurePermissionRequested signal:
+    QWebEnginePage::permissionRequested signal:
 
     \skipto m_view->page()
-    \printuntil QWebEnginePage::Feature
+    \printuntil QWebEnginePermission permission
 
     This signal is emitted whenever a web page requests to make use of a certain
     feature or device, including not only location services but also audio
@@ -62,15 +62,14 @@
 
     Now comes the part where we actually ask the user for permission:
 
-    \printuntil securityOrigin
     \printuntil });
 
     Note that the question includes the host component of the web site's URI (\c
-    securityOrigin) to inform the user as to exactly which web site will be
+    permission.origin()) to inform the user as to exactly which web site will be
     receiving their location data.
 
-    We use the \l QWebEnginePage::setFeaturePermission method to communicate the
-    user's answer back to the web page.
+    We use the \l QWebEnginePermission::grant() and \l QWebEnginePermission::deny()
+    methods to communicate the user's answer back to the web page.
 
     Finally we ask the \l QWebEnginePage to load the web page that might want to
     use location services:
diff --git a/examples/webenginewidgets/maps/mainwindow.cpp b/examples/webenginewidgets/maps/mainwindow.cpp
index 0d2b49911..ca98ca263 100644
--- a/examples/webenginewidgets/maps/mainwindow.cpp
+++ b/examples/webenginewidgets/maps/mainwindow.cpp
@@ -13,25 +13,22 @@ MainWindow::MainWindow(QWidget *parent)
 
     QWebEnginePage *page = m_view->page();
 
-    connect(page, &QWebEnginePage::featurePermissionRequested,
-            [this, page](const QUrl &securityOrigin, QWebEnginePage::Feature feature) {
-        if (feature != QWebEnginePage::Geolocation)
+    connect(page, &QWebEnginePage::permissionRequested,
+            [this, page](QWebEnginePermission permission) {
+        if (permission.feature() != QWebEnginePermission::Geolocation)
             return;
 
         QMessageBox msgBox(this);
-        msgBox.setText(tr("%1 wants to know your location").arg(securityOrigin.host()));
+        msgBox.setText(tr("%1 wants to know your location").arg(permission.origin().host()));
         msgBox.setInformativeText(tr("Do you want to send your current location to this website?"));
         msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
         msgBox.setDefaultButton(QMessageBox::Yes);
 
-        if (msgBox.exec() == QMessageBox::Yes) {
-            page->setFeaturePermission(
-                securityOrigin, feature, QWebEnginePage::PermissionGrantedByUser);
-        } else {
-            page->setFeaturePermission(
-                securityOrigin, feature, QWebEnginePage::PermissionDeniedByUser);
-        }
+        if (msgBox.exec() == QMessageBox::Yes)
+            permission.grant();
+        else
+            permission.deny();
     });
 
-    page->load(QUrl(QStringLiteral("https://maps.google.com")));
+    page->load(QUrl(QStringLiteral("https://bing.com/maps")));
 }
diff --git a/examples/webenginewidgets/notifications/doc/src/notifications.qdoc b/examples/webenginewidgets/notifications/doc/src/notifications.qdoc
index f4fe1818f..bd0def910 100644
--- a/examples/webenginewidgets/notifications/doc/src/notifications.qdoc
+++ b/examples/webenginewidgets/notifications/doc/src/notifications.qdoc
@@ -45,11 +45,11 @@
 
     \section2 Requesting Feature Permissions
 
-    We then use the \l QWebEnginePage::featurePermissionRequested() call to
+    We then use the \l QWebEnginePage::permissionRequested() call to
     request the user's permission to show notifications on their device.
 
     \quotefromfile webenginewidgets/notifications/main.cpp
-    \skipto featurePermissionRequested
+    \skipto permissionRequested
     \printuntil });
 
     \section2 Handling New Notifications
diff --git a/examples/webenginewidgets/notifications/main.cpp b/examples/webenginewidgets/notifications/main.cpp
index c754aff3f..df9ebff73 100644
--- a/examples/webenginewidgets/notifications/main.cpp
+++ b/examples/webenginewidgets/notifications/main.cpp
@@ -33,11 +33,11 @@ int main(int argc, char *argv[])
     // set custom page to open all page's links for https scheme in system browser
     view.setPage(new WebEnginePage(&view));
 
-    QObject::connect(view.page(), &QWebEnginePage::featurePermissionRequested,
-                     [&] (const QUrl &origin, QWebEnginePage::Feature feature) {
-                         if (feature != QWebEnginePage::Notifications)
+    QObject::connect(view.page(), &QWebEnginePage::permissionRequested,
+                     [&] (QWebEnginePermission permission) {
+                         if (permission.feature() != QWebEnginePermission::Notifications)
                              return;
-                         view.page()->setFeaturePermission(origin, feature, QWebEnginePage::PermissionGrantedByUser);
+                         permission.grant();
                      });
 
     auto profile = view.page()->profile();
@@ -50,4 +50,3 @@ int main(int argc, char *argv[])
     view.setUrl(QStringLiteral("qrc:/index.html"));
     return app.exec();
 }
-
diff --git a/examples/webenginewidgets/push-notifications/main.cpp b/examples/webenginewidgets/push-notifications/main.cpp
index 18a862182..950ebfc9f 100644
--- a/examples/webenginewidgets/push-notifications/main.cpp
+++ b/examples/webenginewidgets/push-notifications/main.cpp
@@ -20,13 +20,12 @@ int main(int argc, char *argv[])
     QWebEngineView view(profile.data());
     auto popup = new NotificationPopup(&view);
 
-    QObject::connect(view.page(), &QWebEnginePage::featurePermissionRequested,
-                     [&](const QUrl &origin, QWebEnginePage::Feature feature) {
-                         if (feature != QWebEnginePage::Notifications)
+    QObject::connect(view.page(), &QWebEnginePage::permissionRequested,
+                     [&](QWebEnginePermission permission) {
+                         if (permission.feature() != QWebEnginePage::Notifications)
                              return;
 
-                         view.page()->setFeaturePermission(origin, feature,
-                                                           QWebEnginePage::PermissionGrantedByUser);
+                         permission.grant();
                      });
 
     profile->setPushServiceEnabled(true);
diff --git a/examples/webenginewidgets/simplebrowser/webview.cpp b/examples/webenginewidgets/simplebrowser/webview.cpp
index 08e044f70..3dcfc0c47 100644
--- a/examples/webenginewidgets/simplebrowser/webview.cpp
+++ b/examples/webenginewidgets/simplebrowser/webview.cpp
@@ -71,26 +71,26 @@ WebView::~WebView()
     m_imageAnimationGroup = nullptr;
 }
 
-inline QString questionForFeature(QWebEnginePage::Feature feature)
+inline QString questionForFeature(QWebEnginePermission::Feature feature)
 {
     switch (feature) {
-    case QWebEnginePage::Geolocation:
+    case QWebEnginePermission::Geolocation:
         return QObject::tr("Allow %1 to access your location information?");
-    case QWebEnginePage::MediaAudioCapture:
+    case QWebEnginePermission::MediaAudioCapture:
         return QObject::tr("Allow %1 to access your microphone?");
-    case QWebEnginePage::MediaVideoCapture:
+    case QWebEnginePermission::MediaVideoCapture:
         return QObject::tr("Allow %1 to access your webcam?");
-    case QWebEnginePage::MediaAudioVideoCapture:
+    case QWebEnginePermission::MediaAudioVideoCapture:
         return QObject::tr("Allow %1 to access your microphone and webcam?");
-    case QWebEnginePage::MouseLock:
+    case QWebEnginePermission::MouseLock:
         return QObject::tr("Allow %1 to lock your mouse cursor?");
-    case QWebEnginePage::DesktopVideoCapture:
+    case QWebEnginePermission::DesktopVideoCapture:
         return QObject::tr("Allow %1 to capture video of your desktop?");
-    case QWebEnginePage::DesktopAudioVideoCapture:
+    case QWebEnginePermission::DesktopAudioVideoCapture:
         return QObject::tr("Allow %1 to capture audio and video of your desktop?");
-    case QWebEnginePage::Notifications:
+    case QWebEnginePermission::Notifications:
         return QObject::tr("Allow %1 to show notification on your desktop?");
-    case QWebEnginePage::ClipboardReadWrite:
+    case QWebEnginePermission::ClipboardReadWrite:
         return QObject::tr("Allow %1 to read from and write to the clipboard?");
     }
     return QString();
@@ -103,8 +103,8 @@ void WebView::setPage(WebPage *page)
                    &WebView::handleCertificateError);
         disconnect(oldPage, &QWebEnginePage::authenticationRequired, this,
                    &WebView::handleAuthenticationRequired);
-        disconnect(oldPage, &QWebEnginePage::featurePermissionRequested, this,
-                   &WebView::handleFeaturePermissionRequested);
+        disconnect(oldPage, &QWebEnginePage::permissionRequested, this,
+                   &WebView::handlePermissionRequested);
         disconnect(oldPage, &QWebEnginePage::proxyAuthenticationRequired, this,
                    &WebView::handleProxyAuthenticationRequired);
         disconnect(oldPage, &QWebEnginePage::registerProtocolHandlerRequested, this,
@@ -124,8 +124,8 @@ void WebView::setPage(WebPage *page)
     connect(page, &WebPage::createCertificateErrorDialog, this, &WebView::handleCertificateError);
     connect(page, &QWebEnginePage::authenticationRequired, this,
             &WebView::handleAuthenticationRequired);
-    connect(page, &QWebEnginePage::featurePermissionRequested, this,
-            &WebView::handleFeaturePermissionRequested);
+    connect(page, &QWebEnginePage::permissionRequested, this,
+            &WebView::handlePermissionRequested);
     connect(page, &QWebEnginePage::proxyAuthenticationRequired, this,
             &WebView::handleProxyAuthenticationRequired);
     connect(page, &QWebEnginePage::registerProtocolHandlerRequested, this,
@@ -309,17 +309,14 @@ void WebView::handleAuthenticationRequired(const QUrl &requestUrl, QAuthenticato
     }
 }
 
-void WebView::handleFeaturePermissionRequested(const QUrl &securityOrigin,
-                                               QWebEnginePage::Feature feature)
+void WebView::handlePermissionRequested(QWebEnginePermission permission)
 {
     QString title = tr("Permission Request");
-    QString question = questionForFeature(feature).arg(securityOrigin.host());
+    QString question = questionForFeature(permission.feature()).arg(permission.origin().host());
     if (!question.isEmpty() && QMessageBox::question(window(), title, question) == QMessageBox::Yes)
-        page()->setFeaturePermission(securityOrigin, feature,
-                                     QWebEnginePage::PermissionGrantedByUser);
+        permission.grant();
     else
-        page()->setFeaturePermission(securityOrigin, feature,
-                                     QWebEnginePage::PermissionDeniedByUser);
+        permission.deny();
 }
 
 void WebView::handleProxyAuthenticationRequired(const QUrl &, QAuthenticator *auth,
diff --git a/examples/webenginewidgets/simplebrowser/webview.h b/examples/webenginewidgets/simplebrowser/webview.h
index c7e7f394c..d652fbdc9 100644
--- a/examples/webenginewidgets/simplebrowser/webview.h
+++ b/examples/webenginewidgets/simplebrowser/webview.h
@@ -14,6 +14,7 @@
 #include <QWebEngineRegisterProtocolHandlerRequest>
 #include <QWebEngineWebAuthUxRequest>
 #include <QWebEngineSettings>
+#include <QWebEnginePermission>
 #include <QActionGroup>
 
 class WebPage;
@@ -43,8 +44,7 @@ signals:
 private slots:
     void handleCertificateError(QWebEngineCertificateError error);
     void handleAuthenticationRequired(const QUrl &requestUrl, QAuthenticator *auth);
-    void handleFeaturePermissionRequested(const QUrl &securityOrigin,
-                                          QWebEnginePage::Feature feature);
+    void handlePermissionRequested(QWebEnginePermission permission);
     void handleProxyAuthenticationRequired(const QUrl &requestUrl, QAuthenticator *auth,
                                            const QString &proxyHost);
     void handleRegisterProtocolHandlerRequested(QWebEngineRegisterProtocolHandlerRequest request);
diff --git a/src/core/api/CMakeLists.txt b/src/core/api/CMakeLists.txt
index c06f5e4ce..e14d0cd5c 100644
--- a/src/core/api/CMakeLists.txt
+++ b/src/core/api/CMakeLists.txt
@@ -29,6 +29,7 @@ qt_internal_add_module(WebEngineCore
         qwebenginenewwindowrequest.cpp qwebenginenewwindowrequest.h qwebenginenewwindowrequest_p.h
         qwebenginenotification.cpp qwebenginenotification.h
         qwebenginepage.cpp qwebenginepage.h qwebenginepage_p.h
+        qwebenginepermission.cpp qwebenginepermission.h qwebenginepermission_p.h
         qwebengineprofile.cpp qwebengineprofile.h qwebengineprofile_p.h
         qwebenginequotarequest.cpp qwebenginequotarequest.h
         qwebengineregisterprotocolhandlerrequest.cpp qwebengineregisterprotocolhandlerrequest.h
diff --git a/src/core/api/qwebenginepage.cpp b/src/core/api/qwebenginepage.cpp
index d7ab70305..f0260fd0d 100644
--- a/src/core/api/qwebenginepage.cpp
+++ b/src/core/api/qwebenginepage.cpp
@@ -24,6 +24,7 @@
 #include "qwebenginescriptcollection_p.h"
 #include "qwebenginesettings.h"
 #include "qwebenginewebauthuxrequest.h"
+#include "qwebenginepermission_p.h"
 
 #include "authentication_dialog_controller.h"
 #include "autofill_popup_controller.h"
@@ -589,50 +590,121 @@ void QWebEnginePagePrivate::showColorDialog(QSharedPointer<ColorChooserControlle
 void QWebEnginePagePrivate::runMediaAccessPermissionRequest(const QUrl &securityOrigin, WebContentsAdapterClient::MediaRequestFlags requestFlags)
 {
     Q_Q(QWebEnginePage);
-    QWebEnginePage::Feature feature;
-    if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture) &&
-        requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
-        feature = QWebEnginePage::MediaAudioVideoCapture;
+    QWebEnginePermission::Feature feature;
+
+    if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture)
+            && requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
+        feature = QWebEnginePermission::MediaAudioVideoCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture))
+        feature = QWebEnginePermission::MediaAudioCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
+        feature = QWebEnginePermission::MediaVideoCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopAudioCapture)
+            && requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
+        feature = QWebEnginePermission::DesktopAudioVideoCapture;
+    else // if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
+        feature = QWebEnginePermission::DesktopVideoCapture;
+
+    Q_EMIT q->permissionRequested(createFeaturePermissionObject(securityOrigin, feature));
+
+#if QT_DEPRECATED_SINCE(6, 8)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    QWebEnginePage::Feature deprecatedFeature;
+
+    if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture)
+            && requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
+        deprecatedFeature = QWebEnginePage::MediaAudioVideoCapture;
     else if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture))
-        feature = QWebEnginePage::MediaAudioCapture;
+        deprecatedFeature = QWebEnginePage::MediaAudioCapture;
     else if (requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
-        feature = QWebEnginePage::MediaVideoCapture;
-    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopAudioCapture) &&
-             requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
-        feature = QWebEnginePage::DesktopAudioVideoCapture;
+        deprecatedFeature = QWebEnginePage::MediaVideoCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopAudioCapture)
+            && requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
+        deprecatedFeature = QWebEnginePage::DesktopAudioVideoCapture;
     else // if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
-        feature = QWebEnginePage::DesktopVideoCapture;
-    Q_EMIT q->featurePermissionRequested(securityOrigin, feature);
+        deprecatedFeature = QWebEnginePage::DesktopVideoCapture;
+
+    Q_EMIT q->featurePermissionRequested(securityOrigin, deprecatedFeature);
+    QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 }
 
-static QWebEnginePage::Feature toFeature(QtWebEngineCore::ProfileAdapter::PermissionType type)
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+static QWebEnginePage::Feature toDeprecatedFeature(QWebEnginePermission::Feature feature)
 {
-    switch (type) {
-    case QtWebEngineCore::ProfileAdapter::NotificationPermission:
+    switch (feature) {
+    case QWebEnginePermission::Feature::Notifications:
         return QWebEnginePage::Notifications;
-    case QtWebEngineCore::ProfileAdapter::GeolocationPermission:
+    case QWebEnginePermission::Feature::Geolocation:
         return QWebEnginePage::Geolocation;
-    case QtWebEngineCore::ProfileAdapter::ClipboardReadWrite:
+    case QWebEnginePermission::Feature::ClipboardReadWrite:
         return QWebEnginePage::ClipboardReadWrite;
-    case QtWebEngineCore::ProfileAdapter::LocalFontsPermission:
+    case QWebEnginePermission::Feature::LocalFontsAccess:
         return QWebEnginePage::LocalFontsAccess;
-    default:
+    case QWebEnginePermission::Feature::MediaAudioCapture:
+        return QWebEnginePage::MediaAudioCapture;
+    case QWebEnginePermission::Feature::MediaVideoCapture:
+        return QWebEnginePage::MediaVideoCapture;
+    case QWebEnginePermission::Feature::MediaAudioVideoCapture:
+        return QWebEnginePage::MediaAudioVideoCapture;
+    case QWebEnginePermission::Feature::DesktopVideoCapture:
+        return QWebEnginePage::DesktopVideoCapture;
+    case QWebEnginePermission::Feature::DesktopAudioVideoCapture:
+        return QWebEnginePage::DesktopAudioVideoCapture;
+    case QWebEnginePermission::Feature::MouseLock:
+        return QWebEnginePage::MouseLock;
+    case QWebEnginePermission::Feature::Unsupported:
         break;
     }
+
     Q_UNREACHABLE();
     return QWebEnginePage::Feature(-1);
 }
+QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 
-void QWebEnginePagePrivate::runFeaturePermissionRequest(QtWebEngineCore::ProfileAdapter::PermissionType permission, const QUrl &securityOrigin)
+void QWebEnginePagePrivate::runFeaturePermissionRequest(QWebEnginePermission::Feature feature, const QUrl &securityOrigin)
 {
     Q_Q(QWebEnginePage);
-    Q_EMIT q->featurePermissionRequested(securityOrigin, toFeature(permission));
+    switch (feature) {
+    case QWebEnginePermission::Notifications:
+    case QWebEnginePermission::Geolocation:
+    case QWebEnginePermission::ClipboardReadWrite:
+    case QWebEnginePermission::LocalFontsAccess:
+        Q_EMIT q->permissionRequested(createFeaturePermissionObject(securityOrigin, feature));
+#if QT_DEPRECATED_SINCE(6, 8)
+        QT_WARNING_PUSH
+        QT_WARNING_DISABLE_DEPRECATED
+        Q_EMIT q->featurePermissionRequested(securityOrigin, toDeprecatedFeature(feature));
+        QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
+        return;
+    case QWebEnginePermission::MouseLock:
+    case QWebEnginePermission::MediaAudioCapture:
+    case QWebEnginePermission::MediaVideoCapture:
+    case QWebEnginePermission::MediaAudioVideoCapture:
+    case QWebEnginePermission::DesktopAudioVideoCapture:
+    case QWebEnginePermission::DesktopVideoCapture:
+    case QWebEnginePermission::Unsupported:
+        Q_UNREACHABLE();
+        return;
+    }
 }
 
 void QWebEnginePagePrivate::runMouseLockPermissionRequest(const QUrl &securityOrigin)
 {
     Q_Q(QWebEnginePage);
+    Q_EMIT q->permissionRequested(createFeaturePermissionObject(securityOrigin, QWebEnginePermission::MouseLock));
+
+#if QT_DEPRECATED_SINCE(6, 8)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     Q_EMIT q->featurePermissionRequested(securityOrigin, QWebEnginePage::MouseLock);
+    QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 }
 
 void QWebEnginePagePrivate::runRegisterProtocolHandlerRequest(QWebEngineRegisterProtocolHandlerRequest request)
@@ -821,6 +893,12 @@ void QWebEnginePagePrivate::showWebAuthDialog(QWebEngineWebAuthUxRequest *reques
     Q_EMIT q->webAuthUxRequested(request);
 }
 
+QWebEnginePermission QWebEnginePagePrivate::createFeaturePermissionObject(const QUrl &securityOrigin, QWebEnginePermission::Feature feature)
+{
+    auto *returnPrivate = new QWebEnginePermissionPrivate{securityOrigin, feature, adapter, profileAdapter()};
+    return QWebEnginePermission(returnPrivate);
+}
+
 QWebEnginePage::QWebEnginePage(QObject* parent)
     : QObject(parent)
     , d_ptr(new QWebEnginePagePrivate())
@@ -1773,104 +1851,64 @@ void QWebEnginePage::setUrlRequestInterceptor(QWebEngineUrlRequestInterceptor *i
     d->adapter->setRequestInterceptor(interceptor);
 }
 
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
 void QWebEnginePage::setFeaturePermission(const QUrl &securityOrigin, QWebEnginePage::Feature feature, QWebEnginePage::PermissionPolicy policy)
 {
     Q_D(QWebEnginePage);
-    if (policy == PermissionUnknown) {
-        switch (feature) {
-        case MediaAudioVideoCapture:
-        case MediaAudioCapture:
-        case MediaVideoCapture:
-        case DesktopAudioVideoCapture:
-        case DesktopVideoCapture:
-        case MouseLock:
-            break;
-        case Geolocation:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::GeolocationPermission, ProfileAdapter::AskPermission);
-            break;
-        case Notifications:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::NotificationPermission, ProfileAdapter::AskPermission);
-            break;
-        case ClipboardReadWrite:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::ClipboardReadWrite,
-                                               ProfileAdapter::AskPermission);
-            break;
-        case LocalFontsAccess:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::LocalFontsPermission, ProfileAdapter::AskPermission);
-            break;
-        }
-        return;
+    QWebEnginePermission::Feature f;
+    QWebEnginePermission::State s;
+
+    switch (feature) {
+    case QWebEnginePage::Notifications:
+        f = QWebEnginePermission::Notifications;
+        break;
+    case QWebEnginePage::Geolocation:
+        f = QWebEnginePermission::Geolocation;
+        break;
+    case QWebEnginePage::MediaAudioCapture:
+        f = QWebEnginePermission::MediaAudioCapture;
+        break;
+    case QWebEnginePage::MediaVideoCapture:
+        f = QWebEnginePermission::MediaVideoCapture;
+        break;
+    case QWebEnginePage::MediaAudioVideoCapture:
+        f = QWebEnginePermission::MediaAudioVideoCapture;
+        break;
+    case QWebEnginePage::MouseLock:
+        f = QWebEnginePermission::MouseLock;
+        break;
+    case QWebEnginePage::DesktopVideoCapture:
+        f = QWebEnginePermission::DesktopVideoCapture;
+        break;
+    case QWebEnginePage::DesktopAudioVideoCapture:
+        f = QWebEnginePermission::DesktopAudioVideoCapture;
+        break;
+    case QWebEnginePage::ClipboardReadWrite:
+        f = QWebEnginePermission::ClipboardReadWrite;
+        break;
+    case QWebEnginePage::LocalFontsAccess:
+        f = QWebEnginePermission::LocalFontsAccess;
+        break;
     }
 
-    const WebContentsAdapterClient::MediaRequestFlags audioVideoCaptureFlags(
-        WebContentsAdapterClient::MediaVideoCapture |
-        WebContentsAdapterClient::MediaAudioCapture);
-    const WebContentsAdapterClient::MediaRequestFlags desktopAudioVideoCaptureFlags(
-        WebContentsAdapterClient::MediaDesktopVideoCapture |
-        WebContentsAdapterClient::MediaDesktopAudioCapture);
-
-    if (policy == PermissionGrantedByUser) {
-        switch (feature) {
-        case MediaAudioVideoCapture:
-            d->adapter->grantMediaAccessPermission(securityOrigin, audioVideoCaptureFlags);
-            break;
-        case MediaAudioCapture:
-            d->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaAudioCapture);
-            break;
-        case MediaVideoCapture:
-            d->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaVideoCapture);
-            break;
-        case DesktopAudioVideoCapture:
-            d->adapter->grantMediaAccessPermission(securityOrigin, desktopAudioVideoCaptureFlags);
-            break;
-        case DesktopVideoCapture:
-            d->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaDesktopVideoCapture);
-            break;
-        case MouseLock:
-            d->adapter->grantMouseLockPermission(securityOrigin, true);
-            break;
-        case Geolocation:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::GeolocationPermission, ProfileAdapter::AllowedPermission);
-            break;
-        case Notifications:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::NotificationPermission, ProfileAdapter::AllowedPermission);
-            break;
-        case ClipboardReadWrite:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::ClipboardReadWrite,
-                                               ProfileAdapter::AllowedPermission);
-            break;
-        case LocalFontsAccess:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::LocalFontsPermission, ProfileAdapter::AllowedPermission);
-            break;
-        }
-    } else { // if (policy == PermissionDeniedByUser)
-        switch (feature) {
-        case MediaAudioVideoCapture:
-        case MediaAudioCapture:
-        case MediaVideoCapture:
-        case DesktopAudioVideoCapture:
-        case DesktopVideoCapture:
-            d->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaNone);
-            break;
-        case Geolocation:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::GeolocationPermission, ProfileAdapter::DeniedPermission);
-            break;
-        case MouseLock:
-            d->adapter->grantMouseLockPermission(securityOrigin, false);
-            break;
-        case Notifications:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::NotificationPermission, ProfileAdapter::DeniedPermission);
-            break;
-        case ClipboardReadWrite:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::ClipboardReadWrite,
-                                               ProfileAdapter::DeniedPermission);
-            break;
-        case LocalFontsAccess:
-            d->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::LocalFontsPermission, ProfileAdapter::DeniedPermission);
-            break;
-        }
+    switch (policy) {
+    case QWebEnginePage::PermissionUnknown:
+        s = QWebEnginePermission::Ask;
+        break;
+    case QWebEnginePage::PermissionDeniedByUser:
+        s = QWebEnginePermission::Denied;
+        break;
+    case QWebEnginePage::PermissionGrantedByUser:
+        s = QWebEnginePermission::Granted;
+        break;
     }
+
+    d->adapter->setFeaturePermission(securityOrigin, f, s);
 }
+QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 
 static inline QWebEnginePage::FileSelectionMode toPublic(FilePickerController::FileChooserMode mode)
 {
diff --git a/src/core/api/qwebenginepage.h b/src/core/api/qwebenginepage.h
index 59eed2b9b..cca7c55e7 100644
--- a/src/core/api/qwebenginepage.h
+++ b/src/core/api/qwebenginepage.h
@@ -9,6 +9,7 @@
 #include <QtWebEngineCore/qwebenginedownloadrequest.h>
 #include <QtWebEngineCore/qwebenginequotarequest.h>
 #include <QtWebEngineCore/qwebengineframe.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 
 #include <QtCore/qobject.h>
 #include <QtCore/qurl.h>
@@ -147,12 +148,19 @@ public:
     };
     Q_ENUM(WebWindowType)
 
-    enum PermissionPolicy {
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
+    enum QT_DEPRECATED_VERSION_X_6_8(
+        "QWebEnginePage::PermissionPolicy has been deprecated. "
+        "The updated permissions API uses QWebEnginePermission::State.")
+    PermissionPolicy {
         PermissionUnknown,
         PermissionGrantedByUser,
         PermissionDeniedByUser
     };
     Q_ENUM(PermissionPolicy)
+QT_WARNING_POP
+#endif
 
     // must match WebContentsAdapterClient::NavigationType
     enum NavigationType {
@@ -166,7 +174,12 @@ public:
     };
     Q_ENUM(NavigationType)
 
-    enum Feature {
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
+    enum QT_DEPRECATED_VERSION_X_6_8(
+        "QWebEnginePage::Feature has been deprecated. "
+        "The updated permissions API uses QWebEnginePermission::Feature.")
+    Feature {
         Notifications = 0,
         Geolocation = 1,
         MediaAudioCapture = 2,
@@ -179,6 +192,8 @@ public:
         LocalFontsAccess,
     };
     Q_ENUM(Feature)
+QT_WARNING_POP
+#endif
 
     // Ex-QWebFrame enum
 
@@ -236,7 +251,12 @@ public:
 
     void findText(const QString &subString, FindFlags options = {}, const std::function<void(const QWebEngineFindTextResult &)> &resultCallback = std::function<void(const QWebEngineFindTextResult &)>());
 
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
+    QT_DEPRECATED_VERSION_X_6_8("Setting permissions through QWebEnginePage has been deprecated. Please use QWebEnginePermission instead.")
     void setFeaturePermission(const QUrl &securityOrigin, Feature feature, PermissionPolicy policy);
+QT_WARNING_POP
+#endif
 
     bool isLoading() const;
 
@@ -319,9 +339,23 @@ Q_SIGNALS:
     void geometryChangeRequested(const QRect &geom);
     void windowCloseRequested();
 
+#if QT_DEPRECATED_SINCE(6, 8)
+#if !defined(Q_MOC_RUN)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+#endif // !defined(Q_MOC_RUN)
+    QT_MOC_COMPAT QT_DEPRECATED_VERSION_X_6_8("The signal has been deprecated; please use permissionRequested instead.")
     void featurePermissionRequested(const QUrl &securityOrigin, QWebEnginePage::Feature feature);
+    QT_MOC_COMPAT QT_DEPRECATED_VERSION_X_6_8("The signal has been deprecated, and no longer functions.")
     void featurePermissionRequestCanceled(const QUrl &securityOrigin, QWebEnginePage::Feature feature);
+#if !defined(Q_MOC_RUN)
+QT_WARNING_POP
+#endif // !defined(Q_MOC_RUN)
+#endif // QT_DEPRECATED_SINCE(6, 8)
+
     void fullScreenRequested(QWebEngineFullScreenRequest fullScreenRequest);
+    void permissionRequested(QWebEnginePermission permissionRequest);
+
 #if QT_DEPRECATED_SINCE(6, 5)
     QT_DEPRECATED_VERSION_X_6_5("Requesting host quota is no longer supported.")
     void quotaRequested(QWebEngineQuotaRequest quotaRequest);
diff --git a/src/core/api/qwebenginepage_p.h b/src/core/api/qwebenginepage_p.h
index 6f536f3a6..77d3dd8c2 100644
--- a/src/core/api/qwebenginepage_p.h
+++ b/src/core/api/qwebenginepage_p.h
@@ -148,7 +148,7 @@ public:
             QSharedPointer<QtWebEngineCore::AuthenticationDialogController>) override;
     void releaseProfile() override;
     void runMediaAccessPermissionRequest(const QUrl &securityOrigin, MediaRequestFlags requestFlags) override;
-    void runFeaturePermissionRequest(QtWebEngineCore::ProfileAdapter::PermissionType permission, const QUrl &securityOrigin) override;
+    void runFeaturePermissionRequest(QWebEnginePermission::Feature feature, const QUrl &securityOrigin) override;
     void runMouseLockPermissionRequest(const QUrl &securityOrigin) override;
     void runRegisterProtocolHandlerRequest(QWebEngineRegisterProtocolHandlerRequest) override;
     void runFileSystemAccessRequest(QWebEngineFileSystemAccessRequest) override;
@@ -180,6 +180,7 @@ public:
                            const QRect &bounds, bool autoselectFirstSuggestion) override;
     void hideAutofillPopup() override;
     void showWebAuthDialog(QWebEngineWebAuthUxRequest *controller) override;
+    QWebEnginePermission createFeaturePermissionObject(const QUrl &securityOrigin, QWebEnginePermission::Feature feature) override;
 
     QtWebEngineCore::ProfileAdapter *profileAdapter() override;
     QtWebEngineCore::WebContentsAdapter *webContentsAdapter() override;
diff --git a/src/core/api/qwebenginepermission.cpp b/src/core/api/qwebenginepermission.cpp
new file mode 100644
index 000000000..d898b8c7e
--- /dev/null
+++ b/src/core/api/qwebenginepermission.cpp
@@ -0,0 +1,307 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qwebenginepermission.h"
+#include "qwebenginepermission_p.h"
+#include "web_contents_adapter.h"
+#include "profile_adapter.h"
+
+QT_BEGIN_NAMESPACE
+
+QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QWebEnginePermissionPrivate)
+
+QWebEnginePermissionPrivate::QWebEnginePermissionPrivate()
+    : QSharedData()
+    , feature(QWebEnginePermission::Unsupported)
+{
+}
+
+QWebEnginePermissionPrivate::QWebEnginePermissionPrivate(const QUrl &origin_, QWebEnginePermission::Feature feature_,
+        QSharedPointer<QtWebEngineCore::WebContentsAdapter> webContentsAdapter_, QtWebEngineCore::ProfileAdapter *profileAdapter_)
+    : QSharedData()
+    , origin(origin_)
+    , feature(feature_)
+    , webContentsAdapter(webContentsAdapter_)
+    , profileAdapter(profileAdapter_)
+{
+}
+
+/*!
+    \class QWebEnginePermission
+    \inmodule QtWebEngineCore
+    \since 6.8
+    \brief A QWebEnginePermission is an object used to access and modify the state of a single permission that's been
+    granted or denied to a specific origin URL.
+
+    The typical usage pattern is as follows:
+    \list 1
+        \li A website requests a specific feature, triggering the QWebEnginePage::permissionRequested() signal;
+        \li The signal handler triggers a prompt asking the user whether they want to grant the permission;
+        \li When the user has made their decision, the application calls \l grant() or \l deny();
+    \endlist
+
+    Alternatively, an application interested in modifying already granted permissions may use QWebEngineProfile::listPermissions()
+    to get a list of existing permissions associated with a profile, or QWebEngineProfile::getPermission() to get
+    a QWebEnginePermission object for a specific permission.
+
+    The \l origin() property can be used to query which origin the QWebEnginePermission is associated with, while the
+    \l feature() property describes the associated feature. A website origin is the combination of its scheme, hostname,
+    and port. Permissions are granted on a per-origin basis; thus, if the web page \c{https://www.example.com:12345/some/page.html}
+    requests a permission, it will be granted to the origin \c{https://www.example.com:12345/}.
+
+    \l QWebEnginePermission::Feature describes all the feature types Qt WebEngine supports. Some Features are transient;
+    in practice, this means that they are never remembered, and a website that uses them will trigger a permission
+    prompt every time the Feature is needed. Transient Features cannot be granted in advance.
+
+    The usability lifetime of a QWebEnginePermission is tied either to its associated QWebEnginePage
+    (for transient feature types), or QWebEngineProfile (for permanent feature types). A transient permission is one which
+    needs to be explicitly granted or denied every time it's needed (e.g. webcam/screen sharing permission), whereas a permanent
+    one might be stored inside the current profile, depending on the value of QWebEngineProfile::persistentPermissionsPolicy().
+    You can check whether a QWebEnginePermission is in a valid state using its \l isValid() property. For invalid objects, calls to \l grant(),
+    \l deny(), or \l reset() will do nothing, while calls to \l state() will always return QWebEnginePermission::Invalid.
+
+    \sa QWebEnginePage::permissionRequested(), QWebEngineProfile::getPermission(), QWebEngineProfile::listPermissions()
+*/
+
+/*! \fn QWebEnginePermission::QWebEnginePermission()
+    \internal
+*/
+
+/*! \internal */
+QWebEnginePermission::QWebEnginePermission()
+    : d_ptr(new QWebEnginePermissionPrivate())
+{
+}
+
+/*! \internal */
+QWebEnginePermission::QWebEnginePermission(QWebEnginePermissionPrivate *pvt)
+    : d_ptr(pvt)
+{
+}
+
+QWebEnginePermission::QWebEnginePermission(const QWebEnginePermission &other)
+    : d_ptr(new QWebEnginePermissionPrivate(*other.d_ptr))
+{
+}
+
+QWebEnginePermission::~QWebEnginePermission() = default;
+
+QWebEnginePermission &QWebEnginePermission::operator=(const QWebEnginePermission &other)
+{
+    if (this == &other)
+        return *this;
+
+    d_ptr.reset(new QWebEnginePermissionPrivate(*other.d_ptr));
+    return *this;
+}
+
+bool QWebEnginePermission::comparesEqual(const QWebEnginePermission &other) const
+{
+    if (this == &other)
+        return true;
+
+    if (d_ptr->feature != other.d_ptr->feature || d_ptr->origin != other.d_ptr->origin)
+        return false;
+
+    if (isTransient(d_ptr->feature)) {
+        if (d_ptr->webContentsAdapter != other.d_ptr->webContentsAdapter)
+            return false;
+    } else {
+        QtWebEngineCore::ProfileAdapter *thisProfile = d_ptr->webContentsAdapter
+            ? d_ptr->webContentsAdapter.toStrongRef()->profileAdapter()
+            : d_ptr->profileAdapter.get();
+        QtWebEngineCore::ProfileAdapter *otherProfile = d_ptr->webContentsAdapter
+            ? other.d_ptr->webContentsAdapter.toStrongRef()->profileAdapter()
+            : other.d_ptr->profileAdapter.get();
+
+        if (thisProfile != otherProfile)
+            return false;
+    }
+
+    return true;
+}
+
+/*!
+    \property QWebEnginePermission::origin
+    \brief The URL of the permission's associated origin.
+
+    A website origin is the combination of its scheme, hostname, and port. Permissions are granted on a
+    per-origin basis; thus, if the web page \c{https://www.example.com:12345/some/page.html}
+    requests a permission, it will be granted to the origin \c{https://www.example.com:12345/}.
+*/
+const QUrl QWebEnginePermission::origin() const
+{
+    return d_ptr->origin;
+}
+
+/*!
+    \enum QWebEnginePermission::Feature
+
+    This enum type holds the type of the requested feature:
+
+    \value MediaAudioCapture Access to a microphone, or another audio source. This feature is transient.
+    \value MediaVideoCapture Access to a webcam, or another video source. This feature is transient.
+    \value MediaAudioVideoCapture Combination of \l MediaAudioCapture and \l MediaVideoCapture. This feature is transient.
+    \value DesktopVideoCapture Access to the contents of the user's screen. This feature is transient.
+    \value DesktopAudioVideoCapture Access to the contents of the user's screen, and application audio. This feature is transient.
+    \value MouseLock Locks the pointer inside an element on the web page. This feature is transient.
+    \value Notifications Allows the website to send notifications to the user.
+    \value Geolocation Access to the user's physical location.
+    \value ClipboardReadWrite Access to the user's clipboard.
+    \value LocalFontsAccess Access to the fonts installed on the user's machine. Only available on desktops.
+    \value Unsupported An unsupported feature type.
+
+    \note Transient feature types are ones that will never be remembered by the underlying storage, and will trigger
+    a permission request every time a website tries to use them. Transient Features can only be denied/granted
+    as they're needed; any attempts to pre-grant a transient Feature will fail.
+*/
+
+/*!
+    \property QWebEnginePermission::feature
+    \brief The feature type associated with this permission.
+*/
+QWebEnginePermission::Feature QWebEnginePermission::feature() const
+{
+    return d_ptr->feature;
+}
+
+/*!
+    \enum QWebEnginePermission::State
+
+    This enum type holds the current state of the requested feature:
+
+    \value Invalid Object is in an invalid state, and any attempts to modify the described permission will fail.
+    \value Ask Either the permission has not been requested before, or the feature() is transient.
+    \value Granted Permission has already been granted.
+    \value Denied Permission has already been denied.
+*/
+
+/*!
+    \property QWebEnginePermission::state
+    \brief The current state of the permission.
+
+    If a permission for the specified \l feature() and \l origin() has already been granted or denied,
+    the return value is QWebEnginePermission::Granted, or QWebEnginePermission::Denied, respectively.
+    When this is the first time the permission is requested, or if the \l feature() is transient,
+    the return value is QWebEnginePermission::Ask. If the object is in an invalid state, the returned
+    value is QWebEnginePermission::Invalid.
+
+    \sa isValid(), isTransient()
+*/
+QWebEnginePermission::State QWebEnginePermission::state() const
+{
+    if (!isValid())
+        return Invalid;
+    if (d_ptr->webContentsAdapter)
+        return d_ptr->webContentsAdapter.toStrongRef()->getPermissionState(origin(), feature());
+    if (d_ptr->profileAdapter)
+        return d_ptr->profileAdapter->getPermissionState(origin(), feature());
+    Q_UNREACHABLE();
+    return Ask;
+}
+
+/*!
+    \property QWebEnginePermission::isValid
+    \brief Indicates whether attempts to change the permission's state will be successful.
+
+    An invalid QWebEnginePermission is either:
+    \list
+        \li One whose \l feature() is unsupported;
+        \li One whose \l feature() is transient, and the associated page/view has been destroyed;
+        \li One whose \l feature() is permanent, but the associated profile has been destroyed;
+        \li One whose \l origin() is invalid.
+    \endlist
+
+    \sa isTransient()
+*/
+bool QWebEnginePermission::isValid() const
+{
+    if (feature() == Unsupported)
+        return false;
+    if (isTransient(feature()) && !d_ptr->webContentsAdapter)
+        return false;
+    if (!d_ptr->profileAdapter)
+        return false;
+    if (!d_ptr->origin.isValid())
+        return false;
+    return true;
+}
+
+/*!
+    Allows the associated origin to access the requested feature. Does nothing when \l isValid() evaluates to false.
+
+    \sa deny(), reset(), isValid()
+*/
+void QWebEnginePermission::grant() const
+{
+    if (!isValid())
+        return;
+    if (d_ptr->webContentsAdapter)
+        d_ptr->webContentsAdapter.toStrongRef()->setFeaturePermission(origin(), feature(), Granted);
+    else if (d_ptr->profileAdapter)
+        d_ptr->profileAdapter->setPermission(origin(), feature(), Granted);
+}
+
+/*!
+    Stops the associated origin from accessing the requested feature. Does nothing when \l isValid() evaluates to false.
+
+    \sa grant(), reset(), isValid()
+*/
+void QWebEnginePermission::deny() const
+{
+    if (!isValid())
+        return;
+    if (d_ptr->webContentsAdapter)
+        d_ptr->webContentsAdapter.toStrongRef()->setFeaturePermission(origin(), feature(), Denied);
+    else if (d_ptr->profileAdapter)
+        d_ptr->profileAdapter->setPermission(origin(), feature(), Denied);
+}
+
+/*!
+    Removes the permission from the profile's underlying storage. By default, permissions are stored on disk (except for
+    off-the-record profiles, where permissions are stored in memory and are destroyed with the profile).
+    This means that an already granted/denied permission will not be requested twice, but will get automatically
+    granted/denied every subsequent time a website requests it. Calling reset() allows the query to be asked
+    again the next time the website requests it.
+
+    Does nothing when \l isValid() evaluates to false.
+
+    \sa grant(), deny(), isValid(), QWebEngineProfile::persistentPermissionsPolicy()
+*/
+void QWebEnginePermission::reset() const
+{
+    if (!isValid())
+        return;
+    if (d_ptr->webContentsAdapter)
+        d_ptr->webContentsAdapter.toStrongRef()->setFeaturePermission(origin(), feature(), Ask);
+    else if (d_ptr->profileAdapter)
+        d_ptr->profileAdapter->setPermission(origin(), feature(), Ask);
+}
+
+/*!
+    Returns whether \a feature is transient, meaning that a permission will be requested
+    every time the associated functionality is used by a web page.
+*/
+bool QWebEnginePermission::isTransient(QWebEnginePermission::Feature feature)
+{
+    switch (feature) {
+    case QWebEnginePermission::MediaAudioCapture:
+    case QWebEnginePermission::MediaVideoCapture:
+    case QWebEnginePermission::MediaAudioVideoCapture:
+    case QWebEnginePermission::DesktopVideoCapture:
+    case QWebEnginePermission::DesktopAudioVideoCapture:
+    case QWebEnginePermission::MouseLock:
+        return true;
+    case QWebEnginePermission::Notifications:
+    case QWebEnginePermission::Geolocation:
+    case QWebEnginePermission::ClipboardReadWrite:
+    case QWebEnginePermission::LocalFontsAccess:
+        return false;
+    case QWebEnginePermission::Unsupported:
+        return false;
+    }
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qwebenginepermission.cpp"
diff --git a/src/core/api/qwebenginepermission.h b/src/core/api/qwebenginepermission.h
new file mode 100644
index 000000000..09db8ce36
--- /dev/null
+++ b/src/core/api/qwebenginepermission.h
@@ -0,0 +1,90 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QWEBENGINEPERMISSION_H
+#define QWEBENGINEPERMISSION_H
+
+#include <QtWebEngineCore/qtwebenginecoreglobal.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qshareddata.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QWebEnginePermissionPrivate;
+QT_DECLARE_QESDP_SPECIALIZATION_DTOR_WITH_EXPORT(QWebEnginePermissionPrivate,
+                                                 Q_WEBENGINECORE_EXPORT)
+
+class QWebEnginePermission
+{
+    Q_GADGET_EXPORT(Q_WEBENGINECORE_EXPORT)
+    Q_PROPERTY(QUrl origin READ origin CONSTANT FINAL)
+    Q_PROPERTY(Feature feature READ feature CONSTANT FINAL)
+    Q_PROPERTY(State state READ state CONSTANT FINAL)
+    Q_PROPERTY(bool isValid READ isValid CONSTANT FINAL)
+    Q_CLASSINFO("RegisterEnumClassesUnscoped", "false")
+
+public:
+    Q_WEBENGINECORE_EXPORT QWebEnginePermission();
+
+    Q_WEBENGINECORE_EXPORT QWebEnginePermission(const QWebEnginePermission &other);
+    Q_WEBENGINECORE_EXPORT QWebEnginePermission(QWebEnginePermissionPrivate *pvt);
+    Q_WEBENGINECORE_EXPORT ~QWebEnginePermission();
+
+    Q_WEBENGINECORE_EXPORT QWebEnginePermission &operator=(const QWebEnginePermission &other);
+    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QWebEnginePermission)
+    void swap(QWebEnginePermission &other) noexcept { d_ptr.swap(other.d_ptr); }
+
+    enum Feature : quint8 {
+        Unsupported,
+        MediaAudioCapture,
+        MediaVideoCapture,
+        MediaAudioVideoCapture,
+        DesktopVideoCapture,
+        DesktopAudioVideoCapture,
+        MouseLock,
+        Notifications,
+        Geolocation,
+        ClipboardReadWrite,
+        LocalFontsAccess,
+    };
+    Q_ENUM(Feature)
+
+    enum State : quint8 {
+        Invalid,
+        Ask,
+        Granted,
+        Denied
+    };
+    Q_ENUM(State)
+
+    Q_WEBENGINECORE_EXPORT const QUrl origin() const;
+    Q_WEBENGINECORE_EXPORT Feature feature() const;
+    Q_WEBENGINECORE_EXPORT State state() const;
+    Q_WEBENGINECORE_EXPORT bool isValid() const;
+
+    Q_WEBENGINECORE_EXPORT Q_INVOKABLE void grant() const;
+    Q_WEBENGINECORE_EXPORT Q_INVOKABLE void deny() const;
+    Q_WEBENGINECORE_EXPORT Q_INVOKABLE void reset() const;
+
+    Q_WEBENGINECORE_EXPORT Q_INVOKABLE static bool isTransient(QWebEnginePermission::Feature feature);
+
+private:
+    inline friend bool operator==(const QWebEnginePermission &lhs, const QWebEnginePermission &rhs)
+        { return lhs.comparesEqual(rhs); };
+    inline friend bool operator!=(const QWebEnginePermission &lhs, const QWebEnginePermission &rhs)
+        { return !lhs.comparesEqual(rhs); };
+
+    Q_WEBENGINECORE_EXPORT bool comparesEqual(const QWebEnginePermission &other) const;
+
+protected:
+    QExplicitlySharedDataPointer<QWebEnginePermissionPrivate> d_ptr;
+};
+
+
+
+Q_DECLARE_SHARED(QWebEnginePermission)
+
+QT_END_NAMESPACE
+
+#endif // QWEBENGINEPERMISSION_H
diff --git a/src/core/api/qwebenginepermission_p.h b/src/core/api/qwebenginepermission_p.h
new file mode 100644
index 000000000..94c898873
--- /dev/null
+++ b/src/core/api/qwebenginepermission_p.h
@@ -0,0 +1,46 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QWEBENGINEPERMISSION_P_H
+#define QWEBENGINEPERMISSION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qwebenginepermission.h"
+
+#include <QtCore/qpointer.h>
+#include <QtCore/qsharedpointer.h>
+#include <QtCore/qshareddata.h>
+
+namespace QtWebEngineCore {
+class WebContentsAdapter;
+class ProfileAdapter;
+}
+
+QT_BEGIN_NAMESPACE
+
+struct QWebEnginePermissionPrivate : public QSharedData
+{
+    Q_WEBENGINECORE_EXPORT QWebEnginePermissionPrivate();
+    Q_WEBENGINECORE_EXPORT QWebEnginePermissionPrivate(const QUrl &, QWebEnginePermission::Feature,
+        QSharedPointer<QtWebEngineCore::WebContentsAdapter>, QtWebEngineCore::ProfileAdapter *);
+
+    QUrl origin;
+    QWebEnginePermission::Feature feature;
+
+    QWeakPointer<QtWebEngineCore::WebContentsAdapter> webContentsAdapter;
+    QPointer<QtWebEngineCore::ProfileAdapter> profileAdapter;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWEBENGINEPERMISSION_P_H
diff --git a/src/core/doc/src/qwebenginepage_lgpl.qdoc b/src/core/doc/src/qwebenginepage_lgpl.qdoc
index 1640ca8be..630ea507e 100644
--- a/src/core/doc/src/qwebenginepage_lgpl.qdoc
+++ b/src/core/doc/src/qwebenginepage_lgpl.qdoc
@@ -245,6 +245,7 @@
 
 /*!
     \enum QWebEnginePage::PermissionPolicy
+    \deprecated [6.8] Replaced by QWebEnginePermission::State.
 
     This enum describes the permission policies that the user may set for data or device access:
 
@@ -273,6 +274,7 @@
 
 /*!
     \enum QWebEnginePage::Feature
+    \deprecated [6.8] Replaced by QWebEnginePermission::Feature.
 
     This enum describes the platform feature access categories that the user may be asked to grant
     or deny access to:
@@ -779,6 +781,8 @@
 
 /*!
     \fn void QWebEnginePage::setFeaturePermission(const QUrl &securityOrigin, Feature feature, PermissionPolicy policy)
+    \deprecated [6.8] Use QWebEnginePermission's \l {QWebEnginePermission::grant} {grant}(),
+    \l {QWebEnginePermission::deny} {deny}(), and \l {QWebEnginePermission::reset} {reset}() functions instead.
 
     Sets the permission for the web site identified by \a securityOrigin to use \a feature to \a policy.
 
@@ -792,6 +796,7 @@
 
 /*!
     \fn void QWebEnginePage::featurePermissionRequested(const QUrl &securityOrigin, Feature feature)
+    \deprecated [6.8] Use permissionRequested() instead.
 
     This signal is emitted when the web site identified by \a securityOrigin requests to make use of
     the resource or device identified by \a feature.
@@ -801,6 +806,7 @@
 
 /*!
     \fn void QWebEnginePage::featurePermissionRequestCanceled(const QUrl &securityOrigin, Feature feature)
+    \deprecated [6.8] This signal is no longer emitted.
 
     This signal is emitted when the web site identified by \a securityOrigin cancels a previously issued
     request to make use of \a feature.
@@ -810,6 +816,15 @@
 */
 
 /*!
+    \fn void QWebEnginePage::permissionRequested(QWebEnginePermission permission)
+    \since 6.8
+
+    This signal is emitted when a web site requests to make use of a feature (e.g. geolocation access,
+    permission to send notifications). The \a permission object can queried for the requesting URL
+    and the \c{QWebEnginePermission::Feature} it's asking for, as well as to grant or deny permission.
+*/
+
+/*!
     \fn void QWebEnginePage::titleChanged(const QString &title)
 
     This signal is emitted whenever the title of the page changes.
diff --git a/src/core/permission_manager_qt.cpp b/src/core/permission_manager_qt.cpp
index 100b7eb7c..6883d2224 100644
--- a/src/core/permission_manager_qt.cpp
+++ b/src/core/permission_manager_qt.cpp
@@ -27,28 +27,30 @@
 
 namespace QtWebEngineCore {
 
-static ProfileAdapter::PermissionType toQt(blink::PermissionType type)
+static QWebEnginePermission::Feature toQt(blink::PermissionType type)
 {
     switch (type) {
     case blink::PermissionType::GEOLOCATION:
-        return ProfileAdapter::GeolocationPermission;
+        return QWebEnginePermission::Geolocation;
     case blink::PermissionType::AUDIO_CAPTURE:
-        return ProfileAdapter::AudioCapturePermission;
+        return QWebEnginePermission::MediaAudioCapture;
     case blink::PermissionType::VIDEO_CAPTURE:
-        return ProfileAdapter::VideoCapturePermission;
+        return QWebEnginePermission::MediaVideoCapture;
+    case blink::PermissionType::DISPLAY_CAPTURE:
+        return QWebEnginePermission::DesktopAudioVideoCapture;
         // We treat these both as read/write since we do not currently have a
         // ClipboardSanitizedWrite feature.
     case blink::PermissionType::CLIPBOARD_READ_WRITE:
     case blink::PermissionType::CLIPBOARD_SANITIZED_WRITE:
-        return ProfileAdapter::ClipboardReadWrite;
+        return QWebEnginePermission::ClipboardReadWrite;
     case blink::PermissionType::NOTIFICATIONS:
-        return ProfileAdapter::NotificationPermission;
+        return QWebEnginePermission::Notifications;
     case blink::PermissionType::LOCAL_FONTS:
-        return ProfileAdapter::LocalFontsPermission;
+        return QWebEnginePermission::LocalFontsAccess;
     case blink::PermissionType::ACCESSIBILITY_EVENTS:
     case blink::PermissionType::CAMERA_PAN_TILT_ZOOM:
     case blink::PermissionType::WINDOW_MANAGEMENT:
-        return ProfileAdapter::UnsupportedPermission;
+        return QWebEnginePermission::Unsupported;
     case blink::PermissionType::MIDI_SYSEX:
     case blink::PermissionType::PROTECTED_MEDIA_IDENTIFIER:
     case blink::PermissionType::MIDI:
@@ -65,62 +67,92 @@ static ProfileAdapter::PermissionType toQt(blink::PermissionType type)
     case blink::PermissionType::AR:
     case blink::PermissionType::VR:
     case blink::PermissionType::STORAGE_ACCESS_GRANT:
-    case blink::PermissionType::DISPLAY_CAPTURE:
     case blink::PermissionType::TOP_LEVEL_STORAGE_ACCESS:
     case blink::PermissionType::NUM:
-        LOG(INFO) << "Unexpected unsupported WebEngine permission type: " << static_cast<int>(type);
+        LOG(INFO) << "Unexpected unsupported Blink permission type: " << static_cast<int>(type);
         break;
     }
-    return ProfileAdapter::UnsupportedPermission;
+    return QWebEnginePermission::Unsupported;
 }
 
-static blink::PermissionType toBlink(ProfileAdapter::PermissionType type)
+static blink::PermissionType toBlink(QWebEnginePermission::Feature feature)
 {
-    switch (type) {
-    case ProfileAdapter::GeolocationPermission:
+    switch (feature) {
+    case QWebEnginePermission::Notifications:
+        return blink::PermissionType::NOTIFICATIONS;
+    case QWebEnginePermission::Geolocation:
         return blink::PermissionType::GEOLOCATION;
-    case ProfileAdapter::AudioCapturePermission:
+    case QWebEnginePermission::MediaAudioCapture:
         return blink::PermissionType::AUDIO_CAPTURE;
-    case ProfileAdapter::VideoCapturePermission:
+    case QWebEnginePermission::MediaVideoCapture:
         return blink::PermissionType::VIDEO_CAPTURE;
-    case ProfileAdapter::ClipboardReadWrite:
+    case QWebEnginePermission::DesktopVideoCapture:
+    case QWebEnginePermission::DesktopAudioVideoCapture:
+        return blink::PermissionType::DISPLAY_CAPTURE;
+    case QWebEnginePermission::ClipboardReadWrite:
         return blink::PermissionType::CLIPBOARD_READ_WRITE;
-    case ProfileAdapter::NotificationPermission:
-        return blink::PermissionType::NOTIFICATIONS;
-    case ProfileAdapter::LocalFontsPermission:
+    case QWebEnginePermission::LocalFontsAccess:
         return blink::PermissionType::LOCAL_FONTS;
+    case QWebEnginePermission::MediaAudioVideoCapture:
+    case QWebEnginePermission::Unsupported:
+        LOG(INFO) << "Unexpected unsupported WebEngine permission type: " << static_cast<int>(feature);
+        return blink::PermissionType::NUM;
     }
 
-    LOG(INFO) << "Unexpected unsupported Blink permission type: " << static_cast<int>(type);
-    return blink::PermissionType::NUM;
+    Q_UNREACHABLE();
 }
 
-static bool canRequestPermissionFor(ProfileAdapter::PermissionType type)
+static QWebEnginePermission::State toQt(blink::mojom::PermissionStatus state)
 {
-    switch (type) {
-    case ProfileAdapter::GeolocationPermission:
-    case ProfileAdapter::NotificationPermission:
-    case ProfileAdapter::ClipboardReadWrite:
-    case ProfileAdapter::LocalFontsPermission:
-        return true;
-    default:
-        break;
+    switch (state) {
+    case blink::mojom::PermissionStatus::ASK:
+        return QWebEnginePermission::Ask;
+    case blink::mojom::PermissionStatus::GRANTED:
+        return QWebEnginePermission::Granted;
+    case blink::mojom::PermissionStatus::DENIED:
+        return QWebEnginePermission::Denied;
     }
-    return false;
 }
 
-static blink::mojom::PermissionStatus toBlink(ProfileAdapter::PermissionState reply)
+static blink::mojom::PermissionStatus toBlink(QWebEnginePermission::State state)
 {
-    switch (reply) {
-    case ProfileAdapter::AskPermission:
+    switch (state) {
+    case QWebEnginePermission::Invalid:
+    case QWebEnginePermission::Ask:
         return blink::mojom::PermissionStatus::ASK;
-    case ProfileAdapter::AllowedPermission:
+    case QWebEnginePermission::Granted:
         return blink::mojom::PermissionStatus::GRANTED;
-    case ProfileAdapter::DeniedPermission:
+    case QWebEnginePermission::Denied:
         return blink::mojom::PermissionStatus::DENIED;
     }
 }
 
+std::string featureString(QWebEnginePermission::Feature feature)
+{
+    // This is separate from blink::featureString() for the sake of future-proofing;
+    // e.g. in case we add extra Features that do not correspond to a PermissionType, and
+    // we need to store them.
+    switch (feature) {
+    case QWebEnginePermission::Notifications:
+        return "Notifications";
+    case QWebEnginePermission::Geolocation:
+        return "Geolocation";
+    case QWebEnginePermission::ClipboardReadWrite:
+        return "ClipboardReadWrite";
+    case QWebEnginePermission::LocalFontsAccess:
+        return "LocalFontsAccess";
+    case QWebEnginePermission::MediaAudioCapture:
+        return "MediaAudioCapture";
+    case QWebEnginePermission::MediaVideoCapture:
+        return "MediaVideoCapture";
+    case QWebEnginePermission::DesktopAudioVideoCapture:
+        return "DesktopAudioVideoCapture";
+    default:
+        Q_UNREACHABLE();
+        return nullptr;
+    }
+}
+
 static blink::mojom::PermissionStatus getStatusFromSettings(blink::PermissionType type, WebEngineSettings *settings)
 {
     switch (type) {
@@ -159,12 +191,12 @@ PermissionManagerQt::PermissionManagerQt(ProfileAdapter *profileAdapter)
     }
 
     // Register all preference types as keys prior to doing anything else
-    prefRegistry->RegisterDictionaryPref(GetPermissionString(toBlink(ProfileAdapter::GeolocationPermission)));
-    prefRegistry->RegisterDictionaryPref(GetPermissionString(toBlink(ProfileAdapter::AudioCapturePermission)));
-    prefRegistry->RegisterDictionaryPref(GetPermissionString(toBlink(ProfileAdapter::VideoCapturePermission)));
-    prefRegistry->RegisterDictionaryPref(GetPermissionString(toBlink(ProfileAdapter::ClipboardReadWrite)));
-    prefRegistry->RegisterDictionaryPref(GetPermissionString(toBlink(ProfileAdapter::NotificationPermission)));
-    prefRegistry->RegisterDictionaryPref(GetPermissionString(toBlink(ProfileAdapter::LocalFontsPermission)));
+    prefRegistry->RegisterDictionaryPref(featureString(QWebEnginePermission::Geolocation));
+    prefRegistry->RegisterDictionaryPref(featureString(QWebEnginePermission::ClipboardReadWrite));
+    prefRegistry->RegisterDictionaryPref(featureString(QWebEnginePermission::Notifications));
+    prefRegistry->RegisterDictionaryPref(featureString(QWebEnginePermission::LocalFontsAccess));
+    prefRegistry->RegisterDictionaryPref(featureString(QWebEnginePermission::MediaAudioCapture));
+    prefRegistry->RegisterDictionaryPref(featureString(QWebEnginePermission::MediaVideoCapture));
     PrefProxyConfigTrackerImpl::RegisterPrefs(prefRegistry.get());
 
     if (policy == ProfileAdapter::NoPersistentPermissions)
@@ -181,34 +213,35 @@ PermissionManagerQt::~PermissionManagerQt()
     commit();
 }
 
-void PermissionManagerQt::permissionRequestReply(const QUrl &url, ProfileAdapter::PermissionType type, ProfileAdapter::PermissionState reply)
+void PermissionManagerQt::setPermission(const QUrl &url, QWebEnginePermission::Feature feature, QWebEnginePermission::State state)
 {
     // Normalize the QUrl to Chromium origin form.
     const GURL gorigin = toGurl(url).DeprecatedGetOriginAsURL();
     const QUrl origin = gorigin.is_empty() ? url : toQt(gorigin);
     if (origin.isEmpty())
         return;
-    if (reply == ProfileAdapter::AskPermission)
-        ResetPermission(toBlink(type), gorigin, gorigin);
+    if (state == QWebEnginePermission::Ask)
+        ResetPermission(toBlink(feature), gorigin, gorigin);
     else
-        setPermission(toBlink(type), gorigin, reply == ProfileAdapter::AllowedPermission);
-    blink::mojom::PermissionStatus status = toBlink(reply);
-    if (reply != ProfileAdapter::AskPermission) {
+        setPermission(toBlink(feature), gorigin, state == QWebEnginePermission::Granted);
+    blink::mojom::PermissionStatus status = toBlink(state);
+    if (state != QWebEnginePermission::Ask) {
         auto it = m_requests.begin();
         while (it != m_requests.end()) {
-            if (it->origin == origin && it->type == type) {
+            if (it->origin == origin && it->type == feature) {
                 std::move(it->callback).Run(status);
                 it = m_requests.erase(it);
             } else
                 ++it;
         }
     }
+
     for (const auto &it: m_subscribers) {
-        if (it.second.origin == origin && it.second.type == type)
+        if (it.second.origin == origin && it.second.type == feature)
             it.second.callback.Run(status);
     }
 
-    if (reply == ProfileAdapter::AskPermission)
+    if (state == QWebEnginePermission::Ask)
         return;
 
     auto it = m_multiRequests.begin();
@@ -218,13 +251,13 @@ void PermissionManagerQt::permissionRequestReply(const QUrl &url, ProfileAdapter
             std::vector<blink::mojom::PermissionStatus> result;
             result.reserve(it->types.size());
             for (blink::PermissionType permission : it->types) {
-                if (toQt(permission) == ProfileAdapter::UnsupportedPermission) {
+                if (toQt(permission) == QWebEnginePermission::Unsupported) {
                     result.push_back(blink::mojom::PermissionStatus::DENIED);
                     continue;
                 }
 
                 blink::mojom::PermissionStatus permissionStatus = GetPermissionStatus(permission, gorigin, GURL());
-                if (permissionStatus == toBlink(reply)) {
+                if (permissionStatus == toBlink(state)) {
                     if (permissionStatus == blink::mojom::PermissionStatus::ASK) {
                         answerable = false;
                         break;
@@ -233,7 +266,7 @@ void PermissionManagerQt::permissionRequestReply(const QUrl &url, ProfileAdapter
                     result.push_back(permissionStatus);
                 } else {
                     // Reached when the PersistentPermissionsPolicy is set to NoPersistentPermissions
-                    result.push_back(toBlink(reply));
+                    result.push_back(toBlink(state));
                 }
             }
             if (answerable) {
@@ -246,9 +279,9 @@ void PermissionManagerQt::permissionRequestReply(const QUrl &url, ProfileAdapter
     }
 }
 
-bool PermissionManagerQt::checkPermission(const QUrl &origin, ProfileAdapter::PermissionType type)
+QWebEnginePermission::State PermissionManagerQt::getPermissionState(const QUrl &origin, QWebEnginePermission::Feature feature)
 {
-    return GetPermissionStatus(toBlink(type), toGurl(origin), GURL()) == blink::mojom::PermissionStatus::GRANTED;
+    return toQt(GetPermissionStatus(toBlink(feature), toGurl(origin), GURL()));
 }
 
 void PermissionManagerQt::commit()
@@ -275,8 +308,8 @@ void PermissionManagerQt::RequestPermissions(content::RenderFrameHost *frameHost
     std::vector<content::PermissionStatus> result;
     result.reserve(requestDescription.permissions.size());
     for (blink::PermissionType permission : requestDescription.permissions) {
-        const ProfileAdapter::PermissionType permissionType = toQt(permission);
-        if (permissionType == ProfileAdapter::UnsupportedPermission) {
+        const QWebEnginePermission::Feature feature = toQt(permission);
+        if (feature == QWebEnginePermission::Unsupported) {
             result.push_back(blink::mojom::PermissionStatus::DENIED);
             continue;
         }
@@ -306,9 +339,9 @@ void PermissionManagerQt::RequestPermissions(content::RenderFrameHost *frameHost
     auto requestOrigin = toQt(requestDescription.requesting_origin);
     m_multiRequests.push_back({ request_id, requestDescription.permissions, requestOrigin, std::move(callback) });
     for (blink::PermissionType permission : requestDescription.permissions) {
-        const ProfileAdapter::PermissionType permissionType = toQt(permission);
-        if (canRequestPermissionFor(permissionType))
-            contentsDelegate->requestFeaturePermission(permissionType, requestOrigin);
+        const QWebEnginePermission::Feature feature = toQt(permission);
+        if (!QWebEnginePermission::isTransient(feature))
+            contentsDelegate->requestFeaturePermission(feature, requestOrigin);
     }
 }
 
@@ -324,12 +357,12 @@ blink::mojom::PermissionStatus PermissionManagerQt::GetPermissionStatus(
     const GURL& requesting_origin,
     const GURL& /*embedding_origin*/)
 {
-    const ProfileAdapter::PermissionType permissionType = toQt(permission);
-    if (permissionType == ProfileAdapter::UnsupportedPermission)
+    const QWebEnginePermission::Feature feature = toQt(permission);
+    if (feature == QWebEnginePermission::Unsupported)
         return blink::mojom::PermissionStatus::DENIED;
 
     permission = toBlink(toQt(permission)); // Filter out merged/unsupported permissions (e.g. clipboard)
-    auto *pref = m_prefService->FindPreference(GetPermissionString(permission));
+    auto *pref = m_prefService->FindPreference(featureString(toQt(permission)));
     if (!pref)
         return blink::mojom::PermissionStatus::ASK; // Permission type not in database
 
@@ -405,11 +438,11 @@ void PermissionManagerQt::ResetPermission(
     const GURL& requesting_origin,
     const GURL& /*embedding_origin*/)
 {
-    const ProfileAdapter::PermissionType permissionType = toQt(permission);
-    if (permissionType == ProfileAdapter::UnsupportedPermission)
+    const QWebEnginePermission::Feature feature = toQt(permission);
+    if (feature == QWebEnginePermission::Unsupported)
         return;
 
-    ScopedDictPrefUpdate updater(m_prefService.get(), GetPermissionString(permission));
+    ScopedDictPrefUpdate updater(m_prefService.get(), featureString(feature));
     updater.Get().Remove(requesting_origin.spec());
 }
 
@@ -437,14 +470,14 @@ void PermissionManagerQt::setPermission(
     const GURL& requesting_origin,
     bool granted)
 {
-    const ProfileAdapter::PermissionType permissionType = toQt(permission);
-    if (permissionType == ProfileAdapter::UnsupportedPermission)
+    const QWebEnginePermission::Feature feature = toQt(permission);
+    if (feature == QWebEnginePermission::Unsupported)
         return;
 
-    if (!m_prefService->FindPreference(GetPermissionString(permission)))
+    if (!m_prefService->FindPreference(featureString(feature)))
         return;
 
-    ScopedDictPrefUpdate updater(m_prefService.get(), GetPermissionString(permission));
+    ScopedDictPrefUpdate updater(m_prefService.get(), featureString(feature));
     updater.Get().Set(requesting_origin.spec(), granted);
 }
 
diff --git a/src/core/permission_manager_qt.h b/src/core/permission_manager_qt.h
index 5dedaa612..e74a3fba1 100644
--- a/src/core/permission_manager_qt.h
+++ b/src/core/permission_manager_qt.h
@@ -7,6 +7,7 @@
 #include "base/functional/callback.h"
 #include "content/public/browser/permission_controller_delegate.h"
 
+#include <QtWebEngineCore/qwebenginepermission.h>
 #include "profile_adapter.h"
 
 #include <map>
@@ -21,8 +22,9 @@ public:
     PermissionManagerQt(ProfileAdapter *adapter);
     ~PermissionManagerQt();
 
-    void permissionRequestReply(const QUrl &origin, ProfileAdapter::PermissionType type, ProfileAdapter::PermissionState reply);
-    bool checkPermission(const QUrl &origin, ProfileAdapter::PermissionType type);
+    void setPermission(const QUrl &origin, QWebEnginePermission::Feature feature, QWebEnginePermission::State state);
+    QWebEnginePermission::State getPermissionState(const QUrl &origin, QWebEnginePermission::Feature feature);
+
     void commit();
 
     // content::PermissionManager implementation:
@@ -66,7 +68,7 @@ public:
 private:
     struct Request {
         int id;
-        ProfileAdapter::PermissionType type;
+        QWebEnginePermission::Feature type;
         QUrl origin;
         base::OnceCallback<void(blink::mojom::PermissionStatus)> callback;
     };
@@ -77,7 +79,7 @@ private:
         base::OnceCallback<void(const std::vector<blink::mojom::PermissionStatus>&)> callback;
     };
     struct Subscription {
-        ProfileAdapter::PermissionType type;
+        QWebEnginePermission::Feature type;
         QUrl origin;
         base::RepeatingCallback<void(blink::mojom::PermissionStatus)> callback;
     };
diff --git a/src/core/profile_adapter.cpp b/src/core/profile_adapter.cpp
index 6fec8aa28..4b337e8ed 100644
--- a/src/core/profile_adapter.cpp
+++ b/src/core/profile_adapter.cpp
@@ -569,14 +569,14 @@ UserResourceControllerHost *ProfileAdapter::userResourceController()
     return m_userResourceController.data();
 }
 
-void ProfileAdapter::permissionRequestReply(const QUrl &origin, PermissionType type, PermissionState reply)
+void ProfileAdapter::setPermission(const QUrl &origin, QWebEnginePermission::Feature feature, QWebEnginePermission::State state)
 {
-    static_cast<PermissionManagerQt*>(profile()->GetPermissionControllerDelegate())->permissionRequestReply(origin, type, reply);
+    static_cast<PermissionManagerQt*>(profile()->GetPermissionControllerDelegate())->setPermission(origin, feature, state);
 }
 
-bool ProfileAdapter::checkPermission(const QUrl &origin, PermissionType type)
+QWebEnginePermission::State ProfileAdapter::getPermissionState(const QUrl &origin, QWebEnginePermission::Feature feature)
 {
-    return static_cast<PermissionManagerQt*>(profile()->GetPermissionControllerDelegate())->checkPermission(origin, type);
+    return static_cast<PermissionManagerQt*>(profile()->GetPermissionControllerDelegate())->getPermissionState(origin, feature);
 }
 
 QString ProfileAdapter::httpAcceptLanguageWithoutQualities() const
diff --git a/src/core/profile_adapter.h b/src/core/profile_adapter.h
index 18d82ba96..644d7e03c 100644
--- a/src/core/profile_adapter.h
+++ b/src/core/profile_adapter.h
@@ -28,6 +28,7 @@
 #include <QtWebEngineCore/qwebenginecookiestore.h>
 #include <QtWebEngineCore/qwebengineurlrequestinterceptor.h>
 #include <QtWebEngineCore/qwebengineurlschemehandler.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 #include "net/qrc_url_scheme_handler.h"
 
 QT_FORWARD_DECLARE_CLASS(QObject)
@@ -133,22 +134,6 @@ public:
         PersistentPermissionsOnDisk,
     };
 
-    enum PermissionType {
-        UnsupportedPermission = 0,
-        GeolocationPermission = 1,
-        NotificationPermission = 2,
-        AudioCapturePermission = 3,
-        VideoCapturePermission = 4,
-        ClipboardReadWrite = 5,
-        LocalFontsPermission = 6,
-    };
-
-    enum PermissionState {
-        AskPermission = 0,
-        AllowedPermission = 1,
-        DeniedPermission = 2
-    };
-
     enum ClientHint : uchar {
         UAArchitecture,
         UAPlatform,
@@ -187,8 +172,8 @@ public:
     const QList<QByteArray> customUrlSchemes() const;
     UserResourceControllerHost *userResourceController();
 
-    void permissionRequestReply(const QUrl &origin, PermissionType type, PermissionState reply);
-    bool checkPermission(const QUrl &origin, PermissionType type);
+    void setPermission(const QUrl &origin, QWebEnginePermission::Feature feature, QWebEnginePermission::State state);
+    QWebEnginePermission::State getPermissionState(const QUrl &origin, QWebEnginePermission::Feature feature);
 
     QString httpAcceptLanguageWithoutQualities() const;
     QString httpAcceptLanguage() const;
diff --git a/src/core/web_contents_adapter.cpp b/src/core/web_contents_adapter.cpp
index 4774cf4dc..7d9e119e9 100644
--- a/src/core/web_contents_adapter.cpp
+++ b/src/core/web_contents_adapter.cpp
@@ -1411,21 +1411,92 @@ QSizeF WebContentsAdapter::lastContentsSize() const
     return QSizeF();
 }
 
-void WebContentsAdapter::grantMediaAccessPermission(const QUrl &securityOrigin, WebContentsAdapterClient::MediaRequestFlags flags)
+void WebContentsAdapter::setFeaturePermission(const QUrl &origin, QWebEnginePermission::Feature feature, QWebEnginePermission::State state)
 {
+    if (!QWebEnginePermission::isTransient(feature)) {
+        // Do not check for initialization in this path so permissions can be set before first navigation
+        Q_ASSERT(m_profileAdapter);
+        m_profileAdapter->setPermission(origin, feature, state);
+        return;
+    }
+
     CHECK_INITIALIZED();
-    // Let the permission manager remember the reply.
-    if (flags & WebContentsAdapterClient::MediaAudioCapture)
-        m_profileAdapter->permissionRequestReply(securityOrigin, ProfileAdapter::AudioCapturePermission, ProfileAdapter::AllowedPermission);
-    if (flags & WebContentsAdapterClient::MediaVideoCapture)
-        m_profileAdapter->permissionRequestReply(securityOrigin, ProfileAdapter::VideoCapturePermission, ProfileAdapter::AllowedPermission);
-    MediaCaptureDevicesDispatcher::GetInstance()->handleMediaAccessPermissionResponse(m_webContents.get(), securityOrigin, flags);
+    if (feature == QWebEnginePermission::MouseLock) {
+        switch (state) {
+        case QWebEnginePermission::Ask:
+            // Do nothing
+            break;
+        case QWebEnginePermission::Denied:
+            grantMouseLockPermission(origin, false);
+            break;
+        case QWebEnginePermission::Granted:
+            grantMouseLockPermission(origin, true);
+            break;
+        }
+
+        return;
+    }
+
+    const WebContentsAdapterClient::MediaRequestFlags audioVideoCaptureFlags(
+        WebContentsAdapterClient::MediaVideoCapture |
+        WebContentsAdapterClient::MediaAudioCapture);
+    const WebContentsAdapterClient::MediaRequestFlags desktopAudioVideoCaptureFlags(
+        WebContentsAdapterClient::MediaDesktopVideoCapture |
+        WebContentsAdapterClient::MediaDesktopAudioCapture);
+
+    switch (state) {
+    case QWebEnginePermission::Ask:
+        // Do nothing
+        return;
+    case QWebEnginePermission::Denied:
+        // Deny all media access
+        grantMediaAccessPermission(origin, WebContentsAdapterClient::MediaNone);
+        return;
+    case QWebEnginePermission::Granted:
+        // Enable only the requested capture type
+        break;
+    }
+
+    switch (feature) {
+    case QWebEnginePermission::MediaAudioVideoCapture:
+        grantMediaAccessPermission(origin, audioVideoCaptureFlags);
+        break;
+    case QWebEnginePermission::MediaAudioCapture:
+        grantMediaAccessPermission(origin, WebContentsAdapterClient::MediaAudioCapture);
+        break;
+    case QWebEnginePermission::MediaVideoCapture:
+        grantMediaAccessPermission(origin, WebContentsAdapterClient::MediaVideoCapture);
+        break;
+    case QWebEnginePermission::DesktopAudioVideoCapture:
+        grantMediaAccessPermission(origin, desktopAudioVideoCaptureFlags);
+        break;
+    case QWebEnginePermission::DesktopVideoCapture:
+        grantMediaAccessPermission(origin, WebContentsAdapterClient::MediaDesktopVideoCapture);
+        break;
+    default:
+        Q_UNREACHABLE();
+        break;
+    }
 }
 
-void WebContentsAdapter::grantFeaturePermission(const QUrl &securityOrigin, ProfileAdapter::PermissionType feature, ProfileAdapter::PermissionState allowed)
+QWebEnginePermission::State WebContentsAdapter::getPermissionState(const QUrl &origin, QWebEnginePermission::Feature feature)
 {
-    Q_ASSERT(m_profileAdapter);
-    m_profileAdapter->permissionRequestReply(securityOrigin, feature, allowed);
+    // For now, we just return Ask for transient Features
+    if (QWebEnginePermission::isTransient(feature))
+        return QWebEnginePermission::Ask;
+
+    return m_profileAdapter->getPermissionState(origin, feature);
+}
+
+void WebContentsAdapter::grantMediaAccessPermission(const QUrl &origin, WebContentsAdapterClient::MediaRequestFlags flags)
+{
+    CHECK_INITIALIZED();
+    // Let the permission manager remember the reply.
+    if (flags & WebContentsAdapterClient::MediaAudioCapture)
+        m_profileAdapter->setPermission(origin, QWebEnginePermission::MediaAudioCapture, QWebEnginePermission::Granted);
+    if (flags & WebContentsAdapterClient::MediaVideoCapture)
+        m_profileAdapter->setPermission(origin, QWebEnginePermission::MediaVideoCapture, QWebEnginePermission::Granted);
+    MediaCaptureDevicesDispatcher::GetInstance()->handleMediaAccessPermissionResponse(m_webContents.get(), origin, flags);
 }
 
 void WebContentsAdapter::grantMouseLockPermission(const QUrl &securityOrigin, bool granted)
diff --git a/src/core/web_contents_adapter.h b/src/core/web_contents_adapter.h
index 61da0ba7b..66736dd21 100644
--- a/src/core/web_contents_adapter.h
+++ b/src/core/web_contents_adapter.h
@@ -26,6 +26,7 @@
 #include <QtWebEngineCore/qwebenginecontextmenurequest.h>
 #include <QtWebEngineCore/qwebenginehttprequest.h>
 #include <QtWebEngineCore/qwebengineframe.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 
 #include "web_contents_adapter_client.h"
 
@@ -178,10 +179,12 @@ public:
     void devToolsFrontendDestroyed(DevToolsFrontendQt *frontend);
     QString devToolsId();
 
-    void grantMediaAccessPermission(const QUrl &securityOrigin, WebContentsAdapterClient::MediaRequestFlags flags);
-    void grantMouseLockPermission(const QUrl &securityOrigin, bool granted);
+    void setFeaturePermission(const QUrl &origin, QWebEnginePermission::Feature feature, QWebEnginePermission::State state);
+    QWebEnginePermission::State getPermissionState(const QUrl &origin, QWebEnginePermission::Feature feature);
+
+    void grantMediaAccessPermission(const QUrl &origin, WebContentsAdapterClient::MediaRequestFlags flags);
+    void grantMouseLockPermission(const QUrl &origin, bool granted);
     void handlePendingMouseLockPermission();
-    void grantFeaturePermission(const QUrl &securityOrigin, ProfileAdapter::PermissionType feature, ProfileAdapter::PermissionState allowed);
 
     void setBackgroundColor(const QColor &color);
     QAccessibleInterface *browserAccessible();
diff --git a/src/core/web_contents_adapter_client.h b/src/core/web_contents_adapter_client.h
index 6cb07a32b..ca162833c 100644
--- a/src/core/web_contents_adapter_client.h
+++ b/src/core/web_contents_adapter_client.h
@@ -16,6 +16,7 @@
 #define WEB_CONTENTS_ADAPTER_CLIENT_H
 
 #include <QtWebEngineCore/private/qtwebenginecoreglobal_p.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 
 #include "profile_adapter.h"
 
@@ -194,7 +195,7 @@ public:
     virtual QObject *accessibilityParentObject() = 0;
     virtual void javaScriptConsoleMessage(JavaScriptConsoleMessageLevel level, const QString& message, int lineNumber, const QString& sourceID) = 0;
     virtual void authenticationRequired(QSharedPointer<AuthenticationDialogController>) = 0;
-    virtual void runFeaturePermissionRequest(ProfileAdapter::PermissionType, const QUrl &securityOrigin) = 0;
+    virtual void runFeaturePermissionRequest(QWebEnginePermission::Feature, const QUrl &securityOrigin) = 0;
     virtual void runMediaAccessPermissionRequest(const QUrl &securityOrigin, MediaRequestFlags requestFlags) = 0;
     virtual void runMouseLockPermissionRequest(const QUrl &securityOrigin) = 0;
     virtual void runRegisterProtocolHandlerRequest(QWebEngineRegisterProtocolHandlerRequest) = 0;
@@ -228,6 +229,7 @@ public:
     virtual WebContentsAdapter* webContentsAdapter() = 0;
     virtual void releaseProfile() = 0;
     virtual void showWebAuthDialog(QWebEngineWebAuthUxRequest *request) = 0;
+    virtual QWebEnginePermission createFeaturePermissionObject(const QUrl &securityOrigin, QWebEnginePermission::Feature feature) = 0;
 };
 
 } // namespace QtWebEngineCore
diff --git a/src/core/web_contents_delegate_qt.cpp b/src/core/web_contents_delegate_qt.cpp
index 4df73fb69..e16f5d769 100644
--- a/src/core/web_contents_delegate_qt.cpp
+++ b/src/core/web_contents_delegate_qt.cpp
@@ -733,7 +733,7 @@ void WebContentsDelegateQt::selectClientCert(const QSharedPointer<ClientCertSele
     m_viewClient->selectClientCert(selectController);
 }
 
-void WebContentsDelegateQt::requestFeaturePermission(ProfileAdapter::PermissionType feature, const QUrl &requestingOrigin)
+void WebContentsDelegateQt::requestFeaturePermission(QWebEnginePermission::Feature feature, const QUrl &requestingOrigin)
 {
     m_viewClient->runFeaturePermissionRequest(feature, requestingOrigin);
 }
@@ -790,9 +790,9 @@ bool WebContentsDelegateQt::CheckMediaAccessPermission(content::RenderFrameHost
 {
     switch (type) {
     case blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE:
-        return m_viewClient->profileAdapter()->checkPermission(toQt(security_origin), ProfileAdapter::AudioCapturePermission);
+        return m_viewClient->profileAdapter()->getPermissionState(toQt(security_origin), QWebEnginePermission::MediaAudioCapture);
     case blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE:
-        return m_viewClient->profileAdapter()->checkPermission(toQt(security_origin), ProfileAdapter::VideoCapturePermission);
+        return m_viewClient->profileAdapter()->getPermissionState(toQt(security_origin), QWebEnginePermission::MediaVideoCapture);
     default:
         LOG(INFO) << "WebContentsDelegateQt::CheckMediaAccessPermission: "
                   << "Unsupported media stream type checked " << type;
diff --git a/src/core/web_contents_delegate_qt.h b/src/core/web_contents_delegate_qt.h
index 51004878d..88056c3ca 100644
--- a/src/core/web_contents_delegate_qt.h
+++ b/src/core/web_contents_delegate_qt.h
@@ -136,7 +136,7 @@ public:
     void overrideWebPreferences(content::WebContents *, blink::web_pref::WebPreferences*);
     void allowCertificateError(const QSharedPointer<CertificateErrorController> &);
     void selectClientCert(const QSharedPointer<ClientCertSelectController> &);
-    void requestFeaturePermission(ProfileAdapter::PermissionType feature, const QUrl &requestingOrigin);
+    void requestFeaturePermission(QWebEnginePermission::Feature feature, const QUrl &requestingOrigin);
     void launchExternalURL(const QUrl &url, ui::PageTransition page_transition, bool is_main_frame, bool has_user_gesture);
     FindTextHelper *findTextHelper();
 
diff --git a/src/webenginequick/api/qquickwebengineforeigntypes_p.h b/src/webenginequick/api/qquickwebengineforeigntypes_p.h
index 7ba3a4121..58dee066f 100644
--- a/src/webenginequick/api/qquickwebengineforeigntypes_p.h
+++ b/src/webenginequick/api/qquickwebengineforeigntypes_p.h
@@ -32,6 +32,7 @@
 #include <QtWebEngineCore/qwebengineregisterprotocolhandlerrequest.h>
 #include <QtWebEngineCore/qwebenginefilesystemaccessrequest.h>
 #include <QtWebEngineCore/qwebenginewebauthuxrequest.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -240,6 +241,30 @@ struct ForeginWebEngineWebAuthPinRequest
     QML_UNCREATABLE("")
 };
 
+// To prevent the same type from being exported twice into qmltypes
+// (for value type and for the enums)
+class QWebEnginePermissionDerived : public QWebEnginePermission
+{
+    Q_GADGET
+};
+
+namespace ForeignWebEnginePermissionNamespace
+{
+    Q_NAMESPACE
+    QML_FOREIGN_NAMESPACE(QWebEnginePermissionDerived)
+    QML_NAMED_ELEMENT(WebEnginePermission)
+    QML_ADDED_IN_VERSION(6, 8)
+}
+
+struct ForeignWebEnginePermission
+{
+    Q_GADGET
+    QML_FOREIGN(QWebEnginePermission)
+    QML_VALUE_TYPE(webEnginePermission)
+    QML_ADDED_IN_VERSION(6, 8)
+    QML_UNCREATABLE("")
+};
+
 QT_END_NAMESPACE
 
 #endif // QQUICKWEBENGINEFOREIGNTYPES_H
diff --git a/src/webenginequick/api/qquickwebenginesettings.cpp b/src/webenginequick/api/qquickwebenginesettings.cpp
index 31ed7a661..5dc093a44 100644
--- a/src/webenginequick/api/qquickwebenginesettings.cpp
+++ b/src/webenginequick/api/qquickwebenginesettings.cpp
@@ -79,7 +79,7 @@ bool QQuickWebEngineSettings::javascriptCanOpenWindows() const
 
     Since unrestricted clipboard access is a potential security concern, it is
     recommended that applications leave this disabled and instead respond to
-    \l{WebEngineView::ClipboardReadWrite}{ClipboardReadWrite} feature permission requests.
+    \l{WebEnginePermission::ClipboardReadWrite}{ClipboardReadWrite} feature permission requests.
 
     Disabled by default.
 */
@@ -389,7 +389,7 @@ bool QQuickWebEngineSettings::webRTCPublicInterfacesOnly() const
 
     Since unrestricted clipboard access is a potential security concern, it is
     recommended that applications leave this disabled and instead respond to
-    \l{WebEngineView::ClipboardReadWrite}{ClipboardReadWrite} feature permission requests.
+    \l{WebEnginePermission::ClipboardReadWrite}{ClipboardReadWrite} feature permission requests.
 
     Disabled by default.
 */
diff --git a/src/webenginequick/api/qquickwebengineview.cpp b/src/webenginequick/api/qquickwebengineview.cpp
index 0ff182c7a..852d00c76 100644
--- a/src/webenginequick/api/qquickwebengineview.cpp
+++ b/src/webenginequick/api/qquickwebengineview.cpp
@@ -41,6 +41,7 @@
 #include <QtWebEngineCore/qwebengineregisterprotocolhandlerrequest.h>
 #include <QtWebEngineCore/qwebenginescriptcollection.h>
 #include <QtWebEngineCore/qwebenginewebauthuxrequest.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 #include <QtWebEngineCore/private/qwebenginecontextmenurequest_p.h>
 #include <QtWebEngineCore/private/qwebenginedesktopmediarequest_p.h>
 #include <QtWebEngineCore/private/qwebenginehistory_p.h>
@@ -48,6 +49,7 @@
 #include <QtWebEngineCore/private/qwebenginescriptcollection_p.h>
 #include <QtWebEngineCore/private/qwebenginepage_p.h>
 #include <QtWebEngineCore/private/qtwebenginecoreglobal_p.h>
+#include <QtWebEngineCore/private/qwebenginepermission_p.h>
 
 #include <QtCore/qloggingcategory.h>
 #include <QtCore/qmimedata.h>
@@ -484,29 +486,67 @@ void QQuickWebEngineViewPrivate::selectClientCert(
     Q_EMIT q->selectClientCertificate(certSelection);
 }
 
-static QQuickWebEngineView::Feature toFeature(QtWebEngineCore::ProfileAdapter::PermissionType type)
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+static QQuickWebEngineView::Feature toDeprecatedFeature(QWebEnginePermission::Feature feature)
 {
-    switch (type) {
-    case QtWebEngineCore::ProfileAdapter::NotificationPermission:
+    switch (feature) {
+    case QWebEnginePermission::Feature::Notifications:
         return QQuickWebEngineView::Notifications;
-    case QtWebEngineCore::ProfileAdapter::GeolocationPermission:
+    case QWebEnginePermission::Feature::Geolocation:
         return QQuickWebEngineView::Geolocation;
-    case QtWebEngineCore::ProfileAdapter::ClipboardReadWrite:
+    case QWebEnginePermission::Feature::ClipboardReadWrite:
         return QQuickWebEngineView::ClipboardReadWrite;
-    case QtWebEngineCore::ProfileAdapter::LocalFontsPermission:
+    case QWebEnginePermission::Feature::LocalFontsAccess:
         return QQuickWebEngineView::LocalFontsAccess;
-    default:
+    case QWebEnginePermission::Feature::MediaAudioCapture:
+        return QQuickWebEngineView::MediaAudioCapture;
+    case QWebEnginePermission::Feature::MediaVideoCapture:
+        return QQuickWebEngineView::MediaVideoCapture;
+    case QWebEnginePermission::Feature::MediaAudioVideoCapture:
+        return QQuickWebEngineView::MediaAudioVideoCapture;
+    case QWebEnginePermission::Feature::DesktopVideoCapture:
+        return QQuickWebEngineView::DesktopVideoCapture;
+    case QWebEnginePermission::Feature::DesktopAudioVideoCapture:
+        return QQuickWebEngineView::DesktopAudioVideoCapture;
+    case QWebEnginePermission::Feature::MouseLock:
+    case QWebEnginePermission::Feature::Unsupported:
         break;
     }
+
     Q_UNREACHABLE();
     return QQuickWebEngineView::Feature(-1);
 }
+QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 
-
-void QQuickWebEngineViewPrivate::runFeaturePermissionRequest(QtWebEngineCore::ProfileAdapter::PermissionType permission, const QUrl &url)
+void QQuickWebEngineViewPrivate::runFeaturePermissionRequest(QWebEnginePermission::Feature feature, const QUrl &url)
 {
     Q_Q(QQuickWebEngineView);
-    Q_EMIT q->featurePermissionRequested(url, toFeature(permission));
+    switch (feature) {
+    case QWebEnginePermission::Notifications:
+    case QWebEnginePermission::Geolocation:
+    case QWebEnginePermission::ClipboardReadWrite:
+    case QWebEnginePermission::LocalFontsAccess:
+        Q_EMIT q->permissionRequested(createFeaturePermissionObject(url, feature));
+#if QT_DEPRECATED_SINCE(6, 8)
+        QT_WARNING_PUSH
+        QT_WARNING_DISABLE_DEPRECATED
+        Q_EMIT q->featurePermissionRequested(url, toDeprecatedFeature(feature));
+        QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
+        return;
+    case QWebEnginePermission::MouseLock:
+    case QWebEnginePermission::MediaAudioCapture:
+    case QWebEnginePermission::MediaVideoCapture:
+    case QWebEnginePermission::MediaAudioVideoCapture:
+    case QWebEnginePermission::DesktopAudioVideoCapture:
+    case QWebEnginePermission::DesktopVideoCapture:
+    case QWebEnginePermission::Unsupported:
+        Q_UNREACHABLE();
+        return;
+    }
 }
 
 void QQuickWebEngineViewPrivate::showColorDialog(QSharedPointer<ColorChooserController> controller)
@@ -784,19 +824,41 @@ void QQuickWebEngineViewPrivate::runMediaAccessPermissionRequest(const QUrl &sec
     Q_Q(QQuickWebEngineView);
     if (!requestFlags)
         return;
-    QQuickWebEngineView::Feature feature;
+    QWebEnginePermission::Feature feature;
     if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture) && requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
-        feature = QQuickWebEngineView::MediaAudioVideoCapture;
+        feature = QWebEnginePermission::MediaAudioVideoCapture;
     else if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture))
-        feature = QQuickWebEngineView::MediaAudioCapture;
+        feature = QWebEnginePermission::MediaAudioCapture;
     else if (requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
-        feature = QQuickWebEngineView::MediaVideoCapture;
+        feature = QWebEnginePermission::MediaVideoCapture;
     else if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopAudioCapture) &&
              requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
-        feature = QQuickWebEngineView::DesktopAudioVideoCapture;
+        feature = QWebEnginePermission::DesktopAudioVideoCapture;
+    else // if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
+        feature = QWebEnginePermission::DesktopVideoCapture;
+    Q_EMIT q->permissionRequested(createFeaturePermissionObject(securityOrigin, feature));
+
+#if QT_DEPRECATED_SINCE(6, 8)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    QQuickWebEngineView::Feature deprecatedFeature;
+
+    if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture)
+            && requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
+        deprecatedFeature = QQuickWebEngineView::MediaAudioVideoCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaAudioCapture))
+        deprecatedFeature = QQuickWebEngineView::MediaAudioCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaVideoCapture))
+        deprecatedFeature = QQuickWebEngineView::MediaVideoCapture;
+    else if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopAudioCapture)
+            && requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
+        deprecatedFeature = QQuickWebEngineView::DesktopAudioVideoCapture;
     else // if (requestFlags.testFlag(WebContentsAdapterClient::MediaDesktopVideoCapture))
-        feature = QQuickWebEngineView::DesktopVideoCapture;
-    Q_EMIT q->featurePermissionRequested(securityOrigin, feature);
+        deprecatedFeature = QQuickWebEngineView::DesktopVideoCapture;
+
+    Q_EMIT q->featurePermissionRequested(securityOrigin, deprecatedFeature);
+    QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 }
 
 void QQuickWebEngineViewPrivate::runMouseLockPermissionRequest(const QUrl &securityOrigin)
@@ -1466,6 +1528,12 @@ void QQuickWebEngineViewPrivate::showWebAuthDialog(QWebEngineWebAuthUxRequest *r
     Q_EMIT q->webAuthUxRequested(request);
 }
 
+QWebEnginePermission QQuickWebEngineViewPrivate::createFeaturePermissionObject(const QUrl &securityOrigin, QWebEnginePermission::Feature feature)
+{
+    auto *returnPrivate = new QWebEnginePermissionPrivate(securityOrigin, feature, adapter, profileAdapter());
+    return QWebEnginePermission(returnPrivate);
+}
+
 bool QQuickWebEngineView::isLoading() const
 {
     Q_D(const QQuickWebEngineView);
@@ -1761,55 +1829,49 @@ void QQuickWebEngineView::setDevToolsView(QQuickWebEngineView *devToolsView)
     Q_EMIT devToolsViewChanged();
 }
 
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
 void QQuickWebEngineView::grantFeaturePermission(const QUrl &securityOrigin, QQuickWebEngineView::Feature feature, bool granted)
 {
-    if (!granted && ((feature >= MediaAudioCapture && feature <= MediaAudioVideoCapture) ||
-                     (feature >= DesktopVideoCapture && feature <= DesktopAudioVideoCapture))) {
-         d_ptr->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaNone);
-         return;
-    }
+    Q_D(QQuickWebEngineView);
+    QWebEnginePermission::Feature f;
 
     switch (feature) {
-    case MediaAudioCapture:
-        d_ptr->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaAudioCapture);
+    case QQuickWebEngineView::Notifications:
+        f = QWebEnginePermission::Notifications;
         break;
-    case MediaVideoCapture:
-        d_ptr->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaVideoCapture);
+    case QQuickWebEngineView::Geolocation:
+        f = QWebEnginePermission::Geolocation;
         break;
-    case MediaAudioVideoCapture:
-        d_ptr->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaRequestFlags(WebContentsAdapterClient::MediaAudioCapture                                                                                                               | WebContentsAdapterClient::MediaVideoCapture));
+    case QQuickWebEngineView::MediaAudioCapture:
+        f = QWebEnginePermission::MediaAudioCapture;
         break;
-    case DesktopVideoCapture:
-        d_ptr->adapter->grantMediaAccessPermission(securityOrigin, WebContentsAdapterClient::MediaDesktopVideoCapture);
+    case QQuickWebEngineView::MediaVideoCapture:
+        f = QWebEnginePermission::MediaVideoCapture;
         break;
-    case DesktopAudioVideoCapture:
-        d_ptr->adapter->grantMediaAccessPermission(
-            securityOrigin,
-            WebContentsAdapterClient::MediaRequestFlags(
-                WebContentsAdapterClient::MediaDesktopAudioCapture |
-                WebContentsAdapterClient::MediaDesktopVideoCapture));
+    case QQuickWebEngineView::MediaAudioVideoCapture:
+        f = QWebEnginePermission::MediaAudioVideoCapture;
         break;
-    case Geolocation:
-        d_ptr->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::GeolocationPermission,
-                                               granted ? ProfileAdapter::AllowedPermission : ProfileAdapter::DeniedPermission);
+    case QQuickWebEngineView::DesktopVideoCapture:
+        f = QWebEnginePermission::DesktopVideoCapture;
         break;
-    case Notifications:
-        d_ptr->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::NotificationPermission,
-                                               granted ? ProfileAdapter::AllowedPermission : ProfileAdapter::DeniedPermission);
+    case QQuickWebEngineView::DesktopAudioVideoCapture:
+        f = QWebEnginePermission::DesktopAudioVideoCapture;
         break;
-    case ClipboardReadWrite:
-        d_ptr->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::ClipboardReadWrite,
-                                               granted ? ProfileAdapter::AllowedPermission
-                                                       : ProfileAdapter::DeniedPermission);
+    case QQuickWebEngineView::ClipboardReadWrite:
+        f = QWebEnginePermission::ClipboardReadWrite;
         break;
-    case LocalFontsAccess:
-        d_ptr->adapter->grantFeaturePermission(securityOrigin, ProfileAdapter::LocalFontsPermission,
-                                               granted ? ProfileAdapter::AllowedPermission : ProfileAdapter::DeniedPermission);
+    case QQuickWebEngineView::LocalFontsAccess:
+        f = QWebEnginePermission::LocalFontsAccess;
         break;
     default:
         Q_UNREACHABLE();
     }
+
+    d->adapter->setFeaturePermission(securityOrigin, f, granted ? QWebEnginePermission::Granted : QWebEnginePermission::Denied);
 }
+QT_WARNING_POP
+#endif // QT_DEPRECATED_SINCE(6, 8)
 
 void QQuickWebEngineView::setActiveFocusOnPress(bool arg)
 {
diff --git a/src/webenginequick/api/qquickwebengineview_p.h b/src/webenginequick/api/qquickwebengineview_p.h
index a310e0934..ea09dff9f 100644
--- a/src/webenginequick/api/qquickwebengineview_p.h
+++ b/src/webenginequick/api/qquickwebengineview_p.h
@@ -20,6 +20,7 @@
 #include <QtWebEngineCore/qwebenginedesktopmediarequest.h>
 #include <QtWebEngineCore/qwebenginedownloadrequest.h>
 #include <QtWebEngineCore/qwebengineframe.h>
+#include <QtWebEngineCore/qwebenginepermission.h>
 #include <QtWebEngineQuick/private/qtwebenginequickglobal_p.h>
 #include <QtGui/qcolor.h>
 #include <QtQml/qqmlregistration.h>
@@ -166,8 +167,12 @@ QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
     Q_ENUM(NewViewDestination)
 QT_WARNING_POP
 #endif
-
-    enum Feature {
+#if QT_DEPRECATED_SINCE(6, 8)
+QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
+    enum QT_DEPRECATED_VERSION_X_6_8(
+        "WebEnginePage::Feature has been deprecated. "
+        "The updated permissions API uses WebEnginePermission::Feature.")
+    Feature {
         MediaAudioCapture,
         MediaVideoCapture,
         MediaAudioVideoCapture,
@@ -179,6 +184,8 @@ QT_WARNING_POP
         LocalFontsAccess,
     };
     Q_ENUM(Feature)
+QT_WARNING_POP
+#endif
 
     enum WebAction {
         NoWebAction = - 1,
@@ -489,7 +496,17 @@ public Q_SLOTS:
     void stop();
     Q_REVISION(1,1) void findText(const QString &subString, FindFlags options = { }, const QJSValue &callback = QJSValue());
     Q_REVISION(1,1) void fullScreenCancelled();
+#if QT_DEPRECATED_SINCE(6, 8)
+#if !defined(Q_MOC_RUN)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+#endif // !defined(Q_MOC_RUN)
+    QT_DEPRECATED_VERSION_X_6_8("Setting permissions through WebEngineView has been deprecated. Please use WebEnginePermission instead.")
     Q_REVISION(1,1) void grantFeaturePermission(const QUrl &securityOrigin, QQuickWebEngineView::Feature, bool granted);
+#if !defined(Q_MOC_RUN)
+QT_WARNING_POP
+#endif // !defined(Q_MOC_RUN)
+#endif // QT_DEPRECATED_SINCE(6, 8)
     Q_REVISION(1,2) void setActiveFocusOnPress(bool arg);
     Q_REVISION(1,2) void triggerWebAction(WebAction action);
     Q_REVISION(1,3) void printToPdf(const QString &filePath, PrintedPageSizeId pageSizeId = PrintedPageSizeId::A4, PrintedPageOrientation orientation = PrintedPageOrientation::Portrait);
@@ -515,9 +532,19 @@ Q_SIGNALS:
     Q_REVISION(1,1) void certificateError(const QWebEngineCertificateError &error);
     Q_REVISION(1,1) void fullScreenRequested(const QWebEngineFullScreenRequest &request);
     Q_REVISION(1,1) void isFullScreenChanged();
+#if QT_DEPRECATED_SINCE(6, 8)
+#if !defined(Q_MOC_RUN)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+#endif // !defined(Q_MOC_RUN)
+    QT_MOC_COMPAT QT_DEPRECATED_VERSION_X_6_8("The signal has been deprecated; please use permissionRequested instead.")
     Q_REVISION(1, 1)
     void featurePermissionRequested(const QUrl &securityOrigin,
                                     QQuickWebEngineView::Feature feature);
+#if !defined(Q_MOC_RUN)
+QT_WARNING_POP
+#endif // !defined(Q_MOC_RUN)
+#endif // QT_DEPRECATED_SINCE(6, 8)
     Q_REVISION(1,1) void zoomFactorChanged(qreal arg);
     Q_REVISION(1,1) void profileChanged();
     Q_REVISION(1,1) void webChannelChanged();
@@ -562,6 +589,7 @@ Q_SIGNALS:
     Q_REVISION(6, 7) void webAuthUxRequested(QWebEngineWebAuthUxRequest *request);
     Q_REVISION(6,7) void desktopMediaRequested(const QWebEngineDesktopMediaRequest &request);
     Q_REVISION(6, 8) void printRequestedByFrame(QWebEngineFrame frame);
+    Q_REVISION(6,8) void permissionRequested(QWebEnginePermission permissionRequest);
 
 protected:
     void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override;
diff --git a/src/webenginequick/api/qquickwebengineview_p_p.h b/src/webenginequick/api/qquickwebengineview_p_p.h
index 988a2f0b1..e61f32bcb 100644
--- a/src/webenginequick/api/qquickwebengineview_p_p.h
+++ b/src/webenginequick/api/qquickwebengineview_p_p.h
@@ -114,7 +114,7 @@ public:
     void allowCertificateError(const QWebEngineCertificateError &error) override;
     void selectClientCert(const QSharedPointer<QtWebEngineCore::ClientCertSelectController>
                                   &selectController) override;
-    void runFeaturePermissionRequest(QtWebEngineCore::ProfileAdapter::PermissionType permission, const QUrl &securityOrigin) override;
+    void runFeaturePermissionRequest(QWebEnginePermission::Feature feature, const QUrl &securityOrigin) override;
     void renderProcessTerminated(RenderProcessTerminationStatus terminationStatus, int exitCode) override;
     void requestGeometryChange(const QRect &geometry, const QRect &frameGeometry) override;
     void updateScrollPosition(const QPointF &position) override;
@@ -139,6 +139,7 @@ public:
                            const QRect &bounds, bool autoselectFirstSuggestion) override;
     void hideAutofillPopup() override;
     void showWebAuthDialog(QWebEngineWebAuthUxRequest *request) override;
+    QWebEnginePermission createFeaturePermissionObject(const QUrl &securityOrigin, QWebEnginePermission::Feature feature) override;
 
     void updateAction(QQuickWebEngineView::WebAction) const;
     bool adoptWebContents(QtWebEngineCore::WebContentsAdapter *webContents);
diff --git a/src/webenginequick/doc/src/webengine_permission.qdoc b/src/webenginequick/doc/src/webengine_permission.qdoc
new file mode 100644
index 000000000..f59f57fa0
--- /dev/null
+++ b/src/webenginequick/doc/src/webengine_permission.qdoc
@@ -0,0 +1,137 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
+
+/*!
+    \qmltype webEnginePermission
+    \instantiates QWebEnginePermission
+    \inqmlmodule QtWebEngine
+    \brief An object used to access and modify the state of a single permission that's been
+    granted or denied to a specific origin URL.
+
+    The typical usage pattern is as follows:
+    \list 1
+        \li A website requests a specific feature, triggering the WebEngineView::permissionRequested signal;
+        \li The signal handler triggers a prompt asking the user whether they want to grant the permission;
+        \li When the user has made their decision, the application calls \l grant() or \l deny();
+    \endlist
+
+    Alternatively, an application interested in modifying already granted permissions may use WebEngineProfile::listPermissions()
+    to get a list of existing permissions associated with a profile, or WebEngineProfile::getPermission() to get
+    a webEnginePermission object for a specific permission.
+
+    The \l origin property can be used to query which origin the webEnginePermission is associated with, while the
+    \l feature property describes the associated feature. A website origin is the combination of its scheme, hostname,
+    and port. Permissions are granted on a per-origin basis; thus, if the web page \c{https://www.example.com:12345/some/page.html}
+    requests a permission, it will be granted to the origin \c{https://www.example.com:12345/}.
+
+    The usability lifetime of a webEnginePermission is tied either to its associated WebEngineView
+    (for transient feature types), or WebEngineProfile (for permanent feature types). A transient permission is one which
+    needs to be explicitly granted or denied every time it's needed (e.g. webcam/screen sharing permission), whereas a permanent
+    one might be stored inside the current profile, depending on the value of WebEngineProfile::persistentPermissionsPolicy.
+    You can check whether a webEnginePermission is in a valid state using its \l isValid() property. For invalid objects, calls to \l grant(),
+    \l deny(), or \l reset() will do nothing, and their \l state() will always be WebEnginePermission.Invalid.
+
+    The feature types Qt WebEngine supports are described in \l feature.
+
+    \sa WebEngineView::permissionRequested, WebEngineProfile::getPermission(),
+    WebEngineProfile::listPermissions()
+*/
+
+/*!
+    \qmlproperty url webEnginePermission::origin
+    \brief The URL of the permission's associated origin.
+
+    A website origin is the combination of its scheme, hostname, and port. Permissions are granted on a
+    per-origin basis; thus, if the web page \c{https://www.example.com:12345/some/page.html}
+    requests a permission, it will be granted to the origin \c{https://www.example.com:12345/}.
+*/
+
+/*!
+    \qmlproperty enumeration webEnginePermission::feature
+    \brief The feature type associated with this permission.
+
+    \value WebEnginePermission.MediaAudioCapture Access to a microphone, or another audio source. This feature is transient.
+    \value WebEnginePermission.MediaVideoCapture Access to a webcam, or another video source. This feature is transient.
+    \value WebEnginePermission.MediaAudioVideoCapture Combination of \l MediaAudioCapture and \l MediaVideoCapture. This feature is transient.
+    \value WebEnginePermission.DesktopVideoCapture Access to the contents of the user's screen. This feature is transient.
+    \value WebEnginePermission.DesktopAudioVideoCapture Access to the contents of the user's screen, and application audio. This feature is transient.
+    \value WebEnginePermission.MouseLock Locks the pointer inside an element on the web page. This feature is transient.
+    \value WebEnginePermission.Notifications Allows the website to send notifications to the user.
+    \value WebEnginePermission.Geolocation Access to the user's physical location.
+    \value WebEnginePermission.ClipboardReadWrite Access to the user's clipboard.
+    \value WebEnginePermission.LocalFontsAccess Access to the fonts installed on the user's machine. Only available on desktops.
+    \value WebEnginePermission.Unsupported An unsupported feature type.
+
+    \note Transient feature types are ones that will never be remembered by the underlying storage, and will trigger
+    a permission request every time a website tries to use them.
+*/
+
+/*!
+    \qmlproperty enumeration webEnginePermission::state
+    \brief The current state of the permission.
+
+    \value WebEnginePermission.Invalid Object is in an invalid state, and any attempts to modify the described permission will fail.
+    \value WebEnginePermission.Ask Either the permission has not been requested before, or the feature() is transient.
+    \value WebEnginePermission.Granted Permission has already been granted.
+    \value WebEnginePermission.Denied Permission has already been denied.
+
+    If a permission for the specified \l feature and \l origin has already been granted or denied,
+    the return value is WebEnginePermission.Granted, or WebEnginePermission.Denied, respectively.
+    When this is the first time the permission is requested, or if the \l feature is transient,
+    the return value is WebEnginePermission.Ask. If the object is in an invalid state, the returned
+    value is WebEnginePermission.Invalid.
+
+    \sa isValid, isTransient
+*/
+
+/*!
+    \qmlproperty bool webEnginePermission::isValid
+    \brief Indicates whether attempts to change the permission's state will be successful.
+
+    An invalid webEnginePermission is either:
+    \list
+        \li One whose \l feature is unsupported;
+        \li One whose \l feature is transient, and the associated page/view has been destroyed;
+        \li One whose \l feature is permanent, but the associated profile has been destroyed;
+        \li One whose \l origin is invalid.
+    \endlist
+
+    \sa isTransient
+*/
+
+/*!
+    \qmlmethod void webEnginePermission::grant()
+
+    Allows the associated origin to access the requested feature. Does nothing when \l isValid evaluates to false.
+
+    \sa deny, reset, isValid
+*/
+
+/*!
+    \qmlmethod void webEnginePermission::deny()
+
+    Stops the associated origin from accessing the requested feature. Does nothing when \l isValid evaluates to false.
+
+    \sa grant, reset, isValid
+*/
+
+/*!
+    \qmlmethod void webEnginePermission::reset()
+
+    Removes the permission from the profile's underlying storage. By default, permissions are stored on disk (except for
+    off-the-record profiles, where permissions are stored in memory and are destroyed with the profile).
+    This means that an already granted/denied permission will not be requested twice, but will get automatically
+    granted/denied every subsequent time a website requests it. Calling reset() allows the query to be asked
+    again the next time the website requests it.
+
+    Does nothing when \l isValid evaluates to false.
+
+    \sa grant, deny, isValid, WebEngineProfile::persistentPermissionsPolicy
+*/
+
+/*!
+    \qmlmethod void webEnginePermission::isTransient(WebEnginePermission.Feature feature)
+
+    Returns whether \a feature is transient, meaning that a permission will be requested
+    every time the associated functionality is used by a web page.
+*/
diff --git a/src/webenginequick/doc/src/webengineview_lgpl.qdoc b/src/webenginequick/doc/src/webengineview_lgpl.qdoc
index 82bf605ca..f7b17fa7b 100644
--- a/src/webenginequick/doc/src/webengineview_lgpl.qdoc
+++ b/src/webenginequick/doc/src/webengineview_lgpl.qdoc
@@ -111,10 +111,9 @@
     \section2 Platform Features
 
     Web pages can request access to platform features, such as geolocation or audio and video
-    capture devices. The \l featurePermissionRequested() signal is emitted when a web page requests
-    to make use of a resource. The supported platform features are described by the \l Feature
-    property. If users grant the permission, the \l grantFeaturePermission() method is used to set
-    it to \e granted.
+    capture devices. The \l permissionRequested() signal is emitted when a web page requests
+    to make use of a resource. The supported platform features are described by the QWebEnginePermission::Feature
+    property.
 
     \section2 Rendering to OpenGL Surface
 
@@ -445,6 +444,7 @@
 /*!
     \qmlmethod void WebEngineView::grantFeaturePermission(url securityOrigin, Feature feature, bool granted)
     \since QtWebEngine 1.1
+    \deprecated [6.8] Use webEnginePermission.grant() or webEnginePermission.deny() instead.
 
     Sets or unsets the permission, depending on \a granted, for the web site
     identified by \a securityOrigin to use \a feature.
@@ -501,6 +501,7 @@
 /*!
     \qmlsignal WebEngineView::featurePermissionRequested(url securityOrigin, Feature feature)
     \since QtWebEngine 1.1
+    \deprecated [6.8] Use \l permissionRequested() instead.
 
     This signal is emitted when the web site identified by \a securityOrigin requests
     to make use of the resource or device identified by \a feature.
@@ -509,6 +510,15 @@
 */
 
 /*!
+    \qmlsignal WebEngineView::permissionRequested(webEnginePermission permission)
+    \since QtWebEngine 6.8
+
+    This signal is emitted when a web site requests to make use of a feature (e.g. geolocation access,
+    permission to send notifications). The \a permission object can queried for the requesting URL
+    and the \c{WebEnginePermission.Feature} it's asking for, as well as to grant or deny permission.
+*/
+
+/*!
     \qmlsignal WebEngineView::loadingChanged(WebEngineLoadingInfo loadingInfo)
 
     This signal is emitted when a page load begins, ends, or fails.
@@ -844,6 +854,7 @@
 
 /*!
     \qmlproperty enumeration WebEngineView::Feature
+    \deprecated [6.8] Replaced by WebEnginePermission.Feature.
 
     Describes the platform feature access categories that the user may be asked to grant or deny
     access to:
diff --git a/tests/auto/quick/publicapi/tst_publicapi.cpp b/tests/auto/quick/publicapi/tst_publicapi.cpp
index c4d889cbe..cf0e59274 100644
--- a/tests/auto/quick/publicapi/tst_publicapi.cpp
+++ b/tests/auto/quick/publicapi/tst_publicapi.cpp
@@ -26,6 +26,7 @@
 #include <QtWebEngineCore/QWebEngineLoadingInfo>
 #include <QtWebEngineCore/QWebEngineWebAuthUxRequest>
 #include <QtWebEngineCore/QWebEngineFrame>
+#include <QtWebEngineCore/QWebEnginePermission>
 #include <private/qquickwebengineview_p.h>
 #include <private/qquickwebengineaction_p.h>
 #include <private/qquickwebengineclientcertificateselection_p.h>
@@ -72,6 +73,7 @@ static const QList<const QMetaObject *> typesToCheck = QList<const QMetaObject *
     << &QWebEngineNavigationRequest::staticMetaObject
     << &QWebEngineNewWindowRequest::staticMetaObject
     << &QWebEngineNotification::staticMetaObject
+    << &QWebEnginePermission::staticMetaObject
     << &QWebEngineQuotaRequest::staticMetaObject
     << &QWebEngineRegisterProtocolHandlerRequest::staticMetaObject
     << &QQuickWebEngineTouchSelectionMenuRequest::staticMetaObject
@@ -82,6 +84,7 @@ static const QList<const QMetaObject *> typesToCheck = QList<const QMetaObject *
 
 static QList<QMetaEnum> knownEnumNames = QList<QMetaEnum>()
     << QWebEngineDownloadRequest::staticMetaObject.enumerator(QWebEngineDownloadRequest::staticMetaObject.indexOfEnumerator("SavePageFormat"))
+    << QWebEnginePermission::staticMetaObject.enumerator(QWebEnginePermission::staticMetaObject.indexOfEnumerator("Feature"))
     ;
 
 static const QStringList hardcodedTypes = QStringList()
@@ -353,6 +356,29 @@ static const QStringList expectedAPI = QStringList()
     << "QWebEngineNewWindowRequest.InNewDialog --> DestinationType"
     << "QWebEngineNewWindowRequest.InNewTab --> DestinationType"
     << "QWebEngineNewWindowRequest.InNewWindow --> DestinationType"
+    << "QWebEnginePermission.Unsupported --> Feature"
+    << "QWebEnginePermission.MediaAudioCapture --> Feature"
+    << "QWebEnginePermission.MediaVideoCapture --> Feature"
+    << "QWebEnginePermission.MediaAudioVideoCapture --> Feature"
+    << "QWebEnginePermission.DesktopVideoCapture --> Feature"
+    << "QWebEnginePermission.DesktopAudioVideoCapture --> Feature"
+    << "QWebEnginePermission.MouseLock --> Feature"
+    << "QWebEnginePermission.Notifications --> Feature"
+    << "QWebEnginePermission.Geolocation --> Feature"
+    << "QWebEnginePermission.ClipboardReadWrite --> Feature"
+    << "QWebEnginePermission.LocalFontsAccess --> Feature"
+    << "QWebEnginePermission.Invalid --> State"
+    << "QWebEnginePermission.Ask --> State"
+    << "QWebEnginePermission.Granted --> State"
+    << "QWebEnginePermission.Denied --> State"
+    << "QWebEnginePermission.origin --> QUrl"
+    << "QWebEnginePermission.feature --> QWebEnginePermission::Feature"
+    << "QWebEnginePermission.state --> QWebEnginePermission::State"
+    << "QWebEnginePermission.isValid --> bool"
+    << "QWebEnginePermission.grant() --> void"
+    << "QWebEnginePermission.deny() --> void"
+    << "QWebEnginePermission.reset() --> void"
+    << "QWebEnginePermission.isTransient(QWebEnginePermission::Feature) --> bool"
     << "QQuickWebEngineNewWindowRequest.openIn(QQuickWebEngineView*) --> void"
     << "QQuickWebEngineProfile.AllowPersistentCookies --> PersistentCookiesPolicy"
     << "QQuickWebEngineProfile.DiskHttpCache --> HttpCacheType"
@@ -537,10 +563,20 @@ static const QStringList expectedAPI = QStringList()
     << "QQuickWebEngineView.B10 --> PrintedPageSizeId"
     << "QQuickWebEngineView.Back --> WebAction"
     << "QQuickWebEngineView.C5E --> PrintedPageSizeId"
+#if QT_DEPRECATED_SINCE(6, 8)
+    << "QQuickWebEngineView.ClipboardReadWrite --> Feature"
+    << "QQuickWebEngineView.DesktopAudioVideoCapture --> Feature"
+    << "QQuickWebEngineView.DesktopVideoCapture --> Feature"
+    << "QQuickWebEngineView.Geolocation --> Feature"
+    << "QQuickWebEngineView.LocalFontsAccess --> Feature"
+    << "QQuickWebEngineView.MediaAudioCapture --> Feature"
+    << "QQuickWebEngineView.MediaAudioVideoCapture --> Feature"
+    << "QQuickWebEngineView.MediaVideoCapture --> Feature"
+    << "QQuickWebEngineView.Notifications --> Feature"
+#endif
     << "QQuickWebEngineView.CertificateErrorDomain --> ErrorDomain"
     << "QQuickWebEngineView.ChangeTextDirectionLTR --> WebAction"
     << "QQuickWebEngineView.ChangeTextDirectionRTL --> WebAction"
-    << "QQuickWebEngineView.ClipboardReadWrite --> Feature"
     << "QQuickWebEngineView.Comm10E --> PrintedPageSizeId"
     << "QQuickWebEngineView.ConnectionErrorDomain --> ErrorDomain"
     << "QQuickWebEngineView.Copy --> WebAction"
@@ -552,8 +588,6 @@ static const QStringList expectedAPI = QStringList()
     << "QQuickWebEngineView.Custom --> PrintedPageSizeId"
     << "QQuickWebEngineView.Cut --> WebAction"
     << "QQuickWebEngineView.DLE --> PrintedPageSizeId"
-    << "QQuickWebEngineView.DesktopAudioVideoCapture --> Feature"
-    << "QQuickWebEngineView.DesktopVideoCapture --> Feature"
     << "QQuickWebEngineView.DnsErrorDomain --> ErrorDomain"
     << "QQuickWebEngineView.DoublePostcard --> PrintedPageSizeId"
     << "QQuickWebEngineView.DownloadImageToDisk --> WebAction"
@@ -608,7 +642,6 @@ static const QStringList expectedAPI = QStringList()
     << "QQuickWebEngineView.Folio --> PrintedPageSizeId"
     << "QQuickWebEngineView.Forward --> WebAction"
     << "QQuickWebEngineView.FtpErrorDomain --> ErrorDomain"
-    << "QQuickWebEngineView.Geolocation --> Feature"
     << "QQuickWebEngineView.HttpErrorDomain --> ErrorDomain"
     << "QQuickWebEngineView.Imperial10x11 --> PrintedPageSizeId"
     << "QQuickWebEngineView.Imperial10x13 --> PrintedPageSizeId"
@@ -653,12 +686,7 @@ static const QStringList expectedAPI = QStringList()
     << "QQuickWebEngineView.LoadStartedStatus --> LoadStatus"
     << "QQuickWebEngineView.LoadStoppedStatus --> LoadStatus"
     << "QQuickWebEngineView.LoadSucceededStatus --> LoadStatus"
-    << "QQuickWebEngineView.LocalFontsAccess --> Feature"
-    << "QQuickWebEngineView.MediaAudioCapture --> Feature"
-    << "QQuickWebEngineView.MediaAudioVideoCapture --> Feature"
-    << "QQuickWebEngineView.MediaVideoCapture --> Feature"
     << "QQuickWebEngineView.NoErrorDomain --> ErrorDomain"
-    << "QQuickWebEngineView.Notifications --> Feature"
     << "QQuickWebEngineView.NoWebAction --> WebAction"
     << "QQuickWebEngineView.NormalTerminationStatus --> RenderProcessTerminationStatus"
     << "QQuickWebEngineView.Note --> PrintedPageSizeId"
@@ -734,7 +762,9 @@ static const QStringList expectedAPI = QStringList()
     << "QQuickWebEngineView.goBack() --> void"
     << "QQuickWebEngineView.goBackOrForward(int) --> void"
     << "QQuickWebEngineView.goForward() --> void"
+#if QT_DEPRECATED_SINCE(6, 8)
     << "QQuickWebEngineView.grantFeaturePermission(QUrl,QQuickWebEngineView::Feature,bool) --> void"
+#endif
     << "QQuickWebEngineView.history --> QWebEngineHistory*"
     << "QQuickWebEngineView.icon --> QUrl"
     << "QQuickWebEngineView.iconChanged() --> void"
@@ -769,6 +799,7 @@ static const QStringList expectedAPI = QStringList()
     << "QQuickWebEngineView.NewViewInDialog --> NewViewDestination"
     << "QQuickWebEngineView.NewViewInTab --> NewViewDestination"
     << "QQuickWebEngineView.NewViewInWindow --> NewViewDestination"
+    << "QQuickWebEngineView.permissionRequested(QWebEnginePermission) --> void"
     << "QQuickWebEngineView.pdfPrintingFinished(QString,bool) --> void"
     << "QQuickWebEngineView.printRequested() --> void"
     << "QQuickWebEngineView.printRequestedByFrame(QWebEngineFrame) --> void"
@@ -1020,4 +1051,3 @@ void tst_publicapi::publicAPI()
 QTEST_MAIN(tst_publicapi)
 
 #include "tst_publicapi.moc"
-
diff --git a/tests/auto/quick/qmltests/data/tst_geopermission.qml b/tests/auto/quick/qmltests/data/tst_geopermission.qml
index c474033a9..e425a82c7 100644
--- a/tests/auto/quick/qmltests/data/tst_geopermission.qml
+++ b/tests/auto/quick/qmltests/data/tst_geopermission.qml
@@ -16,19 +16,19 @@ TestWebEngineView {
     profile.persistentPermissionsPolicy: WebEngineProfile.NoPersistentPermissions
 
     SignalSpy {
-        id: featurePermissionSpy
+        id: permissionSpy
         target: webEngineView
-        signalName: "featurePermissionRequested"
+        signalName: "permissionRequested"
     }
 
-    onFeaturePermissionRequested: function(securityOrigin, feature) {
-        if (feature === WebEngineView.Geolocation) {
+    onPermissionRequested: function(perm) {
+        if (perm.feature === WebEnginePermission.Geolocation) {
             geoPermissionRequested = true
             if (deniedGeolocation) {
-                webEngineView.grantFeaturePermission(securityOrigin, feature, false)
+                perm.deny()
             }
             else {
-                webEngineView.grantFeaturePermission(securityOrigin, feature, true)
+                perm.grant()
             }
         }
     }
@@ -57,15 +57,15 @@ TestWebEngineView {
 
         function init() {
             deniedGeolocation = false
-            featurePermissionSpy.clear()
+            permissionSpy.clear()
         }
 
         function test_geoPermissionRequest() {
-            compare(featurePermissionSpy.count, 0)
+            compare(permissionSpy.count, 0)
             webEngineView.url = Qt.resolvedUrl("geolocation.html")
-            featurePermissionSpy.wait()
+            permissionSpy.wait()
             verify(geoPermissionRequested)
-            compare(featurePermissionSpy.count, 1)
+            compare(permissionSpy.count, 1)
             tryVerify(isHandled, 5000)
             verify(getErrorMessage() === "")
         }
@@ -73,7 +73,7 @@ TestWebEngineView {
         function test_deniedGeolocationByUser() {
             deniedGeolocation = true
             webEngineView.url = Qt.resolvedUrl("geolocation.html")
-            featurePermissionSpy.wait()
+            permissionSpy.wait()
             tryVerify(isHandled, 5000)
             compare(getErrorMessage(), "User denied Geolocation")
         }
diff --git a/tests/auto/quick/qmltests/data/tst_getUserMedia.qml b/tests/auto/quick/qmltests/data/tst_getUserMedia.qml
index 653f7a5df..9a876778b 100644
--- a/tests/auto/quick/qmltests/data/tst_getUserMedia.qml
+++ b/tests/auto/quick/qmltests/data/tst_getUserMedia.qml
@@ -22,17 +22,17 @@ TestWebEngineView {
                 {
                     tag: "device audio",
                     constraints: { audio: true },
-                    feature: WebEngineView.MediaAudioCapture,
+                    feature: WebEnginePermission.MediaAudioCapture,
                 },
                 {
                     tag: "device video",
                     constraints: { video: true },
-                    feature: WebEngineView.MediaVideoCapture,
+                    feature: WebEnginePermission.MediaVideoCapture,
                 },
                 {
                     tag: "device audio+video",
                     constraints: { audio: true, video: true },
-                    feature: WebEngineView.MediaAudioVideoCapture,
+                    feature: WebEnginePermission.MediaAudioVideoCapture,
                 },
                 {
                     tag: "desktop video",
@@ -43,7 +43,7 @@ TestWebEngineView {
                             }
                         }
                     },
-                    feature: WebEngineView.DesktopVideoCapture,
+                    feature: WebEnginePermission.DesktopVideoCapture,
                 },
                 {
                     tag: "desktop audio+video",
@@ -59,7 +59,7 @@ TestWebEngineView {
                             }
                         }
                     },
-                    feature: WebEngineView.DesktopAudioVideoCapture,
+                    feature: WebEnginePermission.DesktopAudioVideoCapture,
                 }
             ]
         }
@@ -116,28 +116,24 @@ TestWebEngineView {
     ////
     // synchronous permission requests
 
-    property variant requestedFeature
-    property variant requestedSecurityOrigin
+    property variant permissionObject
 
-    onFeaturePermissionRequested: function(securityOrigin, feature) {
-        requestedFeature = feature
-        requestedSecurityOrigin = securityOrigin
+    onPermissionRequested: function(perm) {
+        permissionObject = perm
     }
 
     function gotFeatureRequest(expectedFeature) {
-        return requestedFeature == expectedFeature
+        return permissionObject && permissionObject.feature == expectedFeature
     }
 
     function acceptPendingRequest() {
-        webEngineView.grantFeaturePermission(requestedSecurityOrigin, requestedFeature, true)
-        requestedFeature = undefined
-        requestedSecurityOrigin = undefined
+        permissionObject.grant()
+        permissionObject = undefined
     }
 
     function rejectPendingRequest() {
-        webEngineView.grantFeaturePermission(requestedSecurityOrigin, requestedFeature, false)
-        requestedFeature = undefined
-        requestedSecurityOrigin = undefined
+        permissionObject.deny()
+        permissionObject = undefined
     }
 
     ////
diff --git a/tests/auto/quick/qmltests/data/tst_notification.qml b/tests/auto/quick/qmltests/data/tst_notification.qml
index 0bb33b41e..5defbff4b 100644
--- a/tests/auto/quick/qmltests/data/tst_notification.qml
+++ b/tests/auto/quick/qmltests/data/tst_notification.qml
@@ -13,7 +13,7 @@ TestWebEngineView {
 
     property bool permissionRequested: false
     property bool grantPermission: false
-    property url securityOrigin: ''
+    property var permissionObject
 
     profile.persistentPermissionsPolicy: WebEngineProfile.NoPersistentPermissions
 
@@ -22,14 +22,17 @@ TestWebEngineView {
     SignalSpy {
         id: spyRequest
         target: view
-        signalName: 'featurePermissionRequested'
+        signalName: 'permissionRequested'
     }
 
-    onFeaturePermissionRequested: function(securityOrigin, feature) {
-        if (feature === WebEngineView.Notifications) {
+    onPermissionRequested: function(perm) {
+        if (perm.feature === WebEnginePermission.Notifications) {
             view.permissionRequested = true
-            view.securityOrigin = securityOrigin
-            view.grantFeaturePermission(securityOrigin, feature, grantPermission)
+            view.permissionObject = perm
+            if (grantPermission)
+                perm.grant()
+            else
+                perm.deny()
         }
     }
 
@@ -93,7 +96,7 @@ TestWebEngineView {
             compare(notification.title, title)
             compare(notification.message, message)
             compare(notification.direction, Qt.RightToLeft)
-            compare(notification.origin, securityOrigin)
+            compare(notification.origin, permissionObject.origin)
             compare(notification.tag, 'tst')
             compare(notification.language, 'de')
         }
diff --git a/tests/auto/widgets/qwebenginepage/tst_qwebenginepage.cpp b/tests/auto/widgets/qwebenginepage/tst_qwebenginepage.cpp
index f6eac2880..8b6ea31fd 100644
--- a/tests/auto/widgets/qwebenginepage/tst_qwebenginepage.cpp
+++ b/tests/auto/widgets/qwebenginepage/tst_qwebenginepage.cpp
@@ -72,6 +72,7 @@
 #include <qwebengineurlscheme.h>
 #include <qwebengineurlschemehandler.h>
 #include <qwebengineview.h>
+#include <qwebenginepermission.h>
 #include <qimagewriter.h>
 #include <QColorSpace>
 #include <QQuickRenderControl>
@@ -451,12 +452,12 @@ public:
         return true;
     }
 public Q_SLOTS:
-    void requestPermission(const QUrl &origin, QWebEnginePage::Feature feature)
+    void requestPermission(QWebEnginePermission permission)
     {
         if (m_allowGeolocation)
-            setFeaturePermission(origin, feature, PermissionGrantedByUser);
+            permission.grant();
         else
-            setFeaturePermission(origin, feature, PermissionDeniedByUser);
+            permission.deny();
     }
 
 public:
@@ -488,8 +489,8 @@ void tst_QWebEnginePage::geolocationRequestJS()
     newPage->profile()->setPersistentPermissionsPolicy(QWebEngineProfile::NoPersistentPermissions);
     newPage->setGeolocationPermission(allowed);
 
-    connect(newPage, SIGNAL(featurePermissionRequested(const QUrl&, QWebEnginePage::Feature)),
-            newPage, SLOT(requestPermission(const QUrl&, QWebEnginePage::Feature)));
+    connect(newPage, SIGNAL(permissionRequested(QWebEnginePermission)),
+            newPage, SLOT(requestPermission(QWebEnginePermission)));
 
     QSignalSpy spyLoadFinished(newPage, SIGNAL(loadFinished(bool)));
     newPage->setHtml(QString("<html><body>test</body></html>"), QUrl("qrc://secure/origin"));
@@ -1656,8 +1657,9 @@ public:
     GetUserMediaTestPage()
         : m_gotRequest(false)
         , m_loadSucceeded(false)
+        , m_permission(nullptr)
     {
-        connect(this, &QWebEnginePage::featurePermissionRequested, this, &GetUserMediaTestPage::onFeaturePermissionRequested);
+        connect(this, &QWebEnginePage::permissionRequested, this, &GetUserMediaTestPage::onPermissionRequested);
         connect(this, &QWebEnginePage::loadFinished, [this](bool success){
             m_loadSucceeded = success;
         });
@@ -1695,18 +1697,20 @@ public:
 
     void rejectPendingRequest()
     {
-        setFeaturePermission(m_requestSecurityOrigin, m_requestedFeature, QWebEnginePage::PermissionDeniedByUser);
+        QVERIFY(m_permission);
+        m_permission->deny();
         m_gotRequest = false;
     }
     void acceptPendingRequest()
     {
-        setFeaturePermission(m_requestSecurityOrigin, m_requestedFeature, QWebEnginePage::PermissionGrantedByUser);
+        QVERIFY(m_permission);
+        m_permission->grant();
         m_gotRequest = false;
     }
 
-    bool gotFeatureRequest(QWebEnginePage::Feature feature)
+    bool gotFeatureRequest(QWebEnginePermission::Feature feature)
     {
-        return m_gotRequest && m_requestedFeature == feature;
+        return m_gotRequest && m_permission && m_permission->feature() == feature;
     }
 
     bool gotFeatureRequest() const
@@ -1720,50 +1724,47 @@ public:
     }
 
 private Q_SLOTS:
-    void onFeaturePermissionRequested(const QUrl &securityOrigin, QWebEnginePage::Feature feature)
+    void onPermissionRequested(QWebEnginePermission permission)
     {
-        m_requestedFeature = feature;
-        m_requestSecurityOrigin = securityOrigin;
+        m_permission.reset(new QWebEnginePermission(permission));
         m_gotRequest = true;
     }
 
 private:
     bool m_gotRequest;
     bool m_loadSucceeded;
-    QWebEnginePage::Feature m_requestedFeature;
-    QUrl m_requestSecurityOrigin;
-
+    std::unique_ptr<QWebEnginePermission> m_permission;
 };
 
 void tst_QWebEnginePage::getUserMediaRequest_data()
 {
     QTest::addColumn<QString>("call");
-    QTest::addColumn<QWebEnginePage::Feature>("feature");
+    QTest::addColumn<QWebEnginePermission::Feature>("feature");
 
     QTest::addRow("device audio")
-        << "getUserMedia({audio: true})" << QWebEnginePage::MediaAudioCapture;
+        << "getUserMedia({audio: true})" << QWebEnginePermission::MediaAudioCapture;
     QTest::addRow("device video")
-        << "getUserMedia({video: true})" << QWebEnginePage::MediaVideoCapture;
+        << "getUserMedia({video: true})" << QWebEnginePermission::MediaVideoCapture;
     QTest::addRow("device audio+video")
-        << "getUserMedia({audio: true, video: true})" << QWebEnginePage::MediaAudioVideoCapture;
+        << "getUserMedia({audio: true, video: true})" << QWebEnginePermission::MediaAudioVideoCapture;
     QTest::addRow("desktop video")
         << "getUserMedia({video: { mandatory: { chromeMediaSource: 'desktop' }}})"
-        << QWebEnginePage::DesktopVideoCapture;
+        << QWebEnginePermission::DesktopVideoCapture;
     QTest::addRow("desktop audio+video")
         << "getUserMedia({audio: { mandatory: { chromeMediaSource: 'desktop' }}, video: { mandatory: { chromeMediaSource: 'desktop' }}})"
-        << QWebEnginePage::DesktopAudioVideoCapture;
+        << QWebEnginePermission::DesktopAudioVideoCapture;
     QTest::addRow("display video")
-        << "getDisplayMedia()" << QWebEnginePage::DesktopVideoCapture;
+        << "getDisplayMedia()" << QWebEnginePermission::DesktopVideoCapture;
 }
 
 void tst_QWebEnginePage::getUserMediaRequest()
 {
     QFETCH(QString, call);
-    QFETCH(QWebEnginePage::Feature, feature);
+    QFETCH(QWebEnginePermission::Feature, feature);
 
     GetUserMediaTestPage page;
     QWebEngineView view;
-    if (feature == QWebEnginePage::DesktopVideoCapture || feature == QWebEnginePage::DesktopAudioVideoCapture) {
+    if (feature == QWebEnginePermission::DesktopVideoCapture || feature == QWebEnginePermission::DesktopAudioVideoCapture) {
         // Desktop capture needs to be on a desktop.
         view.setPage(&page);
         view.resize(640, 480);
@@ -1833,7 +1834,7 @@ void tst_QWebEnginePage::getUserMediaRequestSettingDisabled()
 void tst_QWebEnginePage::getUserMediaRequestDesktopVideoManyPages()
 {
     const QString constraints = QStringLiteral("{video: { mandatory: { chromeMediaSource: 'desktop' }}}");
-    const QWebEnginePage::Feature feature = QWebEnginePage::DesktopVideoCapture;
+    const QWebEnginePermission::Feature feature = QWebEnginePermission::DesktopVideoCapture;
     std::vector<GetUserMediaTestPage> pages(10);
 
     // Desktop capture needs to be on a desktop
@@ -1866,7 +1867,7 @@ void tst_QWebEnginePage::getUserMediaRequestDesktopVideoManyPages()
 void tst_QWebEnginePage::getUserMediaRequestDesktopVideoManyRequests()
 {
     const QString constraints = QStringLiteral("{video: { mandatory: { chromeMediaSource: 'desktop' }}}");
-    const QWebEnginePage::Feature feature = QWebEnginePage::DesktopVideoCapture;
+    const QWebEnginePermission::Feature feature = QWebEnginePermission::DesktopVideoCapture;
     GetUserMediaTestPage page;
 
     // Desktop capture needs to be on a desktop
@@ -3795,20 +3796,30 @@ void tst_QWebEnginePage::dynamicFrame()
 
 struct NotificationPage : ConsolePage {
     Q_OBJECT
-    const QWebEnginePage::PermissionPolicy policy;
+    const QWebEnginePermission::State policy;
 
 public:
-    NotificationPage(QWebEnginePage::PermissionPolicy ppolicy) : policy(ppolicy) {
+    NotificationPage(QWebEnginePermission::State ppolicy) : policy(ppolicy) {
         connect(this, &QWebEnginePage::loadFinished, [load = spyLoad.ref()] (bool result) mutable { load(result); });
 
-        connect(this, &QWebEnginePage::featurePermissionRequested,
-                [this] (const QUrl &origin, QWebEnginePage::Feature feature) {
-            if (feature != QWebEnginePage::Notifications)
+        connect(this, &QWebEnginePage::permissionRequested,
+                [this] (QWebEnginePermission permission) {
+            if (permission.feature() != QWebEnginePermission::Notifications)
                 return;
             if (spyRequest.wasCalled())
                 QFAIL("request executed twise!");
-            setFeaturePermission(origin, feature, policy);
-            spyRequest.ref()(origin);
+            switch (policy) {
+            case QWebEnginePermission::Granted:
+                permission.grant();
+                break;
+            case QWebEnginePermission::Denied:
+                permission.deny();
+                break;
+            case QWebEnginePermission::Ask:
+                permission.reset();
+                break;
+            }
+            spyRequest.ref()(permission.origin());
         });
 
         load(QStringLiteral("qrc:///shared/notification.html"));
@@ -3828,18 +3839,18 @@ public:
 void tst_QWebEnginePage::notificationPermission_data()
 {
     QTest::addColumn<bool>("setOnInit");
-    QTest::addColumn<QWebEnginePage::PermissionPolicy>("policy");
+    QTest::addColumn<QWebEnginePermission::State>("policy");
     QTest::addColumn<QString>("permission");
-    QTest::newRow("denyOnInit")  << true  << QWebEnginePage::PermissionDeniedByUser << "denied";
-    QTest::newRow("deny")        << false << QWebEnginePage::PermissionDeniedByUser << "denied";
-    QTest::newRow("grant")       << false << QWebEnginePage::PermissionGrantedByUser << "granted";
-    QTest::newRow("grantOnInit") << true  << QWebEnginePage::PermissionGrantedByUser << "granted";
+    QTest::newRow("denyOnInit")  << true  << QWebEnginePermission::Denied << "denied";
+    QTest::newRow("deny")        << false << QWebEnginePermission::Denied << "denied";
+    QTest::newRow("grant")       << false << QWebEnginePermission::Granted << "granted";
+    QTest::newRow("grantOnInit") << true  << QWebEnginePermission::Granted << "granted";
 }
 
 void tst_QWebEnginePage::notificationPermission()
 {
     QFETCH(bool, setOnInit);
-    QFETCH(QWebEnginePage::PermissionPolicy, policy);
+    QFETCH(QWebEnginePermission::State, policy);
     QFETCH(QString, permission);
 
     QWebEngineProfile otr;
@@ -3849,20 +3860,33 @@ void tst_QWebEnginePage::notificationPermission()
     QUrl baseUrl("https://www.example.com/somepage.html");
 
     bool permissionRequested = false, errorState = false;
-    connect(&page, &QWebEnginePage::featurePermissionRequested, &page, [&] (const QUrl &o, QWebEnginePage::Feature f) {
-        if (f != QWebEnginePage::Notifications)
+    connect(&page, &QWebEnginePage::permissionRequested, &page, [&] (QWebEnginePermission permission) {
+        if (permission.feature() != QWebEnginePermission::Notifications)
             return;
-        if (permissionRequested || o != baseUrl.url(QUrl::RemoveFilename)) {
-            qWarning() << "Unexpected case. Can't proceed." << setOnInit << permissionRequested << o;
+        if (permissionRequested || permission.origin() != baseUrl.url(QUrl::RemoveFilename)) {
+            qWarning() << "Unexpected case. Can't proceed." << setOnInit << permissionRequested << permission.origin();
             errorState = true;
             return;
         }
         permissionRequested = true;
-        page.setFeaturePermission(o, f, policy);
+
+        if (policy == QWebEnginePermission::Granted)
+            permission.grant();
+        else
+            permission.deny();
     });
 
     if (setOnInit)
-        page.setFeaturePermission(baseUrl, QWebEnginePage::Notifications, policy);
+#if QT_DEPRECATED_SINCE(6, 8)
+        QT_WARNING_PUSH
+        QT_WARNING_DISABLE_DEPRECATED
+        // FIXME: Replace with QWebEngineProfile permission API when that's implemented
+        page.setFeaturePermission(baseUrl, QWebEnginePage::Notifications,
+            policy == QWebEnginePermission::Granted ? QWebEnginePage::PermissionGrantedByUser : QWebEnginePage::PermissionDeniedByUser);
+        QT_WARNING_POP
+#else
+        W_QSKIP("Compiled without deprecated APIs", SkipSingle);
+#endif // QT_DEPRECATED_SINCE(6, 8)
 
     QSignalSpy spy(&page, &QWebEnginePage::loadFinished);
     page.setHtml(QString("<html><body>Test</body></html>"), baseUrl);
@@ -3871,8 +3895,17 @@ void tst_QWebEnginePage::notificationPermission()
     QCOMPARE(evaluateJavaScriptSync(&page, QStringLiteral("Notification.permission")), setOnInit ? permission : QLatin1String("default"));
 
     if (!setOnInit) {
-        page.setFeaturePermission(baseUrl, QWebEnginePage::Notifications, policy);
+#if QT_DEPRECATED_SINCE(6, 8)
+        QT_WARNING_PUSH
+        QT_WARNING_DISABLE_DEPRECATED
+        // FIXME: Replace with QWebEngineProfile permission API when that's implemented
+        page.setFeaturePermission(baseUrl, QWebEnginePage::Notifications,
+            policy == QWebEnginePermission::Granted ? QWebEnginePage::PermissionGrantedByUser : QWebEnginePage::PermissionDeniedByUser);
         QTRY_COMPARE(evaluateJavaScriptSync(&page, QStringLiteral("Notification.permission")), permission);
+        QT_WARNING_POP
+#else
+        W_QSKIP("Compiled without deprecated APIs", SkipSingle);
+#endif // QT_DEPRECATED_SINCE(6, 8)
     }
 
     auto js = QStringLiteral("var permission; Notification.requestPermission().then(p => { permission = p })");
@@ -3885,7 +3918,7 @@ void tst_QWebEnginePage::notificationPermission()
 
 void tst_QWebEnginePage::sendNotification()
 {
-    NotificationPage page(QWebEnginePage::PermissionGrantedByUser);
+    NotificationPage page(QWebEnginePermission::Granted);
     QVERIFY(page.spyLoad.waitForResult());
 
     page.resetPermission();
@@ -3973,42 +4006,42 @@ void tst_QWebEnginePage::clipboardReadWritePermissionInitialState()
 void tst_QWebEnginePage::clipboardReadWritePermission_data()
 {
     QTest::addColumn<bool>("canAccessClipboard");
-    QTest::addColumn<QWebEnginePage::PermissionPolicy>("initialPolicy");
+    QTest::addColumn<QWebEnginePermission::State>("initialPolicy");
     QTest::addColumn<QString>("initialPermission");
-    QTest::addColumn<QWebEnginePage::PermissionPolicy>("requestPolicy");
+    QTest::addColumn<QWebEnginePermission::State>("requestPolicy");
     QTest::addColumn<QString>("finalPermission");
 
     QTest::newRow("noAccessGrantGrant")
-            << false << QWebEnginePage::PermissionGrantedByUser << "granted"
-            << QWebEnginePage::PermissionGrantedByUser << "granted";
+            << false << QWebEnginePermission::Granted << "granted"
+            << QWebEnginePermission::Granted << "granted";
     QTest::newRow("noAccessGrantDeny")
-            << false << QWebEnginePage::PermissionGrantedByUser << "granted"
-            << QWebEnginePage::PermissionDeniedByUser << "denied";
+            << false << QWebEnginePermission::Granted << "granted"
+            << QWebEnginePermission::Denied << "denied";
     QTest::newRow("noAccessDenyGrant")
-            << false << QWebEnginePage::PermissionDeniedByUser << "denied"
-            << QWebEnginePage::PermissionGrantedByUser << "granted";
-    QTest::newRow("noAccessDenyDeny") << false << QWebEnginePage::PermissionDeniedByUser << "denied"
-                                      << QWebEnginePage::PermissionDeniedByUser << "denied";
-    QTest::newRow("noAccessAskGrant") << false << QWebEnginePage::PermissionUnknown << "prompt"
-                                      << QWebEnginePage::PermissionGrantedByUser << "granted";
+            << false << QWebEnginePermission::Denied << "denied"
+            << QWebEnginePermission::Granted << "granted";
+    QTest::newRow("noAccessDenyDeny") << false << QWebEnginePermission::Denied << "denied"
+                                      << QWebEnginePermission::Denied << "denied";
+    QTest::newRow("noAccessAskGrant") << false << QWebEnginePermission::Ask << "prompt"
+                                      << QWebEnginePermission::Granted << "granted";
 
     // All policies are ignored and overridden by setting JsCanAccessClipboard and JsCanPaste to
     // true
     QTest::newRow("accessGrantGrant")
-            << true << QWebEnginePage::PermissionGrantedByUser << "granted"
-            << QWebEnginePage::PermissionGrantedByUser << "granted";
-    QTest::newRow("accessDenyDeny") << true << QWebEnginePage::PermissionDeniedByUser << "granted"
-                                    << QWebEnginePage::PermissionDeniedByUser << "granted";
-    QTest::newRow("accessAskAsk") << true << QWebEnginePage::PermissionUnknown << "granted"
-                                  << QWebEnginePage::PermissionUnknown << "granted";
+            << true << QWebEnginePermission::Granted << "granted"
+            << QWebEnginePermission::Granted << "granted";
+    QTest::newRow("accessDenyDeny") << true << QWebEnginePermission::Denied << "granted"
+                                    << QWebEnginePermission::Denied << "granted";
+    QTest::newRow("accessAskAsk") << true << QWebEnginePermission::Ask << "granted"
+                                  << QWebEnginePermission::Ask << "granted";
 }
 
 void tst_QWebEnginePage::clipboardReadWritePermission()
 {
     QFETCH(bool, canAccessClipboard);
-    QFETCH(QWebEnginePage::PermissionPolicy, initialPolicy);
+    QFETCH(QWebEnginePermission::State, initialPolicy);
     QFETCH(QString, initialPermission);
-    QFETCH(QWebEnginePage::PermissionPolicy, requestPolicy);
+    QFETCH(QWebEnginePermission::State, requestPolicy);
     QFETCH(QString, finalPermission);
 
     QWebEngineProfile otr;
@@ -4026,20 +4059,43 @@ void tst_QWebEnginePage::clipboardReadWritePermission()
     bool errorState = false;
 
     // if JavascriptCanAccessClipboard is true, this never fires
-    connect(&page, &QWebEnginePage::featurePermissionRequested, &page,
-            [&](const QUrl &o, QWebEnginePage::Feature f) {
-                if (f != QWebEnginePage::ClipboardReadWrite)
+    connect(&page, &QWebEnginePage::permissionRequested, &page,
+            [&](QWebEnginePermission permission) {
+                if (permission.feature() != QWebEnginePermission::ClipboardReadWrite)
                     return;
-                if (o != baseUrl.url(QUrl::RemoveFilename)) {
-                    qWarning() << "Unexpected case. Can't proceed." << o;
+                if (permission.origin() != baseUrl.url(QUrl::RemoveFilename)) {
+                    qWarning() << "Unexpected case. Can't proceed." << permission.origin();
                     errorState = true;
                     return;
                 }
                 permissionRequestCount++;
-                page.setFeaturePermission(o, f, requestPolicy);
+                switch (requestPolicy) {
+                case QWebEnginePermission::Granted:
+                    permission.grant();
+                    break;
+                case QWebEnginePermission::Denied:
+                    permission.deny();
+                    break;
+                case QWebEnginePermission::Ask:
+                    permission.reset();
+                    break;
+                default:
+                    break;
+                }
             });
 
-    page.setFeaturePermission(baseUrl, QWebEnginePage::ClipboardReadWrite, initialPolicy);
+    // FIXME: Replace with QWebEngineProfile permission API when that's implemented
+#if QT_DEPRECATED_SINCE(6, 8)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    QWebEnginePage::PermissionPolicy deprecatedPolicy =
+        initialPolicy == QWebEnginePermission::Granted ? QWebEnginePage::PermissionGrantedByUser
+        : (initialPolicy == QWebEnginePermission::Denied ? QWebEnginePage::PermissionDeniedByUser : QWebEnginePage::PermissionUnknown);
+    page.setFeaturePermission(baseUrl, QWebEnginePage::ClipboardReadWrite, deprecatedPolicy);
+    QT_WARNING_POP
+#else
+    W_QSKIP("Compiled without deprecated APIs", SkipSingle);
+#endif // QT_DEPRECATED_SINCE(6, 8)
 
     QSignalSpy spy(&page, &QWebEnginePage::loadFinished);
     page.setHtml(QString("<html><body>Test</body></html>"), baseUrl);
@@ -4099,17 +4155,17 @@ void tst_QWebEnginePage::contentsSize()
 
 void tst_QWebEnginePage::localFontAccessPermission_data()
 {
-    QTest::addColumn<QWebEnginePage::PermissionPolicy>("policy");
+    QTest::addColumn<QWebEnginePermission::State>("policy");
     QTest::addColumn<bool>("ignore");
     QTest::addColumn<bool>("shouldBeEmpty");
 
-    QTest::newRow("ignore")         << QWebEnginePage::PermissionDeniedByUser  << true  << true;
-    QTest::newRow("setDeny")        << QWebEnginePage::PermissionDeniedByUser  << false << true;
-    QTest::newRow("setGrant")       << QWebEnginePage::PermissionGrantedByUser << false << false;
+    QTest::newRow("ignore")   << QWebEnginePermission::Denied  << true  << true;
+    QTest::newRow("setDeny")  << QWebEnginePermission::Denied  << false << true;
+    QTest::newRow("setGrant") << QWebEnginePermission::Granted << false << false;
 }
 
 void tst_QWebEnginePage::localFontAccessPermission() {
-    QFETCH(QWebEnginePage::PermissionPolicy, policy);
+    QFETCH(QWebEnginePermission::State, policy);
     QFETCH(bool, ignore);
     QFETCH(bool, shouldBeEmpty);
 
@@ -4118,12 +4174,16 @@ void tst_QWebEnginePage::localFontAccessPermission() {
     page.profile()->setPersistentPermissionsPolicy(QWebEngineProfile::NoPersistentPermissions);
     view.setPage(&page);
 
-    connect(&page, &QWebEnginePage::featurePermissionRequested, &page, [&] (const QUrl &o, QWebEnginePage::Feature f) {
-        if (f != QWebEnginePage::LocalFontsAccess)
+    connect(&page, &QWebEnginePage::permissionRequested, &page, [&] (QWebEnginePermission permission) {
+        if (permission.feature() != QWebEnginePermission::LocalFontsAccess)
             return;
 
-        if (!ignore)
-            page.setFeaturePermission(o, f, policy);
+        if (!ignore) {
+            if (policy == QWebEnginePermission::Granted)
+                permission.grant();
+            else
+                permission.deny();
+        }
     });
 
     QSignalSpy spy(&page, &QWebEnginePage::loadFinished);
@@ -5734,12 +5794,11 @@ void tst_QWebEnginePage::chooseDesktopMedia()
                 desktopMediaRequested = true;
             });
 
-    connect(&page, &QWebEnginePage::featurePermissionRequested,
-            [&](const QUrl &securityOrigin, QWebEnginePage::Feature feature) {
+    connect(&page, &QWebEnginePage::permissionRequested,
+            [&](QWebEnginePermission permission) {
                 permissionRequested = true;
                 // Handle permission to 'complete' the media request
-                page.setFeaturePermission(securityOrigin, feature,
-                                          QWebEnginePage::PermissionGrantedByUser);
+                permission.grant();
             });
 
     page.load(QUrl(server.url()));
diff --git a/tests/auto/widgets/qwebengineprofile/tst_qwebengineprofile.cpp b/tests/auto/widgets/qwebengineprofile/tst_qwebengineprofile.cpp
index ef069ac1c..818006586 100644
--- a/tests/auto/widgets/qwebengineprofile/tst_qwebengineprofile.cpp
+++ b/tests/auto/widgets/qwebengineprofile/tst_qwebengineprofile.cpp
@@ -1051,8 +1051,15 @@ void tst_QWebEngineProfile::permissionPersistence()
 
     QVariant variant = granted ? "granted" : "denied";
     QVariant defaultVariant = "default";
+#if QT_DEPRECATED_SINCE(6, 8)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     page->setFeaturePermission(server.url("/hedgehog.html"), QWebEnginePage::Notifications,
         granted ? QWebEnginePage::PermissionGrantedByUser : QWebEnginePage::PermissionDeniedByUser);
+    QT_WARNING_POP
+#else
+    W_QSKIP("Compiled without deprecated APIs", SkipSingle);
+#endif // QT_DEPRECATED_SINCE(6, 8)
     QCOMPARE(evaluateJavaScriptSync(page.get(), "Notification.permission"), variant);
 
     page.reset();
@@ -1077,7 +1084,14 @@ void tst_QWebEngineProfile::permissionPersistence()
     QTRY_COMPARE(evaluateJavaScriptSync(page.get(), "Notification.permission"),
         expectSame ? variant : defaultVariant);
 
+#if QT_DEPRECATED_SINCE(6, 8)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
     page->setFeaturePermission(server.url("/hedgehog.html"), QWebEnginePage::Notifications, QWebEnginePage::PermissionUnknown);
+    QT_WARNING_POP
+#else
+    W_QSKIP("Compiled without deprecated APIs", SkipSingle);
+#endif // QT_DEPRECATED_SINCE(6, 8)
     QCOMPARE(evaluateJavaScriptSync(page.get(), "Notification.permission"), defaultVariant);
 
     page.reset();
diff --git a/tests/manual/quick/geopermission/tst_geopermission.qml b/tests/manual/quick/geopermission/tst_geopermission.qml
index 36317c176..ace48d464 100644
--- a/tests/manual/quick/geopermission/tst_geopermission.qml
+++ b/tests/manual/quick/geopermission/tst_geopermission.qml
@@ -13,14 +13,14 @@ WebEngineView {
     property bool deniedGeolocation: false
     property bool geoPermissionRequested: false
 
-    onFeaturePermissionRequested: function(securityOrigin, feature) {
-        if (feature === WebEngineView.Geolocation) {
+    onPermissionRequested: function(perm) {
+        if (perm.feature === WebEnginePermission.Geolocation) {
             geoPermissionRequested = true
             if (deniedGeolocation) {
-                webEngineView.grantFeaturePermission(securityOrigin, feature, false)
+                perm.deny()
             }
             else {
-                webEngineView.grantFeaturePermission(securityOrigin, feature, true)
+                perm.grant()
             }
         }
     }
diff --git a/tests/manual/widgets/geolocation/main.cpp b/tests/manual/widgets/geolocation/main.cpp
index f33cf5798..1f4cefe54 100644
--- a/tests/manual/widgets/geolocation/main.cpp
+++ b/tests/manual/widgets/geolocation/main.cpp
@@ -16,18 +16,15 @@ class GeoPermissionWebView : public QWebEngineView {
   Q_OBJECT
 
 public slots:
-    void handleFeaturePermissionRequested(const QUrl &securityOrigin,
-                                               QWebEnginePage::Feature feature)
+    void handlePermissionRequested(QWebEnginePermission permission)
     {
         qWarning("Feature Permission");
         QString title = tr("Permission Request");
         QString question = QLatin1String("Allow access to geolocation?");
         if (!question.isEmpty() && QMessageBox::question(window(), title, question) == QMessageBox::Yes)
-            page()->setFeaturePermission(securityOrigin, feature,
-                                         QWebEnginePage::PermissionGrantedByUser);
+            permission.grant();
         else
-            page()->setFeaturePermission(securityOrigin, feature,
-                                         QWebEnginePage::PermissionDeniedByUser);
+            permission.deny();
     }
 
 };
@@ -38,8 +35,8 @@ int main(int argc, char *argv[])
     QMainWindow w;
     GeoPermissionWebView webview;
     QWebEnginePage page;
-    QObject::connect(&page, &QWebEnginePage::featurePermissionRequested, &webview,
-            &GeoPermissionWebView::handleFeaturePermissionRequested);
+    QObject::connect(&page, &QWebEnginePage::permissionRequested, &webview,
+            &GeoPermissionWebView::handlePermissionRequested);
     webview.setPage(&page);
     page.load(QUrl("qrc:/geolocation.html"));
     w.setCentralWidget(&webview);
diff --git a/tests/manual/widgets/webrtc/main.cpp b/tests/manual/widgets/webrtc/main.cpp
index 328e4ae36..b5718159c 100644
--- a/tests/manual/widgets/webrtc/main.cpp
+++ b/tests/manual/widgets/webrtc/main.cpp
@@ -35,19 +35,19 @@ private slots:
 Page::Page(QWebEngineProfile *profile, QObject *parent) : QWebEnginePage(profile, parent)
 {
     settings()->setAttribute(QWebEngineSettings::ScreenCaptureEnabled, true);
-    connect(this, &QWebEnginePage::featurePermissionRequested, this,
+    connect(this, &QWebEnginePage::permissionRequested, this,
             &Page::handlePermissionRequest);
     connect(this, &QWebEnginePage::desktopMediaRequested, this, &Page::handleDesktopMediaRequest);
 }
 
-void Page::handlePermissionRequest(const QUrl &origin, Feature feature)
+void Page::handlePermissionRequest(QWebEnginePermission permission)
 {
     if (QMessageBox::question(QApplication::activeWindow(), tr("Permission request"),
                               tr("allow access?"))
         == QMessageBox::Yes)
-        setFeaturePermission(origin, feature, PermissionGrantedByUser);
+        permission.grant();
     else
-        setFeaturePermission(origin, feature, PermissionDeniedByUser);
+        permission.deny();
 }
 
 void Page::handleDesktopMediaRequest(const QWebEngineDesktopMediaRequest &request)