Attachment 356854 Details for Bug 192511 – Patch for landing.

[patch] Patch for landing.

bug-192511-20181207165440.patch (text/plain), 32.00 KB, created by Eric Carlson on 2018-12-07 16:54:41 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Eric Carlson

Created: 2018-12-07 16:54:41 PST

Size: 32.00 KB

patch

obsolete

>Subversion Revision: 238964
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 764c2c369812f4d9d508ec79b6fa1607de42e870..e9905f3610d0bd184a6a59f82468a83671ba5ad8 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,17 @@
>+2018-12-07  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [MediaStream] 'devicechange' event should not fire in frames that can't access capture devices
>+        https://bugs.webkit.org/show_bug.cgi?id=192511
>+        <rdar://problem/46562063>
>+
>+        Reviewed by Youenn Fablet.
>+
>+        Test: http/tests/media/media-stream/device-change-event-in-iframe.html
>+
>+        * Modules/mediastream/MediaDevices.cpp:
>+        (WebCore::MediaDevices::addEventListener): Don't fire the event unless the document can
>+        access a camera or microphone.
>+
> 2018-12-07  Antti Koivisto  <antti@apple.com>
> 
>         Rename LayoutState to RenderLayoutState
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 0d0e15c1c2e571d34c4d39d83e15c6a01107042a..21c0c8fa54b6de4b6d8634006a9d5eaccf5b1bd2 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,27 @@
>+2018-12-07  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [MediaStream] 'devicechange' event should not fire in frames that can't access capture devices
>+        https://bugs.webkit.org/show_bug.cgi?id=192511
>+        <rdar://problem/46562063>
>+
>+        Reviewed by Youenn Fablet.
>+
>+        * UIProcess/UserMediaPermissionCheckProxy.cpp:
>+        (WebKit::UserMediaPermissionCheckProxy::UserMediaPermissionCheckProxy): Remove userMediaID parameter.
>+        (WebKit::UserMediaPermissionCheckProxy::setUserMediaAccessInfo): ID not passed to callback.
>+        * UIProcess/UserMediaPermissionCheckProxy.h:
>+        (WebKit::UserMediaPermissionCheckProxy::create):
>+        (WebKit::UserMediaPermissionCheckProxy::completionHandler): Deleted.
>+
>+        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
>+        (WebKit::generateRequestID): New.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::captureDevicesChanged): Don't notify if
>+        the page does not have a granted request and does not have persistent access.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame): Use generateRequestID.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::getUserMediaPermissionInfo): Change variable name.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame): Use generateRequestID.
>+        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
>+
> 2018-12-07  Truitt Savell  <tsavell@apple.com>
> 
>         Unreviewed, rolling out r238947.
>diff --git a/Source/WebCore/Modules/mediastream/MediaDevices.cpp b/Source/WebCore/Modules/mediastream/MediaDevices.cpp
>index 91c51ad245205a0e45746d6a511751ab2eadbbfc..14bb977536bbfbff2eac630906409440dbfa3cfc 100644
>--- a/Source/WebCore/Modules/mediastream/MediaDevices.cpp
>+++ b/Source/WebCore/Modules/mediastream/MediaDevices.cpp
>@@ -190,6 +190,16 @@ bool MediaDevices::addEventListener(const AtomicString& eventType, Ref<EventList
>                 if (!weakThis || m_scheduledEventTimer.isActive())
>                     return;
> 
>+                auto* document = this->document();
>+                auto* controller = document ? UserMediaController::from(document->page()) : nullptr;
>+                if (!controller)
>+                    return;
>+
>+                bool canAccessMicrophone = controller->canCallGetUserMedia(*document, { UserMediaController::CaptureType::Microphone }) == UserMediaController::GetUserMediaAccess::CanCall;
>+                bool canAccessCamera = controller->canCallGetUserMedia(*document, { UserMediaController::CaptureType::Camera }) == UserMediaController::GetUserMediaAccess::CanCall;
>+                if (!canAccessMicrophone && !canAccessCamera)
>+                    return;
>+
>                 m_scheduledEventTimer.startOneShot(Seconds(randomNumber() / 2));
>             });
>         }
>diff --git a/Source/WebCore/Modules/mediastream/MediaStreamTrack.h b/Source/WebCore/Modules/mediastream/MediaStreamTrack.h
>index e346f813e6cfb9a702ac5e1685d333ed2a05cbfb..d82c3a9d8a36d75a898abd03e4ffa4a8578f3466 100644
>--- a/Source/WebCore/Modules/mediastream/MediaStreamTrack.h
>+++ b/Source/WebCore/Modules/mediastream/MediaStreamTrack.h
>@@ -177,7 +177,7 @@ private:
>     void trackEnabledChanged(MediaStreamTrackPrivate&) final;
> 
>     Vector<Observer*> m_observers;
>-    
>+
> 
>     MediaTrackConstraints m_constraints;
>     std::optional<DOMPromiseDeferred<void>> m_promise;
>diff --git a/Source/WebKit/Scripts/webkit/messages.py b/Source/WebKit/Scripts/webkit/messages.py
>index 2c8416890b417c6d91070854d10b65628d52d2a9..2b6fa52002214a295104107b0d1bcf4076baff7e 100644
>--- a/Source/WebKit/Scripts/webkit/messages.py
>+++ b/Source/WebKit/Scripts/webkit/messages.py
>@@ -440,7 +440,6 @@ def headers_for_type(type):
>         'WebCore::SelectionRect': ['"EditorState.h"'],
>         'WebKit::ActivityStateChangeID': ['"DrawingAreaInfo.h"'],
>         'WebKit::BackForwardListItemState': ['"SessionState.h"'],
>-        'WebKit::DeviceAccessState': ['"UserMediaPermissionRequestManager.h"'],
>         'WebKit::LayerHostingMode': ['"LayerTreeContext.h"'],
>         'WebKit::PageState': ['"SessionState.h"'],
>         'WebKit::WebGestureEvent': ['"WebEvent.h"'],
>diff --git a/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.cpp b/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.cpp
>index 953bbb1156c30662234f9145c3c5c0265a4df497..96513eb011b000de0371bf7d222508214f2da7df 100644
>--- a/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.cpp
>+++ b/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.cpp
>@@ -33,9 +33,8 @@
> namespace WebKit {
> using namespace WebCore;
> 
>-UserMediaPermissionCheckProxy::UserMediaPermissionCheckProxy(uint64_t userMediaID, uint64_t frameID, CompletionHandler&& handler, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin)
>-    : m_userMediaID(userMediaID)
>-    , m_frameID(frameID)
>+UserMediaPermissionCheckProxy::UserMediaPermissionCheckProxy(uint64_t frameID, CompletionHandler&& handler, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin)
>+    : m_frameID(frameID)
>     , m_completionHandler(WTFMove(handler))
>     , m_userMediaDocumentSecurityOrigin(WTFMove(userMediaDocumentOrigin))
>     , m_topLevelDocumentSecurityOrigin(WTFMove(topLevelDocumentOrigin))
>@@ -48,7 +47,7 @@ void UserMediaPermissionCheckProxy::setUserMediaAccessInfo(bool allowed)
>     if (!m_completionHandler)
>         return;
> 
>-    m_completionHandler(m_userMediaID, allowed);
>+    m_completionHandler(allowed);
>     m_completionHandler = nullptr;
> }
> 
>diff --git a/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.h b/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.h
>index 618d6631d5d362642d20e14d6a104d1aa1c9aab6..d91f04ffdab8d142454d5063fe17f0ebfa8334eb 100644
>--- a/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.h
>+++ b/Source/WebKit/UIProcess/UserMediaPermissionCheckProxy.h
>@@ -39,11 +39,11 @@ namespace WebKit {
> class UserMediaPermissionCheckProxy : public API::ObjectImpl<API::Object::Type::UserMediaPermissionCheck> {
> public:
> 
>-    using CompletionHandler = WTF::Function<void(uint64_t, bool allowed)>;
>+    using CompletionHandler = WTF::Function<void(bool allowed)>;
> 
>-    static Ref<UserMediaPermissionCheckProxy> create(uint64_t userMediaID, uint64_t frameID, CompletionHandler&& handler, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin)
>+    static Ref<UserMediaPermissionCheckProxy> create(uint64_t frameID, CompletionHandler&& handler, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin)
>     {
>-        return adoptRef(*new UserMediaPermissionCheckProxy(userMediaID, frameID, WTFMove(handler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin)));
>+        return adoptRef(*new UserMediaPermissionCheckProxy(frameID, WTFMove(handler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin)));
>     }
> 
>     void setUserMediaAccessInfo(bool);
>@@ -53,12 +53,9 @@ public:
>     WebCore::SecurityOrigin& userMediaDocumentSecurityOrigin() { return m_userMediaDocumentSecurityOrigin.get(); }
>     WebCore::SecurityOrigin& topLevelDocumentSecurityOrigin() { return m_topLevelDocumentSecurityOrigin.get(); }
>     
>-    CompletionHandler& completionHandler() { return m_completionHandler; }
>-    
> private:
>-    UserMediaPermissionCheckProxy(uint64_t userMediaID, uint64_t frameID, CompletionHandler&&, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin);
>+    UserMediaPermissionCheckProxy(uint64_t frameID, CompletionHandler&&, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin);
> 
>-    uint64_t m_userMediaID;
>     uint64_t m_frameID;
>     CompletionHandler m_completionHandler;
>     Ref<WebCore::SecurityOrigin> m_userMediaDocumentSecurityOrigin;
>diff --git a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp
>index 1a066203e7ce746dd2b0a6cf6fa0acb511b5bef8..95f553dd225ebcaf3db8f9ad02b57a43a8bcbf83 100644
>--- a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp
>+++ b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp
>@@ -43,6 +43,12 @@ using namespace WebCore;
> static const MediaProducer::MediaStateFlags activeCaptureMask = MediaProducer::HasActiveAudioCaptureDevice | MediaProducer::HasActiveVideoCaptureDevice;
> #endif
> 
>+static uint64_t generateRequestID()
>+{
>+    static uint64_t uniqueRequestID = 1;
>+    return uniqueRequestID++;
>+}
>+
> UserMediaPermissionRequestManagerProxy::UserMediaPermissionRequestManagerProxy(WebPageProxy& page)
>     : m_page(page)
>     , m_rejectionTimer(RunLoop::main(), this, &UserMediaPermissionRequestManagerProxy::rejectionTimerFired)
>@@ -81,9 +87,24 @@ void UserMediaPermissionRequestManagerProxy::stopCapture()
> void UserMediaPermissionRequestManagerProxy::captureDevicesChanged()
> {
> #if ENABLE(MEDIA_STREAM)
>-    // FIXME: a page with persistent access should always get device change notifications.
>-    auto accessState = m_grantedRequests.isEmpty() ? DeviceAccessState::NoAccess : DeviceAccessState::SessionAccess;
>-    m_page.process().send(Messages::WebPage::CaptureDevicesChanged(accessState), m_page.pageID());
>+    if (!m_page.isValid() || !m_page.mainFrame())
>+        return;
>+
>+    auto requestID = generateRequestID();
>+    auto handler = [this, requestID](bool originHasPersistentAccess) mutable {
>+
>+        auto pendingRequest = m_pendingDeviceRequests.take(requestID);
>+        if (!pendingRequest || !m_page.isValid())
>+            return;
>+
>+        if (m_grantedRequests.isEmpty() && !originHasPersistentAccess)
>+            return;
>+
>+        m_page.process().send(Messages::WebPage::CaptureDevicesChanged(), m_page.pageID());
>+    };
>+
>+    auto origin = WebCore::SecurityOrigin::create(m_page.mainFrame()->url());
>+    getUserMediaPermissionInfo(requestID, m_page.mainFrame()->frameID(), WTFMove(handler), origin.get(), WTFMove(origin));
> #endif
> }
> 
>@@ -357,9 +378,10 @@ void UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame(
>             userMediaAccessWasDenied(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
>     };
> 
>-    auto havePermissionInfoHandler = [this, validHandler = WTFMove(validHandler), invalidHandler = WTFMove(invalidHandler), localUserRequest = userRequest](uint64_t userMediaID, bool originHasPersistentAccess) mutable {
>+    auto requestID = generateRequestID();
>+    auto havePermissionInfoHandler = [this, requestID, validHandler = WTFMove(validHandler), invalidHandler = WTFMove(invalidHandler), localUserRequest = userRequest](bool originHasPersistentAccess) mutable {
> 
>-        auto pendingRequest = m_pendingDeviceRequests.take(userMediaID);
>+        auto pendingRequest = m_pendingDeviceRequests.take(requestID);
>         if (!pendingRequest)
>             return;
> 
>@@ -372,7 +394,7 @@ void UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame(
>         RealtimeMediaSourceCenter::singleton().validateRequestConstraints(WTFMove(validHandler), WTFMove(invalidHandler), WTFMove(localUserRequest), WTFMove(deviceIDHashSalt));
>     };
> 
>-    getUserMediaPermissionInfo(userMediaID, frameID, WTFMove(havePermissionInfoHandler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin));
>+    getUserMediaPermissionInfo(requestID, frameID, WTFMove(havePermissionInfoHandler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin));
> #else
>     UNUSED_PARAM(userMediaID);
>     UNUSED_PARAM(frameID);
>@@ -383,21 +405,21 @@ void UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame(
> }
> 
> #if ENABLE(MEDIA_STREAM)
>-void UserMediaPermissionRequestManagerProxy::getUserMediaPermissionInfo(uint64_t userMediaID, uint64_t frameID, UserMediaPermissionCheckProxy::CompletionHandler&& handler, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin)
>+void UserMediaPermissionRequestManagerProxy::getUserMediaPermissionInfo(uint64_t requestID, uint64_t frameID, UserMediaPermissionCheckProxy::CompletionHandler&& handler, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin)
> {
>     if (!m_page.websiteDataStore().deviceIdHashSaltStorage()) {
>-        handler(userMediaID, false);
>+        handler(false);
>         return;
>     }
> 
>     auto userMediaOrigin = API::SecurityOrigin::create(userMediaDocumentOrigin.get());
>     auto topLevelOrigin = API::SecurityOrigin::create(topLevelDocumentOrigin.get());
>-    auto request = UserMediaPermissionCheckProxy::create(userMediaID, frameID, WTFMove(handler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin));
>+    auto request = UserMediaPermissionCheckProxy::create(frameID, WTFMove(handler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin));
> 
>-    m_pendingDeviceRequests.add(userMediaID, request.copyRef());
>+    m_pendingDeviceRequests.add(requestID, request.copyRef());
>     if (!m_page.uiClient().checkUserMediaPermissionForOrigin(m_page, *m_page.process().webFrame(frameID), userMediaOrigin.get(), topLevelOrigin.get(), request.get())) {
>-        m_pendingDeviceRequests.take(userMediaID);
>-        request->completionHandler()(userMediaID, false);
>+        m_pendingDeviceRequests.take(requestID);
>+        handler(false);
>     }
> }
> 
>@@ -432,8 +454,9 @@ void UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame(uint6
> #endif
>     static const int defaultMaximumMicrophoneCount = 1;
> 
>-    auto completionHandler = [this, requestOrigin = userMediaDocumentOrigin.copyRef(), topOrigin = topLevelDocumentOrigin.copyRef()](uint64_t userMediaID, bool originHasPersistentAccess) {
>-        auto pendingRequest = m_pendingDeviceRequests.take(userMediaID);
>+    auto requestID = generateRequestID();
>+    auto completionHandler = [this, requestID, userMediaID, requestOrigin = userMediaDocumentOrigin.copyRef(), topOrigin = topLevelDocumentOrigin.copyRef()](bool originHasPersistentAccess) {
>+        auto pendingRequest = m_pendingDeviceRequests.take(requestID);
>         if (!pendingRequest)
>             return;
> 
>@@ -478,7 +501,7 @@ void UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame(uint6
>         m_page.process().send(Messages::WebPage::DidCompleteMediaDeviceEnumeration(userMediaID, WTFMove(filteredDevices), WTFMove(deviceIDHashSalt), originHasPersistentAccess), m_page.pageID());
>     };
> 
>-    getUserMediaPermissionInfo(userMediaID, frameID, WTFMove(completionHandler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin));
>+    getUserMediaPermissionInfo(requestID, frameID, WTFMove(completionHandler), WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin));
> #else
>     UNUSED_PARAM(userMediaID);
>     UNUSED_PARAM(frameID);
>diff --git a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h
>index 24443db0fb792ab3e8adb7ee59fa3119936a3b7b..16acded88495ae81e6e69fef1c4b7ce0a078e4b7 100644
>--- a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h
>+++ b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h
>@@ -75,7 +75,7 @@ private:
>     const UserMediaPermissionRequestProxy* searchForGrantedRequest(uint64_t frameID, const WebCore::SecurityOrigin& userMediaDocumentOrigin, const WebCore::SecurityOrigin& topLevelDocumentOrigin, bool needsAudio, bool needsVideo) const;
>     bool wasRequestDenied(uint64_t mainFrameID, const WebCore::SecurityOrigin& userMediaDocumentOrigin, const WebCore::SecurityOrigin& topLevelDocumentOrigin, bool needsAudio, bool needsVideo, bool needsScreenCapture);
> 
>-    void getUserMediaPermissionInfo(uint64_t userMediaID, uint64_t frameID, UserMediaPermissionCheckProxy::CompletionHandler&&, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin);
>+    void getUserMediaPermissionInfo(uint64_t requestID, uint64_t frameID, UserMediaPermissionCheckProxy::CompletionHandler&&, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin);
> 
>     enum class RequestAction {
>         Deny,
>diff --git a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
>index 81824b0ffd0d41d723efe43ab123b1924098efa7..acb99fc56a94f18dd8a41f83465a1b88279b03d2 100644
>--- a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
>+++ b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
>@@ -53,8 +53,6 @@ UserMediaPermissionRequestManager::UserMediaPermissionRequestManager(WebPage& pa
> 
> UserMediaPermissionRequestManager::~UserMediaPermissionRequestManager()
> {
>-    if (m_monitoringActivityStateChange)
>-        m_page.corePage()->removeActivityStateChangeObserver(*this);
>     for (auto& sandboxExtension : m_userMediaDeviceSandboxExtensions)
>         sandboxExtension.value->revoke();
> }
>@@ -245,7 +243,7 @@ void UserMediaPermissionRequestManager::removeDeviceChangeObserver(UserMediaClie
>     ASSERT_UNUSED(wasRemoved, wasRemoved);
> }
> 
>-void UserMediaPermissionRequestManager::captureDevicesChanged(DeviceAccessState accessState)
>+void UserMediaPermissionRequestManager::captureDevicesChanged()
> {
>     // When new media input and/or output devices are made available, or any available input and/or
>     // output device becomes unavailable, the User Agent MUST run the following steps in browsing
>@@ -255,19 +253,6 @@ void UserMediaPermissionRequestManager::captureDevicesChanged(DeviceAccessState
>     // * any of the input devices are attached to an active MediaStream in the browsing context, or
>     // * the active document is fully active and has focus.
> 
>-    bool isActive = m_page.corePage()->activityState().containsAll(focusedActiveWindow);
>-    if (!isActive && accessState == DeviceAccessState::NoAccess) {
>-        if (!isActive) {
>-            if (!m_monitoringActivityStateChange) {
>-                m_monitoringActivityStateChange = true;
>-                m_page.corePage()->addActivityStateChangeObserver(*this);
>-            }
>-            m_pendingDeviceChangeEvent = true;
>-            m_accessStateWhenDevicesChanged = accessState;
>-        }
>-        return;
>-    }
>-
>     auto identifiers = m_deviceChangeObserverMap.keys();
>     for (auto& identifier : identifiers) {
>         auto iterator = m_deviceChangeObserverMap.find(identifier);
>@@ -276,28 +261,6 @@ void UserMediaPermissionRequestManager::captureDevicesChanged(DeviceAccessState
>     }
> }
> 
>-void UserMediaPermissionRequestManager::activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> oldActivityState, OptionSet<WebCore::ActivityState::Flag> newActivityState)
>-{
>-    if (!newActivityState.containsAll(focusedActiveWindow))
>-        return;
>-
>-    RunLoop::main().dispatch([this, weakThis = makeWeakPtr(*this)]() mutable {
>-        if (!weakThis || !m_monitoringActivityStateChange)
>-            return;
>-
>-        m_monitoringActivityStateChange = false;
>-        m_page.corePage()->removeActivityStateChangeObserver(*this);
>-    });
>-
>-    if (!m_pendingDeviceChangeEvent)
>-        return;
>-
>-    m_pendingDeviceChangeEvent = false;
>-    auto accessState = m_accessStateWhenDevicesChanged;
>-    m_accessStateWhenDevicesChanged = DeviceAccessState::NoAccess;
>-    captureDevicesChanged(accessState);
>-}
>-
> } // namespace WebKit
> 
> #endif // ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h
>index 8b86eac24544501a506825e53c7305ea889eaf38..6004290399e02f4911e55502d073bfb4f3608062 100644
>--- a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h
>+++ b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h
>@@ -23,7 +23,6 @@
> 
> #include "MediaDeviceSandboxExtensions.h"
> #include "SandboxExtension.h"
>-#include <WebCore/ActivityStateChangeObserver.h>
> #include <WebCore/MediaCanStartListener.h>
> #include <WebCore/MediaConstraints.h>
> #include <WebCore/MediaDevicesEnumerationRequest.h>
>@@ -37,9 +36,7 @@ namespace WebKit {
> 
> class WebPage;
> 
>-enum class DeviceAccessState : uint8_t { NoAccess, SessionAccess, PersistentAccess };
>-
>-class UserMediaPermissionRequestManager : public CanMakeWeakPtr<UserMediaPermissionRequestManager>, private WebCore::MediaCanStartListener, private WebCore::ActivityStateChangeObserver {
>+class UserMediaPermissionRequestManager : public CanMakeWeakPtr<UserMediaPermissionRequestManager>, private WebCore::MediaCanStartListener {
> public:
>     explicit UserMediaPermissionRequestManager(WebPage&);
>     ~UserMediaPermissionRequestManager();
>@@ -59,7 +56,7 @@ public:
>     WebCore::UserMediaClient::DeviceChangeObserverToken addDeviceChangeObserver(WTF::Function<void()>&&);
>     void removeDeviceChangeObserver(WebCore::UserMediaClient::DeviceChangeObserverToken);
> 
>-    void captureDevicesChanged(DeviceAccessState);
>+    void captureDevicesChanged();
> 
> private:
>     void sendUserMediaRequest(WebCore::UserMediaRequest&);
>@@ -67,9 +64,6 @@ private:
>     // WebCore::MediaCanStartListener
>     void mediaCanStart(WebCore::Document&) final;
> 
>-    // WebCore::ActivityStateChangeObserver
>-    void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> oldActivityState, OptionSet<WebCore::ActivityState::Flag> newActivityState) final;
>-
>     void removeMediaRequestFromMaps(WebCore::UserMediaRequest&);
> 
>     WebPage& m_page;
>@@ -84,25 +78,13 @@ private:
>     HashMap<String, RefPtr<SandboxExtension>> m_userMediaDeviceSandboxExtensions;
> 
>     HashMap<WebCore::UserMediaClient::DeviceChangeObserverToken, WTF::Function<void()>> m_deviceChangeObserverMap;
>-    DeviceAccessState m_accessStateWhenDevicesChanged { DeviceAccessState::NoAccess };
>     bool m_monitoringDeviceChange { false };
>-    bool m_pendingDeviceChangeEvent { false };
>-    bool m_monitoringActivityStateChange { false };
> };
> 
> } // namespace WebKit
> 
> namespace WTF {
> 
>-template<> struct EnumTraits<WebKit::DeviceAccessState> {
>-    using values = EnumValues<
>-        WebKit::DeviceAccessState,
>-        WebKit::DeviceAccessState::NoAccess,
>-        WebKit::DeviceAccessState::SessionAccess,
>-        WebKit::DeviceAccessState::PersistentAccess
>-    >;
>-};
>-
> } // namespace WTF
> 
> #endif // ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>index 3e0c914ef01c5f3c0a571d0cfd945a1c56f32260..c5542b2a3f7e250b33e95177fc2757f364ccfc90 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>@@ -3978,9 +3978,9 @@ void WebPage::didCompleteMediaDeviceEnumeration(uint64_t userMediaID, const Vect
>     m_userMediaPermissionRequestManager->didCompleteMediaDeviceEnumeration(userMediaID, devices, WTFMove(deviceIdentifierHashSalt), originHasPersistentAccess);
> }
> 
>-void WebPage::captureDevicesChanged(DeviceAccessState accessState)
>+void WebPage::captureDevicesChanged()
> {
>-    m_userMediaPermissionRequestManager->captureDevicesChanged(accessState);
>+    m_userMediaPermissionRequestManager->captureDevicesChanged();
> }
> 
> #if ENABLE(SANDBOX_EXTENSIONS)
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.h b/Source/WebKit/WebProcess/WebPage/WebPage.h
>index c880029c2483b0645808d83194368eb2b70a039d..83892e5b5d644c6a1bd0981db4adb5c7419baf68 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.h
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.h
>@@ -234,7 +234,6 @@ class WebUserContentController;
> class WebWheelEvent;
> class RemoteLayerTreeTransaction;
> 
>-enum class DeviceAccessState : uint8_t;
> enum FindOptions : uint16_t;
> enum class DragControllerAction : uint8_t;
> 
>@@ -578,7 +577,7 @@ public:
> #if ENABLE(MEDIA_STREAM)
>     UserMediaPermissionRequestManager& userMediaPermissionRequestManager() { return *m_userMediaPermissionRequestManager; }
>     void prepareToSendUserMediaPermissionRequest();
>-    void captureDevicesChanged(DeviceAccessState);
>+    void captureDevicesChanged();
> #endif
> 
>     void elementDidFocus(WebCore::Node*);
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.messages.in b/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>index 520abe7708743e1d1e6fa7f09e58f144923e429c..6f917bc8b2ce67686358eb9f2d5ca705ba62b166 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>@@ -340,7 +340,7 @@ messages -> WebPage LegacyReceiver {
>     UserMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice audioDevice, WebCore::CaptureDevice videoDevice, String mediaDeviceIdentifierHashSalt)
>     UserMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint)
>     DidCompleteMediaDeviceEnumeration(uint64_t userMediaID, Vector<WebCore::CaptureDevice> devices, String mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
>-    CaptureDevicesChanged(enum:uint8_t WebKit::DeviceAccessState accessState)
>+    CaptureDevicesChanged()
> #if ENABLE(SANDBOX_EXTENSIONS)
>     GrantUserMediaDeviceSandboxExtensions(WebKit::MediaDeviceSandboxExtensions sandboxExtensions)
>     RevokeUserMediaDeviceSandboxExtensions(Vector<String> sandboxExtensionIDs)
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 4440b4e5643b31eb613a5f94205708d9595905d9..c7e2389ed9d98fb484cc1e1e982f3c91d1703879 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,16 @@
>+2018-12-07  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [MediaStream] 'devicechange' event should not fire in frames that can't access capture devices
>+        https://bugs.webkit.org/show_bug.cgi?id=192511
>+        <rdar://problem/46562063>
>+
>+        Reviewed by Youenn Fablet.
>+
>+        * fast/mediastream/device-change-event.html: Fix bogus title.
>+        * http/tests/media/media-stream/device-change-event-in-iframe-expected.txt: Added.
>+        * http/tests/media/media-stream/device-change-event-in-iframe.html: Added.
>+        * http/tests/media/media-stream/resources/device-change-iframe.html: Added.
>+
> 2018-12-07  Truitt Savell  <tsavell@apple.com>
> 
>         [ MacOS Debug ] Layout Test webgl/2.0.0/conformance2/textures/misc/tex-unpack-params.html is flaky timeout
>diff --git a/LayoutTests/fast/mediastream/device-change-event.html b/LayoutTests/fast/mediastream/device-change-event.html
>index 41124c9044180ec64c70e27326565e727d8c668b..9b8316a4996afbd74afbbfd74b264a008b328f11 100644
>--- a/LayoutTests/fast/mediastream/device-change-event.html
>+++ b/LayoutTests/fast/mediastream/device-change-event.html
>@@ -2,7 +2,7 @@
> <html>
> <head>
>     <meta charset="utf-8">
>-    <title>Testing local audio capture playback causes "playing" event to fire</title>
>+    <title>'devicechange' event tests</title>
>     <script src="../../resources/testharness.js"></script>
>     <script src="../../resources/testharnessreport.js"></script>
>     <script>
>diff --git a/LayoutTests/http/tests/media/media-stream/device-change-event-in-iframe-expected.txt b/LayoutTests/http/tests/media/media-stream/device-change-event-in-iframe-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..383c6c37bdb9b93707032c7115365e1bb18ef33d
>--- /dev/null
>+++ b/LayoutTests/http/tests/media/media-stream/device-change-event-in-iframe-expected.txt
>@@ -0,0 +1,8 @@
>+     
>+<iframe id=camera> got a 'devicechange' event
>+<iframe id=main> got a 'devicechange' event
>+<iframe id=microphone> got a 'devicechange' event
>+<iframe id=same-origin> got a 'devicechange' event
>+
>+PASS: 'devicechange' only fired on frames with access to devices
>+
>diff --git a/LayoutTests/http/tests/media/media-stream/device-change-event-in-iframe.html b/LayoutTests/http/tests/media/media-stream/device-change-event-in-iframe.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..9e3a8a5fbc627bc96516fdc63b9fb5f8128d98dd
>--- /dev/null
>+++ b/LayoutTests/http/tests/media/media-stream/device-change-event-in-iframe.html
>@@ -0,0 +1,63 @@
>+<!doctype html>
>+<html>
>+<script src="../../../../resources/js-test-pre.js"></script>
>+<body onload="start()">
>+    <iframe id="none"" src="http://localhost:8000/media/media-stream/resources/device-change-iframe.html?1"></iframe>
>+    <iframe id="camera" allow="camera" src="http://localhost:8000/media/media-stream/resources/device-change-iframe.html?2"></iframe>
>+    <iframe id="microphone" allow="camera" src="http://localhost:8000/media/media-stream/resources/device-change-iframe.html?2"></iframe>
>+    <iframe id="same-origin" src="http://127.0.0.1:8000/media/media-stream/resources/device-change-iframe.html?3"></iframe>
>+
>+    <script>
>+
>+        if (window.testRunner) {
>+            testRunner.dumpAsText();
>+            testRunner.waitUntilDone();
>+            testRunner.setUserMediaPermission(true);
>+        }
>+
>+        let count = new Set();
>+        let success = true;
>+        let results = [];
>+        function countEvent(id)
>+        {
>+            results.push(`&LT;iframe id=${id}> got a 'devicechange' event`);
>+            if (id == "none") {
>+                result.innerHTML += `FAIL: &LT;iframe id=${id}> got 'devicechange' event<br>`;
>+                success = false;
>+            } else
>+                count.add(id);
>+
>+            if (count.size == 4) {
>+                setTimeout(() => {
>+                    result.innerHTML = results.sort().join('<br>');
>+                    if (success)
>+                        result.innerHTML += "<br><br>PASS: 'devicechange' only fired on frames with access to devices<br>";
>+                    if (window.testRunner) {
>+                        testRunner.notifyDone();
>+                        testRunner.resetMockMediaDevices();
>+                    }
>+                }, 500);
>+            }
>+        }
>+        
>+        async function start()
>+        {
>+            await window.navigator.mediaDevices.getUserMedia({audio:true});
>+            if (window.testRunner)
>+                testRunner.addMockMicrophoneDevice("id4", "microphone 3");
>+        }
>+
>+        window.onmessage = (event) => { countEvent(event.data); };
>+        navigator.mediaDevices.ondevicechange = (event) => { countEvent('main'); };
>+
>+        Array.from(document.getElementsByTagName('iframe')).forEach(element => {
>+            element.onload = (evt) => { 
>+                evt.target.contentWindow.postMessage(evt.target.id, '*'); 
>+            }
>+        });
>+
>+    </script>
>+
>+    <div id="result"></div>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/media/media-stream/resources/device-change-iframe.html b/LayoutTests/http/tests/media/media-stream/resources/device-change-iframe.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..66b153cffb5edc05cc30c1d111b8db668f1e4dbe
>--- /dev/null
>+++ b/LayoutTests/http/tests/media/media-stream/resources/device-change-iframe.html
>@@ -0,0 +1,12 @@
>+<script>
>+    let myID;
>+    navigator.mediaDevices.ondevicechange = (event) => {
>+        parent.postMessage(myID, '*');
>+        result.innerHTML = `${myID} got 'devicechange' event`;
>+    };
>+    window.addEventListener("message", (event) => { myID = event.data; });
>+</script>
>+
>+<div id='result'></div>
>+
>+

Actions: View | Formatted Diff | Diff

Attachments on bug 192511: 356832 | 356836 | 356854