Title: [209008] trunk
Revision
209008
Author
[email protected]
Date
2016-11-28 12:45:12 -0800 (Mon, 28 Nov 2016)

Log Message

[MediaStream] Don't request user permission for a device if it has already been granted in the current browsing context
https://bugs.webkit.org/show_bug.cgi?id=164760
Source/WebKit2:

<rdar://problem/29261266>

Reviewed by Youenn Fablet.

* UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
(WebKit::FrameAuthorizationState::FrameAuthorizationState):
(WebKit::FrameAuthorizationState::hasPermissionToUseCaptureDevice):
(WebKit::FrameAuthorizationState::setHasPermissionToUseCaptureDevice):
(WebKit::FrameAuthorizationState::reset):
(WebKit::FrameAuthorizationState::securityOriginsAreEqual):
(WebKit::UserMediaPermissionRequestManagerProxy::stateForRequest):
(WebKit::UserMediaPermissionRequestManagerProxy::invalidateRequests):
(WebKit::UserMediaPermissionRequestManagerProxy::createRequest):
(WebKit::UserMediaPermissionRequestManagerProxy::userMediaAccessWasDenied):
(WebKit::UserMediaPermissionRequestManagerProxy::userMediaAccessWasGranted):
(WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame):
* UIProcess/UserMediaPermissionRequestManagerProxy.h:
(WebKit::FrameAuthorizationState::~FrameAuthorizationState):
(WebKit::FrameAuthorizationState::frameID):
* UIProcess/UserMediaPermissionRequestProxy.cpp:
(WebKit::UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy):
* UIProcess/UserMediaPermissionRequestProxy.h:
(WebKit::UserMediaPermissionRequestProxy::create):
(WebKit::UserMediaPermissionRequestProxy::frameID):
(WebKit::UserMediaPermissionRequestProxy::userMediaDocumentSecurityOrigin):
(WebKit::UserMediaPermissionRequestProxy::topLevelDocumentSecurityOrigin):
* UIProcess/WebPageProxy.cpp:
(WebKit::WebPageProxy::didCommitLoadForFrame):
* WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
(WebKit::UserMediaPermissionRequestManager::removeMediaRequestFromMaps):

Tools:

<rdar://problem/29261266>

Reviewed by Youenn Fablet.

Allow scripts to determine the number of times the user has been prompted for capture device access.

* WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl:
* WebKitTestRunner/InjectedBundle/InjectedBundle.cpp:
(WTR::InjectedBundle::setUserMediaPersistentPermissionForOrigin):
(WTR::InjectedBundle::userMediaPermissionRequestCountForOrigin):
(WTR::InjectedBundle::resetUserMediaPermissionRequestCountForOrigin):
(WTR::InjectedBundle::setUserMediaPermissionForOrigin): Deleted.
* WebKitTestRunner/InjectedBundle/InjectedBundle.h:
* WebKitTestRunner/InjectedBundle/TestRunner.cpp:
(WTR::TestRunner::setUserMediaPersistentPermissionForOrigin):
(WTR::TestRunner::userMediaPermissionRequestCountForOrigin):
(WTR::TestRunner::resetUserMediaPermissionRequestCountForOrigin):
(WTR::TestRunner::setUserMediaPermissionForOrigin): Deleted.
* WebKitTestRunner/InjectedBundle/TestRunner.h:
* WebKitTestRunner/TestController.cpp:
(WTR::TestController::resetStateToConsistentValues):
(WTR::OriginSettings::incrementRequestCount):
(WTR::OriginSettings::resetRequestCount):
(WTR::OriginSettings::requestCount):
(WTR::TestController::saltForOrigin):
(WTR::TestController::setUserMediaPersistentPermissionForOrigin):
(WTR::TestController::handleCheckOfUserMediaPermissionForOrigin):
(WTR::TestController::settingsForOrigin):
(WTR::TestController::userMediaPermissionRequestCountForOrigin):
(WTR::TestController::resetUserMediaPermissionRequestCountForOrigin):
(WTR::TestController::decidePolicyForUserMediaPermissionRequestIfPossible):
(WTR::TestController::setUserMediaPermissionForOrigin): Deleted.
* WebKitTestRunner/TestController.h:
* WebKitTestRunner/TestInvocation.cpp:
(WTR::TestInvocation::didReceiveMessageFromInjectedBundle):
(WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):

LayoutTests:

Reviewed by Youenn Fablet.

* fast/mediastream/MediaDevices-getUserMedia-expected.txt:
* fast/mediastream/MediaDevices-getUserMedia.html:

Modified Paths

Added Paths

Diff

Modified: trunk/LayoutTests/ChangeLog (209007 => 209008)


--- trunk/LayoutTests/ChangeLog	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/LayoutTests/ChangeLog	2016-11-28 20:45:12 UTC (rev 209008)
@@ -1,3 +1,13 @@
+2016-11-28  Eric Carlson  <[email protected]>
+
+        [MediaStream] Don't request user permission for a device if it has already been granted in the current browsing context
+        https://bugs.webkit.org/show_bug.cgi?id=164760
+
+        Reviewed by Youenn Fablet.
+
+        * fast/mediastream/MediaDevices-getUserMedia-expected.txt:
+        * fast/mediastream/MediaDevices-getUserMedia.html:
+
 2016-11-28  Antti Koivisto  <[email protected]>
 
         Remove FIRST_LINE_INHERITED fake pseudo style

Modified: trunk/LayoutTests/fast/mediastream/MediaDevices-enumerateDevices.html (209007 => 209008)


