Changeset 209024 in webkit


Ignore:
Timestamp:
Nov 28, 2016 2:41:23 PM (7 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r209008.

This change appears to have caused two fast/mediastrem
LayoutTests to fail.

Reverted changeset:

"[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
http://trac.webkit.org/changeset/209008

Location:
trunk
Files:
2 deleted
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r209008 r209024  
     12016-11-28  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r209008.
     4
     5        This change appears to have caused two fast/mediastrem
     6        LayoutTests to fail.
     7
     8        Reverted changeset:
     9
     10        "[MediaStream] Don't request user permission for a device if
     11        it has already been granted in the current browsing context"
     12        https://bugs.webkit.org/show_bug.cgi?id=164760
     13        http://trac.webkit.org/changeset/209008
     14
    1152016-11-28  Eric Carlson  <eric.carlson@apple.com>
    216
  • trunk/LayoutTests/fast/mediastream/MediaDevices-enumerateDevices.html

    r209008 r209024  
    5959                if (window.testRunner) {
    6060                    testRunner.setUserMediaPermission(true);
    61                     testRunner.setUserMediaPersistentPermissionForOrigin(false, document.location.href, "");
     61                    testRunner.setUserMediaPermissionForOrigin(false, document.location.href, "");
    6262                }
    6363
     
    7878            {
    7979                if (window.testRunner)
    80                     testRunner.setUserMediaPersistentPermissionForOrigin(true, document.location.href, "");
     80                    testRunner.setUserMediaPermissionForOrigin(true, document.location.href, "");
    8181
    8282                debug(`<br>*** Calling mediaDevices.enumerateDevices with persistent access, and without a media stream track<br>`);
  • trunk/LayoutTests/http/tests/media/media-stream/enumerate-devices-source-id-persistent.html

    r209008 r209024  
    1212            if (window.testRunner) {
    1313                testRunner.setUserMediaPermission(true);
    14                 testRunner.setUserMediaPersistentPermissionForOrigin(true, "http://localhost:8000", location.href);
     14                testRunner.setUserMediaPermissionForOrigin(true, "http://localhost:8000", location.href);
    1515            }
    1616
  • trunk/Source/WebKit2/ChangeLog

    r209010 r209024  
     12016-11-28  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r209008.
     4
     5        This change appears to have caused two fast/mediastrem
     6        LayoutTests to fail.
     7
     8        Reverted changeset:
     9
     10        "[MediaStream] Don't request user permission for a device if
     11        it has already been granted in the current browsing context"
     12        https://bugs.webkit.org/show_bug.cgi?id=164760
     13        http://trac.webkit.org/changeset/209008
     14
    1152016-11-28  Andrew Gold  <agold@apple.com>
    216
  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.cpp

    r209008 r209024  
    3535namespace WebKit {
    3636
    37 FrameAuthorizationState::FrameAuthorizationState(UserMediaPermissionRequestProxy& request)
    38     : m_userMediaDocumentSecurityOrigin(request.userMediaDocumentSecurityOrigin())
    39     , m_topLevelDocumentSecurityOrigin(request.topLevelDocumentSecurityOrigin())
    40 {
    41 }
    42 
    43 bool FrameAuthorizationState::hasPermissionToUseCaptureDevice(const String& deviceUID)
    44 {
    45     return m_authorizedDeviceUIDs.find(deviceUID) != notFound;
    46 }
    47 
    48 void FrameAuthorizationState::setHasPermissionToUseCaptureDevice(const String& deviceUID, bool hasPermission)
    49 {
    50     if (deviceUID.isEmpty())
    51         return;
    52 
    53     size_t index = m_authorizedDeviceUIDs.find(deviceUID);
    54     if (hasPermission == (index != notFound))
    55         return;
    56 
    57     if (hasPermission)
    58         m_authorizedDeviceUIDs.append(deviceUID);
    59     else
    60         m_authorizedDeviceUIDs.remove(index);
    61 }
    62 
    63 void FrameAuthorizationState::ensureSecurityOriginsAreEqual(UserMediaPermissionRequestProxy& request)
    64 {
    65     do {
    66         if (!m_userMediaDocumentSecurityOrigin || !m_userMediaDocumentSecurityOrigin->equal(request.userMediaDocumentSecurityOrigin()))
    67             break;
    68 
    69         if (!m_topLevelDocumentSecurityOrigin || !m_topLevelDocumentSecurityOrigin->equal(request.topLevelDocumentSecurityOrigin()))
    70             break;
    71 
    72         return;
    73     } while (0);
    74 
    75     m_userMediaDocumentSecurityOrigin = request.userMediaDocumentSecurityOrigin();
    76     m_topLevelDocumentSecurityOrigin = request.topLevelDocumentSecurityOrigin();
    77     m_authorizedDeviceUIDs.clear();
    78 }
    79 
    80 FrameAuthorizationState& UserMediaPermissionRequestManagerProxy::stateForRequest(UserMediaPermissionRequestProxy& request)
    81 {
    82     auto& state = m_frameStates.add(request.frameID(), nullptr).iterator->value;
    83     if (state) {
    84         state->ensureSecurityOriginsAreEqual(request);
    85         return *state;
    86     }
    87 
    88     state = std::make_unique<FrameAuthorizationState>(request);
    89     return *state;
    90 }
    91 
    9237UserMediaPermissionRequestManagerProxy::UserMediaPermissionRequestManagerProxy(WebPageProxy& page)
    9338    : m_page(page)
     
    10550    m_pendingDeviceRequests.clear();
    10651
    107     m_frameStates.clear();
    108 }
    109 
    110 Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
    111 {
    112     auto request = UserMediaPermissionRequestProxy::create(*this, userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, audioDeviceUIDs, videoDeviceUIDs);
     52    m_pageSandboxExtensionsGranted.clear();
     53}
     54
     55Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
     56{
     57    Ref<UserMediaPermissionRequestProxy> request = UserMediaPermissionRequestProxy::create(*this, userMediaID, audioDeviceUIDs, videoDeviceUIDs);
     58    m_pendingUserMediaRequests.add(userMediaID, request.ptr());
     59    return request;
     60}
     61
     62Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID)
     63{
     64    Ref<UserMediaPermissionRequestProxy> request = UserMediaPermissionRequestProxy::create(*this, userMediaID, Vector<String>(), Vector<String>());
    11365    m_pendingUserMediaRequests.add(userMediaID, request.ptr());
    11466    return request;
     
    152104        return;
    153105
    154     auto request = m_pendingUserMediaRequests.take(userMediaID);
    155     if (!request)
    156         return;
    157 
    158     auto fameState = stateForRequest(*request);
    159     for (const auto& deviceUID : request->videoDeviceUIDs())
    160         fameState.setHasPermissionToUseCaptureDevice(deviceUID, false);
    161     for (const auto& deviceUID : request->audioDeviceUIDs())
    162         fameState.setHasPermissionToUseCaptureDevice(deviceUID, false);
    163 
    164     denyRequest(userMediaID, reason, emptyString());
     106    if (!m_pendingUserMediaRequests.take(userMediaID))
     107        return;
     108
     109    denyRequest(userMediaID, reason, "");
    165110}
    166111
     
    184129        return;
    185130
    186 #if ENABLE(MEDIA_STREAM)
    187     auto request = m_pendingUserMediaRequests.take(userMediaID);
    188     if (!request)
    189         return;
    190 
    191     auto& fameState = stateForRequest(*request);
    192     fameState.setHasPermissionToUseCaptureDevice(audioDeviceUID, true);
    193     fameState.setHasPermissionToUseCaptureDevice(videoDeviceUID, true);
    194 
     131    if (!m_pendingUserMediaRequests.take(userMediaID))
     132        return;
     133
     134#if ENABLE(MEDIA_STREAM)
    195135    size_t extensionCount = 0;
    196136    unsigned requiredExtensions = SandboxExtensionsGranted::None;
     
    204144    }
    205145
    206     unsigned currentExtensions = m_pageSandboxExtensionsGranted;
     146    unsigned currentExtensions = m_pageSandboxExtensionsGranted.get(m_page.pageID());
    207147    if (!(requiredExtensions & currentExtensions)) {
    208148        ASSERT(extensionCount);
    209         m_pageSandboxExtensionsGranted = requiredExtensions | currentExtensions;
     149        m_pageSandboxExtensionsGranted.set(m_page.pageID(), requiredExtensions | currentExtensions);
    210150        SandboxExtension::HandleArray handles;
    211151        handles.allocate(extensionCount);
     
    219159    m_page.process().send(Messages::WebPage::UserMediaAccessWasGranted(userMediaID, audioDeviceUID, videoDeviceUID), m_page.pageID());
    220160#else
    221     UNUSED_PARAM(userMediaID);
    222161    UNUSED_PARAM(audioDeviceUID);
    223162    UNUSED_PARAM(videoDeviceUID);
     
    240179
    241180        if (videoDeviceUIDs.isEmpty() && audioDeviceUIDs.isEmpty()) {
    242             denyRequest(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints, emptyString());
     181            denyRequest(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints, "");
    243182            return;
    244183        }
     
    246185        auto userMediaOrigin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(userMediaDocumentOriginIdentifier)->securityOrigin());
    247186        auto topLevelOrigin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(topLevelDocumentOriginIdentifier)->securityOrigin());
    248         auto request = createRequest(userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, audioDeviceUIDs, videoDeviceUIDs);
    249 
    250         String authorizedAudioDevice;
    251         String authorizedVideoDevice;
    252         auto& fameState = stateForRequest(request);
    253         for (auto deviceUID : audioDeviceUIDs) {
    254             if (fameState.hasPermissionToUseCaptureDevice(deviceUID)) {
    255                 authorizedAudioDevice = deviceUID;
    256                 break;
    257             }
     187        auto request = createRequest(userMediaID, audioDeviceUIDs, videoDeviceUIDs);
     188
     189        if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), *userMediaOrigin.get(), *topLevelOrigin.get(), request.get())) {
     190            m_pendingUserMediaRequests.take(userMediaID);
     191            request->deny(UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
    258192        }
    259         for (auto deviceUID : videoDeviceUIDs) {
    260             if (fameState.hasPermissionToUseCaptureDevice(deviceUID)) {
    261                 authorizedVideoDevice = deviceUID;
    262                 break;
    263             }
    264         }
    265 
    266         if (audioDeviceUIDs.isEmpty() == authorizedAudioDevice.isEmpty() && videoDeviceUIDs.isEmpty() == authorizedVideoDevice.isEmpty()) {
    267             userMediaAccessWasGranted(userMediaID, authorizedAudioDevice, authorizedVideoDevice);
    268             return;
    269         }
    270 
    271         if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), *userMediaOrigin.get(), *topLevelOrigin.get(), request.get()))
    272             userMediaAccessWasDenied(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
    273        
    274193    };
    275194
  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.h

    r209008 r209024  
    2323#include "UserMediaPermissionCheckProxy.h"
    2424#include "UserMediaPermissionRequestProxy.h"
    25 #include <WebCore/SecurityOrigin.h>
    2625#include <WebCore/UserMediaRequest.h>
    2726#include <wtf/HashMap.h>
     
    3635class WebPageProxy;
    3736
    38 class FrameAuthorizationState {
    39 public:
    40     explicit FrameAuthorizationState(UserMediaPermissionRequestProxy&);
    41 
    42     bool hasPermissionToUseCaptureDevice(const String& deviceUID);
    43     void setHasPermissionToUseCaptureDevice(const String&, bool);
    44 
    45     void ensureSecurityOriginsAreEqual(UserMediaPermissionRequestProxy&);
    46 
    47 private:
    48     RefPtr<WebCore::SecurityOrigin> m_userMediaDocumentSecurityOrigin;
    49     RefPtr<WebCore::SecurityOrigin> m_topLevelDocumentSecurityOrigin;
    50     Vector<String> m_authorizedDeviceUIDs;
    51 };
    52 
    5337class UserMediaPermissionRequestManagerProxy {
    5438public:
     
    6145    void userMediaAccessWasGranted(uint64_t, const String& audioDeviceUID, const String& videoDeviceUID);
    6246    void userMediaAccessWasDenied(uint64_t, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason);
    63     FrameAuthorizationState& stateForRequest(UserMediaPermissionRequestProxy&);
    6447
    6548    void enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier);
     
    6851
    6952private:
    70     Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID, uint64_t frameID, const String&userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
     53    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
     54    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID);
    7155    void denyRequest(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason, const String& invalidConstraint);
    7256    Ref<UserMediaPermissionCheckProxy> createUserMediaPermissionCheck(uint64_t userMediaID);
     
    8165        Audio = 1 << 1
    8266    };
    83     unsigned m_pageSandboxExtensionsGranted;
    84 
    85     HashMap<uint64_t, std::unique_ptr<FrameAuthorizationState>> m_frameStates;
     67    HashMap<uint64_t, unsigned> m_pageSandboxExtensionsGranted;
    8668
    8769    WebPageProxy& m_page;
  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.cpp

    r209008 r209024  
    2323#include "UserMediaPermissionRequestManagerProxy.h"
    2424#include <WebCore/RealtimeMediaSourceCenter.h>
    25 #include <WebCore/SecurityOrigin.h>
    26 #include <WebCore/SecurityOriginData.h>
    2725#include <wtf/text/StringHash.h>
    28 
    29 using namespace WebCore;
    3026
    3127namespace WebKit {
    3228
    33 UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
     29UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
    3430    : m_manager(&manager)
    3531    , m_userMediaID(userMediaID)
    36     , m_frameID(frameID)
    37     , m_userMediaDocumentSecurityOrigin((SecurityOriginData::fromDatabaseIdentifier(userMediaDocumentOriginIdentifier)->securityOrigin()))
    38     , m_topLevelDocumentSecurityOrigin(SecurityOriginData::fromDatabaseIdentifier(topLevelDocumentOriginIdentifier)->securityOrigin())
    3932    , m_videoDeviceUIDs(videoDeviceUIDs)
    4033    , m_audioDeviceUIDs(audioDeviceUIDs)
  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.h

    r209008 r209024  
    2626#include <wtf/text/WTFString.h>
    2727
    28 namespace WebCore {
    29 class SecurityOrigin;
    30 }
    31 
    3228namespace WebKit {
    3329
     
    3632class UserMediaPermissionRequestProxy : public API::ObjectImpl<API::Object::Type::UserMediaPermissionRequest> {
    3733public:
    38     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)
     34    static Ref<UserMediaPermissionRequestProxy> create(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs)
    3935    {
    40         return adoptRef(*new UserMediaPermissionRequestProxy(manager, userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, videoDeviceUIDs, audioDeviceUIDs));
     36        return adoptRef(*new UserMediaPermissionRequestProxy(manager, userMediaID, videoDeviceUIDs, audioDeviceUIDs));
    4137    }
    4238
     
    5450    const Vector<String>& audioDeviceUIDs() const { return m_audioDeviceUIDs; }
    5551
    56     uint64_t frameID() const { return m_frameID; }
    57     WebCore::SecurityOrigin* userMediaDocumentSecurityOrigin() { return &m_userMediaDocumentSecurityOrigin.get(); }
    58     WebCore::SecurityOrigin* topLevelDocumentSecurityOrigin() { return &m_topLevelDocumentSecurityOrigin.get(); }
    59 
    6052private:
    61     UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy&, uint64_t userMediaID, uint64_t frameID, const String& userMediaDocumentOriginIdentifier, const String& topLevelDocumentOriginIdentifier, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs);
     53    UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy&, uint64_t userMediaID, const Vector<String>& videoDeviceUIDs, const Vector<String>& audioDeviceUIDs);
    6254
    6355    UserMediaPermissionRequestManagerProxy* m_manager;
    6456    uint64_t m_userMediaID;
    65     uint64_t m_frameID;
    66     Ref<WebCore::SecurityOrigin> m_userMediaDocumentSecurityOrigin;
    67     Ref<WebCore::SecurityOrigin> m_topLevelDocumentSecurityOrigin;
    6857    Vector<String> m_videoDeviceUIDs;
    6958    Vector<String> m_audioDeviceUIDs;
  • trunk/Tools/ChangeLog

    r209012 r209024  
     12016-11-28  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r209008.
     4
     5        This change appears to have caused two fast/mediastrem
     6        LayoutTests to fail.
     7
     8        Reverted changeset:
     9
     10        "[MediaStream] Don't request user permission for a device if
     11        it has already been granted in the current browsing context"
     12        https://bugs.webkit.org/show_bug.cgi?id=164760
     13        http://trac.webkit.org/changeset/209008
     14
    1152016-11-28  Daniel Bates  <dabates@apple.com>
    216
  • trunk/Tools/WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl

    r209008 r209024  
    186186    // MediaStream
    187187    void setUserMediaPermission(boolean value);
    188     void setUserMediaPersistentPermissionForOrigin(boolean permission, DOMString origin, DOMString parentOrigin);
    189     unsigned long userMediaPermissionRequestCountForOrigin(DOMString origin, DOMString parentOrigin);
    190     void resetUserMediaPermissionRequestCountForOrigin(DOMString origin, DOMString parentOrigin);
     188    void setUserMediaPermissionForOrigin(boolean permission, DOMString origin, DOMString parentOrigin);
    191189
    192190    // Audio testing.
  • trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp

    r209008 r209024  
    583583}
    584584
    585 void InjectedBundle::setUserMediaPersistentPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin)
    586 {
    587     auto messageName = adoptWK(WKStringCreateWithUTF8CString("SetUserMediaPersistentPermissionForOrigin"));
     585void InjectedBundle::setUserMediaPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin)
     586{
     587    auto messageName = adoptWK(WKStringCreateWithUTF8CString("SetUserMediaPermissionForOrigin"));
    588588    WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
    589589
     
    591591    WKRetainPtr<WKBooleanRef> permissionWK(AdoptWK, WKBooleanCreate(permission));
    592592    WKDictionarySetItem(messageBody.get(), permissionKeyWK.get(), permissionWK.get());
    593 
    594     WKRetainPtr<WKStringRef> originKeyWK(AdoptWK, WKStringCreateWithUTF8CString("origin"));
    595     WKDictionarySetItem(messageBody.get(), originKeyWK.get(), origin);
    596 
    597     WKRetainPtr<WKStringRef> parentOriginKeyWK(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
    598     WKDictionarySetItem(messageBody.get(), parentOriginKeyWK.get(), parentOrigin);
    599 
    600     WKBundlePagePostMessage(page()->page(), messageName.get(), messageBody.get());
    601 }
    602 
    603 unsigned InjectedBundle::userMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin) const
    604 {
    605     WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString("UserMediaPermissionRequestCountForOrigin"));
    606     WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
    607 
    608     WKRetainPtr<WKStringRef> originKeyWK(AdoptWK, WKStringCreateWithUTF8CString("origin"));
    609     WKDictionarySetItem(messageBody.get(), originKeyWK.get(), origin);
    610 
    611     WKRetainPtr<WKStringRef> parentOriginKeyWK(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
    612     WKDictionarySetItem(messageBody.get(), parentOriginKeyWK.get(), parentOrigin);
    613 
    614     WKTypeRef resultToPass = 0;
    615     WKBundlePagePostSynchronousMessageForTesting(page()->page(), messageName.get(), messageBody.get(), &resultToPass);
    616     WKRetainPtr<WKUInt64Ref> count(AdoptWK, static_cast<WKUInt64Ref>(resultToPass));
    617 
    618     return static_cast<unsigned>(WKUInt64GetValue(count.get()));
    619 }
    620 
    621 void InjectedBundle::resetUserMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin)
    622 {
    623     WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString("ResetUserMediaPermissionRequestCountForOrigin"));
    624     WKRetainPtr<WKMutableDictionaryRef> messageBody(AdoptWK, WKMutableDictionaryCreate());
    625593
    626594    WKRetainPtr<WKStringRef> originKeyWK(AdoptWK, WKStringCreateWithUTF8CString("origin"));
  • trunk/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.h

    r209008 r209024  
    102102    // MediaStream.
    103103    void setUserMediaPermission(bool);
    104     void setUserMediaPersistentPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin);
    105     unsigned userMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin) const;
    106     void resetUserMediaPermissionRequestCountForOrigin(WKStringRef origin, WKStringRef parentOrigin);
     104    void setUserMediaPermissionForOrigin(bool permission, WKStringRef origin, WKStringRef parentOrigin);
    107105
    108106    // Policy delegate.
  • trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp

    r209008 r209024  
    890890}
    891891
    892 void TestRunner::setUserMediaPersistentPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin)
     892void TestRunner::setUserMediaPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin)
    893893{
    894894    WKRetainPtr<WKStringRef> originWK = toWK(origin);
    895895    WKRetainPtr<WKStringRef> parentOriginWK = toWK(parentOrigin);
    896     InjectedBundle::singleton().setUserMediaPersistentPermissionForOrigin(permission, originWK.get(), parentOriginWK.get());
    897 }
    898 
    899 unsigned TestRunner::userMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin) const
    900 {
    901     WKRetainPtr<WKStringRef> originWK = toWK(origin);
    902     WKRetainPtr<WKStringRef> parentOriginWK = toWK(parentOrigin);
    903     return InjectedBundle::singleton().userMediaPermissionRequestCountForOrigin(originWK.get(), parentOriginWK.get());
    904 }
    905 
    906 void TestRunner::resetUserMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin)
    907 {
    908     WKRetainPtr<WKStringRef> originWK = toWK(origin);
    909     WKRetainPtr<WKStringRef> parentOriginWK = toWK(parentOrigin);
    910     InjectedBundle::singleton().resetUserMediaPermissionRequestCountForOrigin(originWK.get(), parentOriginWK.get());
     896    InjectedBundle::singleton().setUserMediaPermissionForOrigin(permission, originWK.get(), parentOriginWK.get());
    911897}
    912898
  • trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.h

    r209008 r209024  
    287287    // MediaStream
    288288    void setUserMediaPermission(bool);
    289     void setUserMediaPersistentPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin);
    290     unsigned userMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin) const;
    291     void resetUserMediaPermissionRequestCountForOrigin(JSStringRef origin, JSStringRef parentOrigin);
     289    void setUserMediaPermissionForOrigin(bool permission, JSStringRef origin, JSStringRef parentOrigin);
    292290
    293291    void setPageVisibility(JSStringRef state);
     
    403401    WKRetainPtr<WKArrayRef> m_allowedHosts;
    404402
    405     size_t m_userMediaPermissionRequestCount { 0 };
    406 
    407403    PlatformTimerRef m_waitToDumpWatchdogTimer;
    408404};
  • trunk/Tools/WebKitTestRunner/TestController.cpp

    r209008 r209024  
    766766    // Reset UserMedia permissions.
    767767    m_userMediaPermissionRequests.clear();
    768     m_cachedUserMediaPermissions.clear();
     768    m_cahcedUserMediaPermissions.clear();
    769769    m_isUserMediaPermissionSet = false;
    770770    m_isUserMediaPermissionAllowed = false;
     
    18861886    HashMap<uint64_t, String>& ephemeralSalts() { return m_ephemeralSalts; }
    18871887
    1888     void incrementRequestCount() { ++m_requestCount; }
    1889     void resetRequestCount() { m_requestCount = 0; }
    1890     unsigned requestCount() const { return m_requestCount; }
    1891 
    18921888private:
    18931889    HashMap<uint64_t, String> m_ephemeralSalts;
    18941890    String m_persistentSalt;
    1895     unsigned m_requestCount { 0 };
    18961891    bool m_persistentPermission { false };
    18971892};
     
    18991894String TestController::saltForOrigin(WKFrameRef frame, String originHash)
    19001895{
    1901     auto& settings = settingsForOrigin(originHash);
    1902     auto& ephemeralSalts = settings.ephemeralSalts();
     1896    RefPtr<OriginSettings> settings = m_cahcedUserMediaPermissions.get(originHash);
     1897    if (!settings) {
     1898        settings = adoptRef(*new OriginSettings());
     1899        m_cahcedUserMediaPermissions.add(originHash, settings);
     1900    }
     1901
     1902    auto& ephemeralSalts = settings->ephemeralSalts();
    19031903    auto frameInfo = adoptWK(WKFrameCreateFrameInfo(frame));
    19041904    auto frameHandle = WKFrameInfoGetFrameHandleRef(frameInfo.get());
     
    19061906    String frameSalt = ephemeralSalts.get(frameIdentifier);
    19071907
    1908     if (settings.persistentPermission()) {
     1908    if (settings->persistentPermission()) {
    19091909        if (frameSalt.length())
    19101910            return frameSalt;
    19111911
    1912         if (!settings.persistentSalt().length())
    1913             settings.setPersistentSalt(createCanonicalUUIDString());
    1914 
    1915         return settings.persistentSalt();
     1912        if (!settings->persistentSalt().length())
     1913            settings->setPersistentSalt(createCanonicalUUIDString());
     1914
     1915        return settings->persistentSalt();
    19161916    }
    19171917
     
    19241924}
    19251925
    1926 void TestController::setUserMediaPersistentPermissionForOrigin(bool permission, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
     1926void TestController::setUserMediaPermissionForOrigin(bool permission, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
    19271927{
    19281928    auto originHash = userMediaOriginHash(userMediaDocumentOriginString, topLevelDocumentOriginString);
    1929     auto& settings = settingsForOrigin(originHash);
    1930     settings.setPersistentPermission(permission);
     1929    RefPtr<OriginSettings> settings = m_cahcedUserMediaPermissions.get(originHash);
     1930    if (!settings) {
     1931        settings = adoptRef(*new OriginSettings());
     1932        m_cahcedUserMediaPermissions.add(originHash, settings);
     1933    }
     1934
     1935    settings->setPersistentPermission(permission);
    19311936}
    19321937
     
    19361941    auto salt = saltForOrigin(frame, originHash);
    19371942
    1938     WKUserMediaPermissionCheckSetUserMediaAccessInfo(checkRequest, WKStringCreateWithUTF8CString(salt.utf8().data()), settingsForOrigin(originHash).persistentPermission());
     1943    WKUserMediaPermissionCheckSetUserMediaAccessInfo(checkRequest, WKStringCreateWithUTF8CString(salt.utf8().data()), m_cahcedUserMediaPermissions.get(originHash)->persistentPermission());
    19391944}
    19401945
     
    19461951}
    19471952
    1948 OriginSettings& TestController::settingsForOrigin(const String& originHash)
    1949 {
    1950     RefPtr<OriginSettings> settings = m_cachedUserMediaPermissions.get(originHash);
    1951     if (!settings) {
    1952         settings = adoptRef(*new OriginSettings());
    1953         m_cachedUserMediaPermissions.add(originHash, settings);
    1954     }
    1955 
    1956     return *settings;
    1957 }
    1958 
    1959 unsigned TestController::userMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
    1960 {
    1961     auto originHash = userMediaOriginHash(userMediaDocumentOriginString, topLevelDocumentOriginString);
    1962     return settingsForOrigin(originHash).requestCount();
    1963 }
    1964 
    1965 void TestController::resetUserMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString)
    1966 {
    1967     auto originHash = userMediaOriginHash(userMediaDocumentOriginString, topLevelDocumentOriginString);
    1968     settingsForOrigin(originHash).resetRequestCount();
    1969 }
    1970 
    19711953void TestController::decidePolicyForUserMediaPermissionRequestIfPossible()
    19721954{
     
    19781960        auto request = pair.second.get();
    19791961
    1980         auto& settings = settingsForOrigin(originHash);
    1981         settings.incrementRequestCount();
    1982 
    1983         if (!m_isUserMediaPermissionAllowed && !settings.persistentPermission()) {
     1962        bool persistentPermission = false;
     1963        RefPtr<OriginSettings> settings = m_cahcedUserMediaPermissions.get(originHash);
     1964        if (settings)
     1965            persistentPermission = settings->persistentPermission();
     1966
     1967        if (!m_isUserMediaPermissionAllowed && !persistentPermission) {
    19841968            WKUserMediaPermissionRequestDeny(request, kWKPermissionDenied);
    19851969            continue;
  • trunk/Tools/WebKitTestRunner/TestController.h

    r209008 r209024  
    102102    WKStringRef getUserMediaSaltForOrigin(WKFrameRef, WKStringRef originKey);
    103103    void setUserMediaPermission(bool);
    104     void setUserMediaPersistentPermissionForOrigin(bool, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
     104    void setUserMediaPermissionForOrigin(bool, WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
    105105    void handleUserMediaPermissionRequest(WKFrameRef, WKSecurityOriginRef, WKSecurityOriginRef, WKUserMediaPermissionRequestRef);
    106106    void handleCheckOfUserMediaPermissionForOrigin(WKFrameRef, WKSecurityOriginRef, WKSecurityOriginRef, const WKUserMediaPermissionCheckRef&);
    107     OriginSettings& settingsForOrigin(const String&);
    108     unsigned userMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
    109     void resetUserMediaPermissionRequestCountForOrigin(WKStringRef userMediaDocumentOriginString, WKStringRef topLevelDocumentOriginString);
    110107
    111108    // Policy delegate.
     
    320317    bool m_isGeolocationPermissionAllowed { false };
    321318
    322     HashMap<String, RefPtr<OriginSettings>> m_cachedUserMediaPermissions;
     319    HashMap<String, RefPtr<OriginSettings>> m_cahcedUserMediaPermissions;
    323320
    324321    typedef Vector<std::pair<String, WKRetainPtr<WKUserMediaPermissionRequestRef>>> PermissionRequestList;
  • trunk/Tools/WebKitTestRunner/TestInvocation.cpp

    r209008 r209024  
    497497    }
    498498
    499     if (WKStringIsEqualToUTF8CString(messageName, "SetUserMediaPersistentPermissionForOrigin")) {
     499    if (WKStringIsEqualToUTF8CString(messageName, "SetUserMediaPermissionForOrigin")) {
    500500        ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
    501501        WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
     
    511511        WKStringRef parentOriginWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, parentOriginKey.get()));
    512512
    513         TestController::singleton().setUserMediaPersistentPermissionForOrigin(permission, originWK, parentOriginWK);
    514         return;
    515     }
    516 
    517     if (WKStringIsEqualToUTF8CString(messageName, "ResetUserMediaPermissionRequestCountForOrigin")) {
    518         ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
    519         WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
    520 
    521         WKRetainPtr<WKStringRef> originKey(AdoptWK, WKStringCreateWithUTF8CString("origin"));
    522         WKStringRef originWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, originKey.get()));
    523 
    524         WKRetainPtr<WKStringRef> parentOriginKey(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
    525         WKStringRef parentOriginWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, parentOriginKey.get()));
    526        
    527         TestController::singleton().resetUserMediaPermissionRequestCountForOrigin(originWK, parentOriginWK);
     513        TestController::singleton().setUserMediaPermissionForOrigin(permission, originWK, parentOriginWK);
    528514        return;
    529515    }
     
    861847#endif // PLATFORM(MAC)
    862848
    863     if (WKStringIsEqualToUTF8CString(messageName, "UserMediaPermissionRequestCountForOrigin")) {
    864         ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
    865         WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
    866 
    867         WKRetainPtr<WKStringRef> originKey(AdoptWK, WKStringCreateWithUTF8CString("origin"));
    868         WKStringRef originWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, originKey.get()));
    869 
    870         WKRetainPtr<WKStringRef> parentOriginKey(AdoptWK, WKStringCreateWithUTF8CString("parentOrigin"));
    871         WKStringRef parentOriginWK = static_cast<WKStringRef>(WKDictionaryGetItemForKey(messageBodyDictionary, parentOriginKey.get()));
    872        
    873         unsigned count = TestController::singleton().userMediaPermissionRequestCountForOrigin(originWK, parentOriginWK);
    874         WKRetainPtr<WKUInt64Ref> result(AdoptWK, WKUInt64Create(count));
    875         return result;
    876     }
    877 
    878 
    879849    ASSERT_NOT_REACHED();
    880850    return nullptr;
Note: See TracChangeset for help on using the changeset viewer.