--- trunk/LayoutTests/fast/mediastream/MediaDevices-enumerateDevices.html	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/LayoutTests/fast/mediastream/MediaDevices-enumerateDevices.html	2016-11-28 20:45:12 UTC (rev 209008)
@@ -58,7 +58,7 @@
             {
                 if (window.testRunner) {
                     testRunner.setUserMediaPermission(true);
-                    testRunner.setUserMediaPermissionForOrigin(false, document.location.href, "");
+                    testRunner.setUserMediaPersistentPermissionForOrigin(false, document.location.href, "");
                 }
 
                 navigator.mediaDevices
@@ -77,7 +77,7 @@
             function grantPermission()
             {
                 if (window.testRunner)
-                    testRunner.setUserMediaPermissionForOrigin(true, document.location.href, "");
+                    testRunner.setUserMediaPersistentPermissionForOrigin(true, document.location.href, "");
 
                 debug(`<br>*** Calling mediaDevices.enumerateDevices with persistent access, and without a media stream track<br>`);
                 havePermission = true;

Modified: trunk/LayoutTests/http/tests/media/media-stream/enumerate-devices-source-id-persistent.html (209007 => 209008)


--- trunk/LayoutTests/http/tests/media/media-stream/enumerate-devices-source-id-persistent.html	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/LayoutTests/http/tests/media/media-stream/enumerate-devices-source-id-persistent.html	2016-11-28 20:45:12 UTC (rev 209008)
@@ -11,7 +11,7 @@
 
             if (window.testRunner) {
                 testRunner.setUserMediaPermission(true);
-                testRunner.setUserMediaPermissionForOrigin(true, "http://localhost:8000", location.href);
+                testRunner.setUserMediaPersistentPermissionForOrigin(true, "http://localhost:8000", location.href);
             }
 
             function setup()

Added: trunk/LayoutTests/http/tests/media/media-stream/get-user-media-prompt-expected.txt (0 => 209008)


--- trunk/LayoutTests/http/tests/media/media-stream/get-user-media-prompt-expected.txt	                        (rev 0)
+++ trunk/LayoutTests/http/tests/media/media-stream/get-user-media-prompt-expected.txt	2016-11-28 20:45:12 UTC (rev 209008)
@@ -0,0 +1,29 @@
+Tests that user is only prompted once per device in the current browsing context.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS numberOfTimesGetUserMediaHasBeenCalled() is 0
+
+** Request an audio-only stream, the user should be prompted **
+PASS navigator.mediaDevices.getUserMedia({audio:true}).then(gotStream1); did not throw exception.
+PASS numberOfTimesGetUserMediaHasBeenCalled() is 1
+PASS stream.getAudioTracks().length is 1
+PASS stream.getVideoTracks().length is 0
+
+** Request a video-only stream, the user should be prompted **
+PASS navigator.mediaDevices.getUserMedia({video:true}).then(gotStream2); did not throw exception.
+PASS numberOfTimesGetUserMediaHasBeenCalled() is 2
+PASS stream.getAudioTracks().length is 0
+PASS stream.getVideoTracks().length is 1
+
+** Request a stream with video and audio, the user should be not prompted **
+PASS navigator.mediaDevices.getUserMedia({audio:true, video:true}).then(gotStream3); did not throw exception.
+PASS numberOfTimesGetUserMediaHasBeenCalled() is 2
+PASS stream.getAudioTracks().length is 1
+PASS stream.getVideoTracks().length is 1
+
+PASS successfullyParsed is true
+
+TEST COMPLETE
+

Added: trunk/LayoutTests/http/tests/media/media-stream/get-user-media-prompt.html (0 => 209008)


--- trunk/LayoutTests/http/tests/media/media-stream/get-user-media-prompt.html	                        (rev 0)
+++ trunk/LayoutTests/http/tests/media/media-stream/get-user-media-prompt.html	2016-11-28 20:45:12 UTC (rev 209008)
@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <style>
+            iframe { border: 1px solid black; }
+        </style>
+        <script src=""
+        <script>
+
+            function numberOfTimesGetUserMediaHasBeenCalled()
+            {
+                return testRunner.userMediaPermissionRequestCountForOrigin(document.location.href, document.location.href);
+            }
+
+            function gotStream3(s)
+            {
+                stream = s;
+                shouldBe("numberOfTimesGetUserMediaHasBeenCalled()", "2");
+                shouldBe("stream.getAudioTracks().length", "1");
+                shouldBe("stream.getVideoTracks().length", "1");
+
+                debug("");
+                finishJSTest();
+            }
+
+            function gotStream2(s)
+            {
+                stream = s;
+                shouldBe("numberOfTimesGetUserMediaHasBeenCalled()", "2");
+                shouldBe("stream.getAudioTracks().length", "0");
+                shouldBe("stream.getVideoTracks().length", "1");
+
+                debug("<br>** Request a stream with video and audio, the user should be not prompted **");
+                shouldNotThrow("navigator.mediaDevices.getUserMedia({audio:true, video:true}).then(gotStream3);");
+            }
+
+            function gotStream1(s)
+            {
+                stream = s;
+                shouldBe("numberOfTimesGetUserMediaHasBeenCalled()", "1");
+                shouldBe("stream.getAudioTracks().length", "1");
+                shouldBe("stream.getVideoTracks().length", "0");
+
+                debug("<br>** Request a video-only stream, the user should be prompted **");
+                shouldNotThrow("navigator.mediaDevices.getUserMedia({video:true}).then(gotStream2);")
+            }
+
+            function setup()
+            {
+                description("Tests that user is only prompted once per device in the current browsing context.");
+
+                testRunner.resetUserMediaPermissionRequestCountForOrigin(document.location.href, document.location.href);
+                shouldBe("numberOfTimesGetUserMediaHasBeenCalled()", "0");
+
+                debug("<br>** Request an audio-only stream, the user should be prompted **");
+                shouldNotThrow("navigator.mediaDevices.getUserMedia({audio:true}).then(gotStream1);");
+            }
+
+            if (window.testRunner)
+                testRunner.setUserMediaPermission(true);
+            window.jsTestIsAsync = true;
+            window.successfullyParsed = true;
+        </script> 
+        <script src=""
+    </head>
+    <body _onload_="setup()">
+    </body>
+</html>

Modified: trunk/Source/WebKit2/ChangeLog (209007 => 209008)


--- trunk/Source/WebKit2/ChangeLog	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Source/WebKit2/ChangeLog	2016-11-28 20:45:12 UTC (rev 209008)
@@ -1,3 +1,38 @@
+2016-11-28  Eric Carlson  <[email protected]>
+
+        [MediaStream] Don't request user permission for a device if it has already been granted in the current browsing context
+        https://bugs.webkit.org/show_bug.cgi?id=164760
+        <rdar://problem/29261266>
+
+        Reviewed by Youenn Fablet.
+
+        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
+        (WebKit::FrameAuthorizationState::FrameAuthorizationState):
+        (WebKit::FrameAuthorizationState::hasPermissionToUseCaptureDevice):
+        (WebKit::FrameAuthorizationState::setHasPermissionToUseCaptureDevice):
+        (WebKit::FrameAuthorizationState::reset):
+        (WebKit::FrameAuthorizationState::securityOriginsAreEqual):
+        (WebKit::UserMediaPermissionRequestManagerProxy::stateForRequest):
+        (WebKit::UserMediaPermissionRequestManagerProxy::invalidateRequests):
+        (WebKit::UserMediaPermissionRequestManagerProxy::createRequest):
+        (WebKit::UserMediaPermissionRequestManagerProxy::userMediaAccessWasDenied):
+        (WebKit::UserMediaPermissionRequestManagerProxy::userMediaAccessWasGranted):
+        (WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame):
+        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
+        (WebKit::FrameAuthorizationState::~FrameAuthorizationState):
+        (WebKit::FrameAuthorizationState::frameID):
+        * UIProcess/UserMediaPermissionRequestProxy.cpp:
+        (WebKit::UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy):
+        * UIProcess/UserMediaPermissionRequestProxy.h:
+        (WebKit::UserMediaPermissionRequestProxy::create):
+        (WebKit::UserMediaPermissionRequestProxy::frameID):
+        (WebKit::UserMediaPermissionRequestProxy::userMediaDocumentSecurityOrigin):
+        (WebKit::UserMediaPermissionRequestProxy::topLevelDocumentSecurityOrigin):
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::didCommitLoadForFrame):
+        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
+        (WebKit::UserMediaPermissionRequestManager::removeMediaRequestFromMaps):
+
 2016-11-27  Dean Jackson  <[email protected]>
 
         Removed a WTFLogAlways I left in with a recent commit.

Modified: trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.cpp (209007 => 209008)


--- trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.cpp	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.cpp	2016-11-28 20:45:12 UTC (rev 209008)
@@ -34,6 +34,61 @@
 
 namespace WebKit {
 
+FrameAuthorizationState::FrameAuthorizationState(UserMediaPermissionRequestProxy& request)
+    : m_userMediaDocumentSecurityOrigin(request.userMediaDocumentSecurityOrigin())
+    , m_topLevelDocumentSecurityOrigin(request.topLevelDocumentSecurityOrigin())
+{
+}
+
+bool FrameAuthorizationState::hasPermissionToUseCaptureDevice(const String& deviceUID)
+{
+    return m_authorizedDeviceUIDs.find(deviceUID) != notFound;
+}
+
+void FrameAuthorizationState::setHasPermissionToUseCaptureDevice(const String& deviceUID, bool hasPermission)
+{
+    if (deviceUID.isEmpty())
+        return;
+
+    size_t index = m_authorizedDeviceUIDs.find(deviceUID);
+    if (hasPermission == (index != notFound))
+        return;
+
+    if (hasPermission)
+        m_authorizedDeviceUIDs.append(deviceUID);
+    else
+        m_authorizedDeviceUIDs.remove(index);
+}
+
+void FrameAuthorizationState::ensureSecurityOriginsAreEqual(UserMediaPermissionRequestProxy& request)
+{
+    do {
+        if (!m_userMediaDocumentSecurityOrigin || !m_userMediaDocumentSecurityOrigin->equal(request.userMediaDocumentSecurityOrigin()))
+            break;
+
+        if (!m_topLevelDocumentSecurityOrigin || !m_topLevelDocumentSecurityOrigin->equal(request.topLevelDocumentSecurityOrigin()))
+            break;
+
+        return;
+    } while (0);
+
+    m_userMediaDocumentSecurityOrigin = request.userMediaDocumentSecurityOrigin();
+    m_topLevelDocumentSecurityOrigin = request.topLevelDocumentSecurityOrigin();
+    m_authorizedDeviceUIDs.clear();
+}
+
+FrameAuthorizationState& UserMediaPermissionRequestManagerProxy::stateForRequest(UserMediaPermissionRequestProxy& request)
+{
+    auto& state = m_frameStates.add(request.frameID(), nullptr).iterator->value;
+    if (state) {
+        state->ensureSecurityOriginsAreEqual(request);
+        return *state;
+    }
+
+    state = std::make_unique<FrameAuthorizationState>(request);
+    return *state;
+}
+
 UserMediaPermissionRequestManagerProxy::UserMediaPermissionRequestManagerProxy(WebPageProxy& page)
     : m_page(page)
 {
@@ -49,23 +104,16 @@
         request->invalidate();
     m_pendingDeviceRequests.clear();
 
-    m_pageSandboxExtensionsGranted.clear();
+    m_frameStates.clear();
 }
 
-Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
+Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
 {
-    Ref<UserMediaPermissionRequestProxy> request = UserMediaPermissionRequestProxy::create(*this, userMediaID, audioDeviceUIDs, videoDeviceUIDs);
+    auto request = UserMediaPermissionRequestProxy::create(*this, userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, audioDeviceUIDs, videoDeviceUIDs);
     m_pendingUserMediaRequests.add(userMediaID, request.ptr());
     return request;
 }
 
-Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID)
-{
-    Ref<UserMediaPermissionRequestProxy> request = UserMediaPermissionRequestProxy::create(*this, userMediaID, Vector<String>(), Vector<String>());
-    m_pendingUserMediaRequests.add(userMediaID, request.ptr());
-    return request;
-}
-
 #if ENABLE(MEDIA_STREAM)
 static uint64_t toWebCore(UserMediaPermissionRequestProxy::UserMediaAccessDenialReason reason)
 {
@@ -103,10 +151,17 @@
     if (!m_page.isValid())
         return;
 
-    if (!m_pendingUserMediaRequests.take(userMediaID))
+    auto request = m_pendingUserMediaRequests.take(userMediaID);
+    if (!request)
         return;
 
-    denyRequest(userMediaID, reason, "");
+    auto fameState = stateForRequest(*request);
+    for (const auto& deviceUID : request->videoDeviceUIDs())
+        fameState.setHasPermissionToUseCaptureDevice(deviceUID, false);
+    for (const auto& deviceUID : request->audioDeviceUIDs())
+        fameState.setHasPermissionToUseCaptureDevice(deviceUID, false);
+
+    denyRequest(userMediaID, reason, emptyString());
 }
 
 void UserMediaPermissionRequestManagerProxy::denyRequest(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason reason, const String& invalidConstraint)
@@ -128,10 +183,15 @@
     if (!m_page.isValid())
         return;
 
-    if (!m_pendingUserMediaRequests.take(userMediaID))
+#if ENABLE(MEDIA_STREAM)
+    auto request = m_pendingUserMediaRequests.take(userMediaID);
+    if (!request)
         return;
 
-#if ENABLE(MEDIA_STREAM)
+    auto& fameState = stateForRequest(*request);
+    fameState.setHasPermissionToUseCaptureDevice(audioDeviceUID, true);
+    fameState.setHasPermissionToUseCaptureDevice(videoDeviceUID, true);
+
     size_t extensionCount = 0;
     unsigned requiredExtensions = SandboxExtensionsGranted::None;
     if (!audioDeviceUID.isEmpty()) {
@@ -143,10 +203,10 @@
         extensionCount++;
     }
 
-    unsigned currentExtensions = m_pageSandboxExtensionsGranted.get(m_page.pageID());
+    unsigned currentExtensions = m_pageSandboxExtensionsGranted;
     if (!(requiredExtensions & currentExtensions)) {
         ASSERT(extensionCount);
-        m_pageSandboxExtensionsGranted.set(m_page.pageID(), requiredExtensions | currentExtensions);
+        m_pageSandboxExtensionsGranted = requiredExtensions | currentExtensions;
         SandboxExtension::HandleArray handles;
         handles.allocate(extensionCount);
         if (!videoDeviceUID.isEmpty())
@@ -158,6 +218,7 @@
 
     m_page.process().send(Messages::WebPage::UserMediaAccessWasGranted(userMediaID, audioDeviceUID, videoDeviceUID), m_page.pageID());
 #else
+    UNUSED_PARAM(userMediaID);
     UNUSED_PARAM(audioDeviceUID);
     UNUSED_PARAM(videoDeviceUID);
 #endif
@@ -178,18 +239,38 @@
             return;
 
         if (videoDeviceUIDs.isEmpty() && audioDeviceUIDs.isEmpty()) {
-            denyRequest(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints, "");
+            denyRequest(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints, emptyString());
             return;
         }
 
         auto userMediaOrigin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(userMediaDocumentOriginIdentifier)->securityOrigin());
         auto topLevelOrigin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(topLevelDocumentOriginIdentifier)->securityOrigin());
-        auto request = createRequest(userMediaID, audioDeviceUIDs, videoDeviceUIDs);
+        auto request = createRequest(userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, audioDeviceUIDs, videoDeviceUIDs);
 
-        if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), *userMediaOrigin.get(), *topLevelOrigin.get(), request.get())) {
-            m_pendingUserMediaRequests.take(userMediaID);
-            request->deny(UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
+        String authorizedAudioDevice;
+        String authorizedVideoDevice;
+        auto& fameState = stateForRequest(request);
+        for (auto deviceUID : audioDeviceUIDs) {
+            if (fameState.hasPermissionToUseCaptureDevice(deviceUID)) {
+                authorizedAudioDevice = deviceUID;
+                break;
+            }
         }
+        for (auto deviceUID : videoDeviceUIDs) {
+            if (fameState.hasPermissionToUseCaptureDevice(deviceUID)) {
+                authorizedVideoDevice = deviceUID;
+                break;
+            }
+        }
+
+        if (audioDeviceUIDs.isEmpty() == authorizedAudioDevice.isEmpty() && videoDeviceUIDs.isEmpty() == authorizedVideoDevice.isEmpty()) {
+            userMediaAccessWasGranted(userMediaID, authorizedAudioDevice, authorizedVideoDevice);
+            return;
+        }
+
+        if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), *userMediaOrigin.get(), *topLevelOrigin.get(), request.get()))
+            userMediaAccessWasDenied(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
+        
     };
 
     auto audioConstraints = MediaConstraintsImpl::create(audioConstraintsData);

Modified: trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.h (209007 => 209008)


--- trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.h	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.h	2016-11-28 20:45:12 UTC (rev 209008)
@@ -22,6 +22,7 @@
 
 #include "UserMediaPermissionCheckProxy.h"
 #include "UserMediaPermissionRequestProxy.h"
+#include <WebCore/SecurityOrigin.h>
 #include <WebCore/UserMediaRequest.h>
 #include <wtf/HashMap.h>
 
@@ -34,6 +35,21 @@
 
 class WebPageProxy;
 
+class FrameAuthorizationState {
+public:
+    explicit FrameAuthorizationState(UserMediaPermissionRequestProxy&);
+
+    bool hasPermissionToUseCaptureDevice(const String& deviceUID);
+    void setHasPermissionToUseCaptureDevice(const String&, bool);
+
+    void ensureSecurityOriginsAreEqual(UserMediaPermissionRequestProxy&);
+
+private:
+    RefPtr<WebCore::SecurityOrigin> m_userMediaDocumentSecurityOrigin;
+    RefPtr<WebCore::SecurityOrigin> m_topLevelDocumentSecurityOrigin;
+    Vector<String> m_authorizedDeviceUIDs;
+};
+
 class UserMediaPermissionRequestManagerProxy {
 public:
     explicit UserMediaPermissionRequestManagerProxy(WebPageProxy&);
@@ -44,6 +60,7 @@
 
     void userMediaAccessWasGranted(uint64_t, const String& audioDeviceUID, const String& videoDeviceUID);
     void userMediaAccessWasDenied(uint64_t, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason);
+    FrameAuthorizationState& stateForRequest(UserMediaPermissionRequestProxy&);
 
     void enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier);
 
@@ -50,8 +67,7 @@
     void didCompleteUserMediaPermissionCheck(uint64_t, const String&, bool allow);
 
 private:
-    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
-    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID);
+    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID, uint64_t frameID, const String&userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
     void denyRequest(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason, const String& invalidConstraint);
     Ref<UserMediaPermissionCheckProxy> createUserMediaPermissionCheck(uint64_t userMediaID);
     void syncWithWebCorePrefs() const;
@@ -64,8 +80,10 @@
         Video = 1 << 0,
         Audio = 1 << 1
     };
-    HashMap<uint64_t, unsigned> m_pageSandboxExtensionsGranted;
+    unsigned m_pageSandboxExtensionsGranted;
 
+    HashMap<uint64_t, std::unique_ptr<FrameAuthorizationState>> m_frameStates;
+
     WebPageProxy& m_page;
 };
 

Modified: trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.cpp (209007 => 209008)


--- trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.cpp	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.cpp	2016-11-28 20:45:12 UTC (rev 209008)
@@ -22,13 +22,20 @@
 
 #include "UserMediaPermissionRequestManagerProxy.h"
 #include <WebCore/RealtimeMediaSourceCenter.h>
+#include <WebCore/SecurityOrigin.h>
+#include <WebCore/SecurityOriginData.h>
 #include <wtf/text/StringHash.h>
 
+using namespace WebCore;
+
 namespace WebKit {
 
-UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
+UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
     : m_manager(&manager)
     , m_userMediaID(userMediaID)
+    , m_frameID(frameID)
+    , m_userMediaDocumentSecurityOrigin((SecurityOriginData::fromDatabaseIdentifier(userMediaDocumentOriginIdentifier)->securityOrigin()))
+    , m_topLevelDocumentSecurityOrigin(SecurityOriginData::fromDatabaseIdentifier(topLevelDocumentOriginIdentifier)->securityOrigin())
     , m_videoDeviceUIDs(videoDeviceUIDs)
     , m_audioDeviceUIDs(audioDeviceUIDs)
 {

Modified: trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.h (209007 => 209008)


--- trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.h	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.h	2016-11-28 20:45:12 UTC (rev 209008)
@@ -25,6 +25,10 @@
 #include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
 
+namespace WebCore {
+class SecurityOrigin;
+}
+
 namespace WebKit {
 
 class UserMediaPermissionRequestManagerProxy;
@@ -31,9 +35,9 @@
 
 class UserMediaPermissionRequestProxy : public API::ObjectImpl<API::Object::Type::UserMediaPermissionRequest> {
 public:
-    static Ref<UserMediaPermissionRequestProxy> create(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs)
+    static Ref<UserMediaPermissionRequestProxy> create(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs)
     {
-        return adoptRef(*new UserMediaPermissionRequestProxy(manager, userMediaID, videoDeviceUIDs, audioDeviceUIDs));
+        return adoptRef(*new UserMediaPermissionRequestProxy(manager, userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, videoDeviceUIDs, audioDeviceUIDs));
     }
 
     void allow(const String& videoDeviceUID, const String& audioDeviceUID);
@@ -49,11 +53,18 @@
     const Vector<String>& videoDeviceUIDs() const { return m_videoDeviceUIDs; }
     const Vector<String>& audioDeviceUIDs() const { return m_audioDeviceUIDs; }
 
+    uint64_t frameID() const { return m_frameID; }
+    WebCore::SecurityOrigin* userMediaDocumentSecurityOrigin() { return &m_userMediaDocumentSecurityOrigin.get(); }
+    WebCore::SecurityOrigin* topLevelDocumentSecurityOrigin() { return &m_topLevelDocumentSecurityOrigin.get(); }
+
 private:
-    UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy&, uint64_t userMediaID, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs);
+    UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy&, uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs);
 
     UserMediaPermissionRequestManagerProxy* m_manager;
     uint64_t m_userMediaID;
+    uint64_t m_frameID;
+    Ref<WebCore::SecurityOrigin> m_userMediaDocumentSecurityOrigin;
+    Ref<WebCore::SecurityOrigin> m_topLevelDocumentSecurityOrigin;
     Vector<String> m_videoDeviceUIDs;
     Vector<String> m_audioDeviceUIDs;
 };

Modified: trunk/Tools/ChangeLog (209007 => 209008)


--- trunk/Tools/ChangeLog	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/ChangeLog	2016-11-28 20:45:12 UTC (rev 209008)
@@ -1,3 +1,44 @@
+2016-11-28  Eric Carlson  <[email protected]>
+
+        [MediaStream] Don't request user permission for a device if it has already been granted in the current browsing context
+        https://bugs.webkit.org/show_bug.cgi?id=164760
+        <rdar://problem/29261266>
+
+        Reviewed by Youenn Fablet.
+        
+        Allow scripts to determine the number of times the user has been prompted for capture device access.
+
+        * WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl:
+        * WebKitTestRunner/InjectedBundle/InjectedBundle.cpp:
+        (WTR::InjectedBundle::setUserMediaPersistentPermissionForOrigin):
+        (WTR::InjectedBundle::userMediaPermissionRequestCountForOrigin):
+        (WTR::InjectedBundle::resetUserMediaPermissionRequestCountForOrigin):
+        (WTR::InjectedBundle::setUserMediaPermissionForOrigin): Deleted.
+        * WebKitTestRunner/InjectedBundle/InjectedBundle.h:
+        * WebKitTestRunner/InjectedBundle/TestRunner.cpp:
+        (WTR::TestRunner::setUserMediaPersistentPermissionForOrigin):
+        (WTR::TestRunner::userMediaPermissionRequestCountForOrigin):
+        (WTR::TestRunner::resetUserMediaPermissionRequestCountForOrigin):
+        (WTR::TestRunner::setUserMediaPermissionForOrigin): Deleted.
+        * WebKitTestRunner/InjectedBundle/TestRunner.h:
+        * WebKitTestRunner/TestController.cpp:
+        (WTR::TestController::resetStateToConsistentValues):
+        (WTR::OriginSettings::incrementRequestCount):
+        (WTR::OriginSettings::resetRequestCount):
+        (WTR::OriginSettings::requestCount):
+        (WTR::TestController::saltForOrigin):
+        (WTR::TestController::setUserMediaPersistentPermissionForOrigin):
+        (WTR::TestController::handleCheckOfUserMediaPermissionForOrigin):
+        (WTR::TestController::settingsForOrigin):
+        (WTR::TestController::userMediaPermissionRequestCountForOrigin):
+        (WTR::TestController::resetUserMediaPermissionRequestCountForOrigin):
+        (WTR::TestController::decidePolicyForUserMediaPermissionRequestIfPossible):
+        (WTR::TestController::setUserMediaPermissionForOrigin): Deleted.
+        * WebKitTestRunner/TestController.h:
+        * WebKitTestRunner/TestInvocation.cpp:
+        (WTR::TestInvocation::didReceiveMessageFromInjectedBundle):
+        (WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):
+
 2016-11-18  Jer Noble  <[email protected]>
 
         Add some performance tests for various aspects of media loading and playback.

Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl	2016-11-28 20:45:12 UTC (rev 209008)
@@ -185,7 +185,9 @@
 
     // MediaStream
     void setUserMediaPermission(boolean value);
-    void setUserMediaPermissionForOrigin(boolean permission, DOMString origin, DOMString parentOrigin);
+    void setUserMediaPersistentPermissionForOrigin(boolean permission, DOMString origin, DOMString parentOrigin);
+    unsigned long userMediaPermissionRequestCountForOrigin(DOMString origin, DOMString parentOrigin);
+    void resetUserMediaPermissionRequestCountForOrigin(DOMString origin, DOMString parentOrigin);
 
     // Audio testing.
     [PassContext] void setAudioResult(object data);

Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp	2016-11-28 20:45:12 UTC (rev 209008)
@@ -582,9 +582,9 @@
     WKBundlePagePostMessage(page()->page(), messageName.get(), messageBody.get());
 }
 
-void InjectedBundle::setUserMediaPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin)
+void InjectedBundle::setUserMediaPersistentPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin)
 {
-    auto messageName = adoptWK(WKStringCreateWithUTF8CString("SetUserMediaPermissionForOrigin"));
+    auto messageName = adoptWK(WKStringCreateWithUTF8CString("SetUserMediaPersistentPermissionForOrigin"));
     WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
 
     WKRetainPtr<WKStringRef> permissionKeyWK(AdoptWK, WKStringCreateWithUTF8CString("permission"));
@@ -600,6 +600,38 @@
     WKBundlePagePostMessage(page()->page(), messageName.get(), messageBody.get());
 }
 
+unsigned InjectedBundle::userMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin) const
+{
+    WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString("UserMediaPermissionRequestCountForOrigin"));
+    WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
+
+    WKRetainPtr<WKStringRef> originKeyWK(AdoptWK, WKStringCreateWithUTF8CString("origin"));
+    WKDictionarySetItem(messageBody.get(), originKeyWK.get(), origin);
+
+    WKRetainPtr<WKStringRef> parentOriginKeyWK(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
+    WKDictionarySetItem(messageBody.get(), parentOriginKeyWK.get(), parentOrigin);
+
+    WKTypeRef resultToPass = 0;
+    WKBundlePagePostSynchronousMessageForTesting(page()->page(), messageName.get(), messageBody.get(), &resultToPass);
+    WKRetainPtr<WKUInt64Ref> count(AdoptWK, static_cast<WKUInt64Ref>(resultToPass));
+
+    return static_cast<unsigned>(WKUInt64GetValue(count.get()));
+}
+
+void InjectedBundle::resetUserMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin)
+{
+    WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString("ResetUserMediaPermissionRequestCountForOrigin"));
+    WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
+
+    WKRetainPtr<WKStringRef> originKeyWK(AdoptWK, WKStringCreateWithUTF8CString("origin"));
+    WKDictionarySetItem(messageBody.get(), originKeyWK.get(), origin);
+
+    WKRetainPtr<WKStringRef> parentOriginKeyWK(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
+    WKDictionarySetItem(messageBody.get(), parentOriginKeyWK.get(), parentOrigin);
+
+    WKBundlePagePostMessage(page()->page(), messageName.get(), messageBody.get());
+}
+
 void InjectedBundle::setCustomPolicyDelegate(bool enabled, bool permissive)
 {
     WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString("SetCustomPolicyDelegate"));

Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.h (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.h	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.h	2016-11-28 20:45:12 UTC (rev 209008)
@@ -101,7 +101,9 @@
 
     // MediaStream.
     void setUserMediaPermission(bool);
-    void setUserMediaPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin);
+    void setUserMediaPersistentPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin);
+    unsigned userMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin) const;
+    void resetUserMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin);
 
     // Policy delegate.
     void setCustomPolicyDelegate(bool enabled, bool permissive);

Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp	2016-11-28 20:45:12 UTC (rev 209008)
@@ -889,13 +889,27 @@
     InjectedBundle::singleton().setUserMediaPermission(enabled);
 }
 
-void TestRunner::setUserMediaPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin)
+void TestRunner::setUserMediaPersistentPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin)
 {
     WKRetainPtr<WKStringRef> originWK = toWK(origin);
     WKRetainPtr<WKStringRef> parentOriginWK = toWK(parentOrigin);
-    InjectedBundle::singleton().setUserMediaPermissionForOrigin(permission, originWK.get(), parentOriginWK.get());
+    InjectedBundle::singleton().setUserMediaPersistentPermissionForOrigin(permission, originWK.get(), parentOriginWK.get());
 }
 
+unsigned TestRunner::userMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin) const
+{
+    WKRetainPtr<WKStringRef> originWK = toWK(origin);
+    WKRetainPtr<WKStringRef> parentOriginWK = toWK(parentOrigin);
+    return InjectedBundle::singleton().userMediaPermissionRequestCountForOrigin(originWK.get(), parentOriginWK.get());
+}
+
+void TestRunner::resetUserMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin)
+{
+    WKRetainPtr<WKStringRef> originWK = toWK(origin);
+    WKRetainPtr<WKStringRef> parentOriginWK = toWK(parentOrigin);
+    InjectedBundle::singleton().resetUserMediaPermissionRequestCountForOrigin(originWK.get(), parentOriginWK.get());
+}
+
 bool TestRunner::callShouldCloseOnWebView()
 {
     WKBundleFrameRef mainFrame = WKBundlePageGetMainFrame(InjectedBundle::singleton().page()->page());

Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.h (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.h	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.h	2016-11-28 20:45:12 UTC (rev 209008)
@@ -286,7 +286,9 @@
 
     // MediaStream
     void setUserMediaPermission(bool);
-    void setUserMediaPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin);
+    void setUserMediaPersistentPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin);
+    unsigned userMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin) const;
+    void resetUserMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin);
 
     void setPageVisibility(JSStringRef state);
     void resetPageVisibility();
@@ -400,6 +402,8 @@
 
     WKRetainPtr<WKArrayRef> m_allowedHosts;
 
+    size_t m_userMediaPermissionRequestCount { 0 };
+
     PlatformTimerRef m_waitToDumpWatchdogTimer;
 };
 

Modified: trunk/Tools/WebKitTestRunner/TestController.cpp (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/TestController.cpp	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/TestController.cpp	2016-11-28 20:45:12 UTC (rev 209008)
@@ -765,7 +765,7 @@
 
     // Reset UserMedia permissions.
     m_userMediaPermissionRequests.clear();
-    m_cahcedUserMediaPermissions.clear();
+    m_cachedUserMediaPermissions.clear();
     m_isUserMediaPermissionSet = false;
     m_isUserMediaPermissionAllowed = false;
 
@@ -1885,34 +1885,34 @@
 
     HashMap<uint64_t, String>& ephemeralSalts() { return m_ephemeralSalts; }
 
+    void incrementRequestCount() { ++m_requestCount; }
+    void resetRequestCount() { m_requestCount = 0; }
+    unsigned requestCount() const { return m_requestCount; }
+
 private:
     HashMap<uint64_t, String> m_ephemeralSalts;
     String m_persistentSalt;
+    unsigned m_requestCount { 0 };
     bool m_persistentPermission { false };
 };
 
 String TestController::saltForOrigin(WKFrameRef frame, String originHash)
 {
-    RefPtr<OriginSettings> settings = m_cahcedUserMediaPermissions.get(originHash);
-    if (!settings) {
-        settings = adoptRef(*new OriginSettings());
-        m_cahcedUserMediaPermissions.add(originHash, settings);
-    }
-
-    auto& ephemeralSalts = settings->ephemeralSalts();
+    auto& settings = settingsForOrigin(originHash);
+    auto& ephemeralSalts = settings.ephemeralSalts();
     auto frameInfo = adoptWK(WKFrameCreateFrameInfo(frame));
     auto frameHandle = WKFrameInfoGetFrameHandleRef(frameInfo.get());
     uint64_t frameIdentifier = WKFrameHandleGetFrameID(frameHandle);
     String frameSalt = ephemeralSalts.get(frameIdentifier);
 
-    if (settings->persistentPermission()) {
+    if (settings.persistentPermission()) {
         if (frameSalt.length())
             return frameSalt;
 
-        if (!settings->persistentSalt().length())
-            settings->setPersistentSalt(createCanonicalUUIDString());
+        if (!settings.persistentSalt().length())
+            settings.setPersistentSalt(createCanonicalUUIDString());
 
-        return settings->persistentSalt();
+        return settings.persistentSalt();
     }
 
     if (!frameSalt.length()) {
@@ -1923,16 +1923,11 @@
     return frameSalt;
 }
 
-void TestController::setUserMediaPermissionForOrigin(bool permission, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
+void TestController::setUserMediaPersistentPermissionForOrigin(bool permission, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
 {
     auto originHash = userMediaOriginHash(userMediaDocumentOriginString, topLevelDocumentOriginString);
-    RefPtr<OriginSettings> settings = m_cahcedUserMediaPermissions.get(originHash);
-    if (!settings) {
-        settings = adoptRef(*new OriginSettings());
-        m_cahcedUserMediaPermissions.add(originHash, settings);
-    }
-
-    settings->setPersistentPermission(permission);
+    auto& settings = settingsForOrigin(originHash);
+    settings.setPersistentPermission(permission);
 }
 
 void TestController::handleCheckOfUserMediaPermissionForOrigin(WKFrameRef frame, WKSecurityOriginRef userMediaDocumentOrigin, WKSecurityOriginRef topLevelDocumentOrigin, const WKUserMediaPermissionCheckRef& checkRequest)
@@ -1940,7 +1935,7 @@
     auto originHash = userMediaOriginHash(userMediaDocumentOrigin, topLevelDocumentOrigin);
     auto salt = saltForOrigin(frame, originHash);
 
-    WKUserMediaPermissionCheckSetUserMediaAccessInfo(checkRequest, WKStringCreateWithUTF8CString(salt.utf8().data()), m_cahcedUserMediaPermissions.get(originHash)->persistentPermission());
+    WKUserMediaPermissionCheckSetUserMediaAccessInfo(checkRequest, WKStringCreateWithUTF8CString(salt.utf8().data()), settingsForOrigin(originHash).persistentPermission());
 }
 
 void TestController::handleUserMediaPermissionRequest(WKFrameRef frame, WKSecurityOriginRef userMediaDocumentOrigin, WKSecurityOriginRef topLevelDocumentOrigin, WKUserMediaPermissionRequestRef request)
@@ -1950,6 +1945,29 @@
     decidePolicyForUserMediaPermissionRequestIfPossible();
 }
 
+OriginSettings& TestController::settingsForOrigin(const String& originHash)
+{
+    RefPtr<OriginSettings> settings = m_cachedUserMediaPermissions.get(originHash);
+    if (!settings) {
+        settings = adoptRef(*new OriginSettings());
+        m_cachedUserMediaPermissions.add(originHash, settings);
+    }
+
+    return *settings;
+}
+
+unsigned TestController::userMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
+{
+    auto originHash = userMediaOriginHash(userMediaDocumentOriginString, topLevelDocumentOriginString);
+    return settingsForOrigin(originHash).requestCount();
+}
+
+void TestController::resetUserMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
+{
+    auto originHash = userMediaOriginHash(userMediaDocumentOriginString, topLevelDocumentOriginString);
+    settingsForOrigin(originHash).resetRequestCount();
+}
+
 void TestController::decidePolicyForUserMediaPermissionRequestIfPossible()
 {
     if (!m_isUserMediaPermissionSet)
@@ -1959,12 +1977,10 @@
         auto originHash = pair.first;
         auto request = pair.second.get();
 
-        bool persistentPermission = false;
-        RefPtr<OriginSettings> settings = m_cahcedUserMediaPermissions.get(originHash);
-        if (settings)
-            persistentPermission = settings->persistentPermission();
+        auto& settings = settingsForOrigin(originHash);
+        settings.incrementRequestCount();
 
-        if (!m_isUserMediaPermissionAllowed && !persistentPermission) {
+        if (!m_isUserMediaPermissionAllowed && !settings.persistentPermission()) {
             WKUserMediaPermissionRequestDeny(request, kWKPermissionDenied);
             continue;
         }

Modified: trunk/Tools/WebKitTestRunner/TestController.h (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/TestController.h	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/TestController.h	2016-11-28 20:45:12 UTC (rev 209008)
@@ -101,9 +101,12 @@
     void getUserMediaInfoForOrigin(WKFrameRef, WKStringRef originKey, bool&, WKRetainPtr<WKStringRef>&);
     WKStringRef getUserMediaSaltForOrigin(WKFrameRef, WKStringRef originKey);
     void setUserMediaPermission(bool);
-    void setUserMediaPermissionForOrigin(bool, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
+    void setUserMediaPersistentPermissionForOrigin(bool, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
     void handleUserMediaPermissionRequest(WKFrameRef, WKSecurityOriginRef, WKSecurityOriginRef, WKUserMediaPermissionRequestRef);
     void handleCheckOfUserMediaPermissionForOrigin(WKFrameRef, WKSecurityOriginRef, WKSecurityOriginRef, const WKUserMediaPermissionCheckRef&);
+    OriginSettings& settingsForOrigin(const String&);
+    unsigned userMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
+    void resetUserMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
 
     // Policy delegate.
     void setCustomPolicyDelegate(bool enabled, bool permissive);
@@ -316,7 +319,7 @@
     bool m_isGeolocationPermissionSet { false };
     bool m_isGeolocationPermissionAllowed { false };
 
-    HashMap<String, RefPtr<OriginSettings>> m_cahcedUserMediaPermissions;
+    HashMap<String, RefPtr<OriginSettings>> m_cachedUserMediaPermissions;
 
     typedef Vector<std::pair<String, WKRetainPtr<WKUserMediaPermissionRequestRef>>> PermissionRequestList;
     PermissionRequestList m_userMediaPermissionRequests;

Modified: trunk/Tools/WebKitTestRunner/TestInvocation.cpp (209007 => 209008)


--- trunk/Tools/WebKitTestRunner/TestInvocation.cpp	2016-11-28 20:44:25 UTC (rev 209007)
+++ trunk/Tools/WebKitTestRunner/TestInvocation.cpp	2016-11-28 20:45:12 UTC (rev 209008)
@@ -496,7 +496,7 @@
         return;
     }
 
-    if (WKStringIsEqualToUTF8CString(messageName, "SetUserMediaPermissionForOrigin")) {
+    if (WKStringIsEqualToUTF8CString(messageName, "SetUserMediaPersistentPermissionForOrigin")) {
         ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
         WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
 
@@ -510,10 +510,24 @@
         WKRetainPtr<WKStringRef> parentOriginKey(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
         WKStringRef parentOriginWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, parentOriginKey.get()));
 
-        TestController::singleton().setUserMediaPermissionForOrigin(permission, originWK, parentOriginWK);
+        TestController::singleton().setUserMediaPersistentPermissionForOrigin(permission, originWK, parentOriginWK);
         return;
     }
 
+    if (WKStringIsEqualToUTF8CString(messageName, "ResetUserMediaPermissionRequestCountForOrigin")) {
+        ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
+        WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
+
+        WKRetainPtr<WKStringRef> originKey(AdoptWK, WKStringCreateWithUTF8CString("origin"));
+        WKStringRef originWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, originKey.get()));
+
+        WKRetainPtr<WKStringRef> parentOriginKey(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
+        WKStringRef parentOriginWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, parentOriginKey.get()));
+        
+        TestController::singleton().resetUserMediaPermissionRequestCountForOrigin(originWK, parentOriginWK);
+        return;
+    }
+
     if (WKStringIsEqualToUTF8CString(messageName, "SetCacheModel")) {
         ASSERT(WKGetTypeID(messageBody) == WKUInt64GetTypeID());
         uint64_t model = WKUInt64GetValue(static_cast<WKUInt64Ref>(messageBody));
@@ -846,6 +860,22 @@
     }
 #endif // PLATFORM(MAC)
 
+    if (WKStringIsEqualToUTF8CString(messageName, "UserMediaPermissionRequestCountForOrigin")) {
+        ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
+        WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
+
+        WKRetainPtr<WKStringRef> originKey(AdoptWK, WKStringCreateWithUTF8CString("origin"));
+        WKStringRef originWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, originKey.get()));
+
+        WKRetainPtr<WKStringRef> parentOriginKey(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
+        WKStringRef parentOriginWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, parentOriginKey.get()));
+        
+        unsigned count = TestController::singleton().userMediaPermissionRequestCountForOrigin(originWK, parentOriginWK);
+        WKRetainPtr<WKUInt64Ref> result(AdoptWK, WKUInt64Create(count));
+        return result;
+    }
+
+
     ASSERT_NOT_REACHED();
     return nullptr;
 }
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to