Unreviewed, rolling out r251993.
authortsavell@apple.com <tsavell@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 4 Nov 2019 20:58:52 +0000 (20:58 +0000)
committertsavell@apple.com <tsavell@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 4 Nov 2019 20:58:52 +0000 (20:58 +0000)
Broke platform/mac/media/encrypted-media/fps-
generateRequest.html on Mojave+

Reverted changeset:

"MediaKeySession / WebKitMediaKeySession should not prevent
entering the back/forward cache"
https://bugs.webkit.org/show_bug.cgi?id=203089
https://trac.webkit.org/changeset/251993

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@252008 268f45cc-cd09-0410-ab3c-d52691b4dbfc

LayoutTests/ChangeLog
LayoutTests/http/tests/navigation/page-cache-mediakeysession-expected.txt [deleted file]
LayoutTests/http/tests/navigation/page-cache-mediakeysession.html [deleted file]
Source/WebCore/ChangeLog
Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
Source/WebCore/Modules/encryptedmedia/legacy/WebKitMediaKeySession.cpp
Source/WebCore/Modules/encryptedmedia/legacy/WebKitMediaKeySession.h

index c88802e..431844c 100644 (file)
@@ -1,3 +1,17 @@
+2019-11-04  Truitt Savell  <tsavell@apple.com>
+
+        Unreviewed, rolling out r251993.
+
+        Broke platform/mac/media/encrypted-media/fps-
+        generateRequest.html on Mojave+
+
+        Reverted changeset:
+
+        "MediaKeySession / WebKitMediaKeySession should not prevent
+        entering the back/forward cache"
+        https://bugs.webkit.org/show_bug.cgi?id=203089
+        https://trac.webkit.org/changeset/251993
+
 2019-11-04  Chris Dumez  <cdumez@apple.com>
 
         MediaRecorder should not prevent entering the back/forward cache
diff --git a/LayoutTests/http/tests/navigation/page-cache-mediakeysession-expected.txt b/LayoutTests/http/tests/navigation/page-cache-mediakeysession-expected.txt
deleted file mode 100644 (file)
index 548b693..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-Tests that a page with a MediaKeySession goes into the back/forward cache.
-
-On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
-
-
-PASS !!session is true
-pageshow - not from cache
-pagehide - entering cache
-pageshow - from cache
-PASS Page was restored from back/forward cache
-PASS successfullyParsed is true
-
-TEST COMPLETE
-
diff --git a/LayoutTests/http/tests/navigation/page-cache-mediakeysession.html b/LayoutTests/http/tests/navigation/page-cache-mediakeysession.html
deleted file mode 100644 (file)
index 1c77ed9..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-<!-- webkit-test-runner [ enableBackForwardCache=true ] -->
-<!DOCTYPE html>
-<html>
-<head>
-<script src="/js-test-resources/js-test.js"></script>
-</head>
-<body>
-<script>
-description('Tests that a page with a MediaKeySession goes into the back/forward cache.');
-jsTestIsAsync = true;
-
-window.addEventListener("pageshow", function(event) {
-    debug("pageshow - " + (event.persisted ? "" : "not ") + "from cache");
-    if (event.persisted) {
-        testPassed("Page was restored from back/forward cache");
-        finishJSTest();
-    }
-});
-
-window.addEventListener("pagehide", function(event) {
-    debug("pagehide - " + (event.persisted ? "" : "not ") + "entering cache");
-    if (!event.persisted) {
-        testFailed("Page failed to enter the back/forward cache");
-        finishJSTest();
-    }
-});
-
-onload = () => {
-    mediaKeys = new WebKitMediaKeys('org.w3c.clearkey');
-    session = mediaKeys.createSession('application/x-mpegurl', new Uint8Array(1));
-    shouldBeTrue("!!session");
-    setTimeout(() => {
-        testLink.click();
-    }, 0);
-}
-</script>
-<a id="testLink" href="resources/page-cache-helper.html" style="display: none">Link</a>
-</body>
-</html>
index 392bd64..be454cd 100644 (file)
@@ -1,3 +1,17 @@
+2019-11-04  Truitt Savell  <tsavell@apple.com>
+
+        Unreviewed, rolling out r251993.
+
+        Broke platform/mac/media/encrypted-media/fps-
+        generateRequest.html on Mojave+
+
+        Reverted changeset:
+
+        "MediaKeySession / WebKitMediaKeySession should not prevent
+        entering the back/forward cache"
+        https://bugs.webkit.org/show_bug.cgi?id=203089
+        https://trac.webkit.org/changeset/251993
+
 2019-11-04  Chris Dumez  <cdumez@apple.com>
 
         Port WebAnimation to the HTML5 event loop
index 4728276..88c8aea 100644 (file)
@@ -31,7 +31,6 @@
 
 #if ENABLE(ENCRYPTED_MEDIA)
 
-#include "AbstractEventLoop.h"
 #include "CDM.h"
 #include "CDMInstance.h"
 #include "DOMPromiseProxy.h"
@@ -71,6 +70,7 @@ MediaKeySession::MediaKeySession(ScriptExecutionContext& context, WeakPtr<MediaK
     , m_sessionType(sessionType)
     , m_implementation(WTFMove(implementation))
     , m_instanceSession(WTFMove(instanceSession))
+    , m_eventQueue(MainThreadGenericEventQueue::create(*this))
 {
     // https://w3c.github.io/encrypted-media/#dom-mediakeys-createsession
     // W3C Editor's Draft 09 November 2016
@@ -157,7 +157,7 @@ void MediaKeySession::generateRequest(const AtomString& initDataType, const Buff
     // 8. Let session type be this object's session type.
     // 9. Let promise be a new promise.
     // 10. Run the following steps in parallel:
-    enqueueTask([this, initData = SharedBuffer::create(initData.data(), initData.length()), initDataType, promise = WTFMove(promise)] () mutable {
+    m_taskQueue.enqueueTask([this, initData = SharedBuffer::create(initData.data(), initData.length()), initDataType, promise = WTFMove(promise)] () mutable {
         // 10.1. If the init data is not valid for initDataType, reject promise with a newly created TypeError.
         // 10.2. Let sanitized init data be a validated and sanitized version of init data.
         RefPtr<SharedBuffer> sanitizedInitData = m_implementation->sanitizeInitData(initDataType, initData);
@@ -226,7 +226,7 @@ void MediaKeySession::generateRequest(const AtomString& initDataType, const Buff
             }
 
             // 10.10. Queue a task to run the following steps:
-            enqueueTask([this, promise = WTFMove(promise), message = WTFMove(message), messageType, sessionId, succeeded] () mutable {
+            m_taskQueue.enqueueTask([this, promise = WTFMove(promise), message = WTFMove(message), messageType, sessionId, succeeded] () mutable {
                 // 10.10.1. If any of the preceding steps failed, reject promise with a new DOMException whose name is the appropriate error name.
                 if (succeeded == CDMInstanceSession::SuccessValue::Failed) {
                     promise->reject(NotSupportedError);
@@ -277,7 +277,7 @@ void MediaKeySession::load(const String& sessionId, Ref<DeferredPromise>&& promi
 
     // 7. Let promise be a new promise.
     // 8. Run the following steps in parallel:
-    enqueueTask([this, sessionId, promise = WTFMove(promise)] () mutable {
+    m_taskQueue.enqueueTask([this, sessionId, promise = WTFMove(promise)] () mutable {
         // 8.1. Let sanitized session ID be a validated and/or sanitized version of sessionId.
         // 8.2. If the preceding step failed, or if sanitized session ID is empty, reject promise with a newly created TypeError.
         Optional<String> sanitizedSessionId = m_implementation->sanitizeSessionId(sessionId);
@@ -329,7 +329,7 @@ void MediaKeySession::load(const String& sessionId, Ref<DeferredPromise>&& promi
             }
 
             // 8.9. Queue a task to run the following steps:
-            enqueueTask([this, knownKeys = WTFMove(knownKeys), expiration = WTFMove(expiration), message = WTFMove(message), sanitizedSessionId, succeeded, promise = WTFMove(promise)] () mutable {
+            m_taskQueue.enqueueTask([this, knownKeys = WTFMove(knownKeys), expiration = WTFMove(expiration), message = WTFMove(message), sanitizedSessionId, succeeded, promise = WTFMove(promise)] () mutable {
                 // 8.9.1. If any of the preceding steps failed, reject promise with a the appropriate error name.
                 if (succeeded == CDMInstanceSession::SuccessValue::Failed) {
                     promise->reject(NotSupportedError);
@@ -386,7 +386,7 @@ void MediaKeySession::update(const BufferSource& response, Ref<DeferredPromise>&
     // 4. Let response copy be a copy of the contents of the response parameter.
     // 5. Let promise be a new promise.
     // 6. Run the following steps in parallel:
-    enqueueTask([this, response = SharedBuffer::create(response.data(), response.length()), promise = WTFMove(promise)] () mutable {
+    m_taskQueue.enqueueTask([this, response = SharedBuffer::create(response.data(), response.length()), promise = WTFMove(promise)] () mutable {
         // 6.1. Let sanitized response be a validated and/or sanitized version of response copy.
         RefPtr<SharedBuffer> sanitizedResponse = m_implementation->sanitizeResponse(response);
 
@@ -437,7 +437,7 @@ void MediaKeySession::update(const BufferSource& response, Ref<DeferredPromise>&
             //   6.7.3.1. Let message be that message.
             //   6.7.3.2. Let message type be the appropriate MediaKeyMessageType for the message.
             // 6.8. Queue a task to run the following steps:
-            enqueueTask([this, sessionWasClosed, changedKeys = WTFMove(changedKeys), changedExpiration = WTFMove(changedExpiration), message = WTFMove(message), promise = WTFMove(promise)] () mutable {
+            m_taskQueue.enqueueTask([this, sessionWasClosed, changedKeys = WTFMove(changedKeys), changedExpiration = WTFMove(changedExpiration), message = WTFMove(message), promise = WTFMove(promise)] () mutable {
                 LOG(EME, "EME - updating CDM license succeeded for session %s, sending a message to the license server", m_sessionId.utf8().data());
                 // 6.8.1.
                 if (sessionWasClosed) {
@@ -514,7 +514,7 @@ void MediaKeySession::close(Ref<DeferredPromise>&& promise)
 
     // 4. Let promise be a new promise.
     // 5. Run the following steps in parallel:
-    enqueueTask([this, promise = WTFMove(promise)] () mutable {
+    m_taskQueue.enqueueTask([this, promise = WTFMove(promise)] () mutable {
         // 5.1. Let cdm be the CDM instance represented by session's cdm instance value.
         // 5.2. Use cdm to close the key session associated with session.
         LOG(EME, "EME - closing CDM session %s", m_sessionId.utf8().data());
@@ -523,7 +523,7 @@ void MediaKeySession::close(Ref<DeferredPromise>&& promise)
                 return;
 
             // 5.3. Queue a task to run the following steps:
-            enqueueTask([this, promise = WTFMove(promise)] () mutable {
+            m_taskQueue.enqueueTask([this, promise = WTFMove(promise)] () mutable {
                 // 5.3.1. Run the Session Closed algorithm on the session.
                 sessionClosed();
 
@@ -552,7 +552,7 @@ void MediaKeySession::remove(Ref<DeferredPromise>&& promise)
 
     // 3. Let promise be a new promise.
     // 4. Run the following steps in parallel:
-    enqueueTask([this, promise = WTFMove(promise)] () mutable {
+    m_taskQueue.enqueueTask([this, promise = WTFMove(promise)] () mutable {
         // 4.1. Let cdm be the CDM instance represented by this object's cdm instance value.
         // 4.2. Let message be null.
         // 4.3. Let message type be null.
@@ -577,7 +577,7 @@ void MediaKeySession::remove(Ref<DeferredPromise>&& promise)
             // NOTE: Step 4.4.1. should be implemented in CDMInstance.
 
             // 4.5. Queue a task to run the following steps:
-            enqueueTask([this, keys = WTFMove(keys), message = WTFMove(message), succeeded, promise = WTFMove(promise)] () mutable {
+            m_taskQueue.enqueueTask([this, keys = WTFMove(keys), message = WTFMove(message), succeeded, promise = WTFMove(promise)] () mutable {
                 // 4.5.1. Run the Update Key Statuses algorithm on the session, providing all key ID(s) in the session along with the "released" MediaKeyStatus value for each.
                 updateKeyStatuses(WTFMove(keys));
 
@@ -616,7 +616,7 @@ void MediaKeySession::enqueueMessage(MediaKeyMessageType messageType, const Shar
     //    interface with its type attribute set to message and its isTrusted attribute initialized to true, and dispatch it at the
     //    session.
     auto messageEvent = MediaKeyMessageEvent::create(eventNames().messageEvent, {messageType, message.tryCreateArrayBuffer()}, Event::IsTrusted::Yes);
-    enqueueEvent(WTFMove(messageEvent));
+    m_eventQueue->enqueueEvent(WTFMove(messageEvent));
 }
 
 void MediaKeySession::updateKeyStatuses(CDMInstanceSession::KeyStatusVector&& inputStatuses)
@@ -661,10 +661,10 @@ void MediaKeySession::updateKeyStatuses(CDMInstanceSession::KeyStatusVector&& in
         m_statuses.uncheckedAppend({ WTFMove(status.first), toMediaKeyStatus(status.second) });
 
     // 5. Queue a task to fire a simple event named keystatuseschange at the session.
-    enqueueEvent(Event::create(eventNames().keystatuseschangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
+    m_eventQueue->enqueueEvent(Event::create(eventNames().keystatuseschangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
 
     // 6. Queue a task to run the Attempt to Resume Playback If Necessary algorithm on each of the media element(s) whose mediaKeys attribute is the MediaKeys object that created the session.
-    enqueueTask(
+    m_taskQueue.enqueueTask(
         [this] () mutable {
             if (m_keys)
                 m_keys->attemptToResumePlaybackOnClients();
@@ -733,35 +733,26 @@ String MediaKeySession::mediaKeysStorageDirectory() const
 
 bool MediaKeySession::hasPendingActivity() const
 {
-    // A MediaKeySession object SHALL NOT be destroyed and SHALL continue to receive events if it is not closed and the MediaKeys object that created it remains accessible.
-    return (!m_closed && m_keys) || ActiveDOMObject::hasPendingActivity();
+    notImplemented();
+    return false;
 }
 
 const char* MediaKeySession::activeDOMObjectName() const
 {
+    notImplemented();
     return "MediaKeySession";
 }
 
-void MediaKeySession::enqueueTask(Function<void()>&& task)
+// FIXME: This should never prevent entering the back/forward cache.
+bool MediaKeySession::shouldPreventEnteringBackForwardCache_DEPRECATED() const
 {
-    auto* context = scriptExecutionContext();
-    if (!context)
-        return;
-
-    context->eventLoop().queueTask(TaskSource::Networking, *context, [pendingActivity = makePendingActivity(*this), task = WTFMove(task)] {
-        task();
-    });
+    notImplemented();
+    return true;
 }
 
-void MediaKeySession::enqueueEvent(Ref<Event>&& event)
+void MediaKeySession::stop()
 {
-    auto* context = scriptExecutionContext();
-    if (!context)
-        return;
-
-    context->eventLoop().queueTask(TaskSource::Networking, *context, [this, pendingActivity = makePendingActivity(*this), event = WTFMove(event)]() mutable {
-        dispatchEvent(WTFMove(event));
-    });
+    notImplemented();
 }
 
 } // namespace WebCore
index e4229f8..aeb5c22 100644 (file)
 #include "ActiveDOMObject.h"
 #include "CDMInstanceSession.h"
 #include "EventTarget.h"
+#include "GenericEventQueue.h"
+#include "GenericTaskQueue.h"
 #include "IDLTypes.h"
 #include "MediaKeyMessageType.h"
 #include "MediaKeySessionType.h"
 #include "MediaKeyStatus.h"
 #include <wtf/RefCounted.h>
-#include <wtf/UniqueRef.h>
 #include <wtf/Vector.h>
 #include <wtf/WeakPtr.h>
 #include <wtf/text/WTFString.h>
@@ -90,9 +91,6 @@ private:
     void sessionClosed();
     String mediaKeysStorageDirectory() const;
 
-    void enqueueTask(Function<void()>&&);
-    void enqueueEvent(Ref<Event>&&);
-
     // CDMInstanceSessionClient
     void updateKeyStatuses(CDMInstanceSessionClient::KeyStatusVector&&) override;
     void sendMessage(CDMMessageType, Ref<SharedBuffer>&& message) final;
@@ -106,6 +104,8 @@ private:
 
     // ActiveDOMObject
     const char* activeDOMObjectName() const override;
+    bool shouldPreventEnteringBackForwardCache_DEPRECATED() const override;
+    void stop() override;
 
     WeakPtr<MediaKeys> m_keys;
     String m_sessionId;
@@ -119,6 +119,8 @@ private:
     MediaKeySessionType m_sessionType;
     Ref<CDM> m_implementation;
     Ref<CDMInstanceSession> m_instanceSession;
+    UniqueRef<MainThreadGenericEventQueue> m_eventQueue;
+    GenericTaskQueue<Timer> m_taskQueue;
     Vector<Ref<SharedBuffer>> m_recordOfKeyUsage;
     double m_firstDecryptTime { 0 };
     double m_latestDecryptTime { 0 };
index 47931e1..8ddef25 100644 (file)
@@ -28,7 +28,6 @@
 
 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
 
-#include "AbstractEventLoop.h"
 #include "Document.h"
 #include "EventNames.h"
 #include "Page.h"
@@ -55,6 +54,7 @@ WebKitMediaKeySession::WebKitMediaKeySession(ScriptExecutionContext& context, We
     : ActiveDOMObject(&context)
     , m_keys(&keys)
     , m_keySystem(keySystem)
+    , m_asyncEventQueue(MainThreadGenericEventQueue::create(*this))
     , m_session(keys.cdm().createSession(*this))
     , m_keyRequestTimer(*this, &WebKitMediaKeySession::keyRequestTimerFired)
     , m_addKeyTimer(*this, &WebKitMediaKeySession::addKeyTimerFired)
@@ -67,6 +67,8 @@ WebKitMediaKeySession::~WebKitMediaKeySession()
 {
     if (m_session)
         m_session->setClient(nullptr);
+
+    m_asyncEventQueue->cancelAllEvents();
 }
 
 void WebKitMediaKeySession::close()
@@ -181,7 +183,7 @@ void WebKitMediaKeySession::addKeyTimerFired()
         if (didStoreKey) {
             auto keyaddedEvent = Event::create(eventNames().webkitkeyaddedEvent, Event::CanBubble::No, Event::IsCancelable::No);
             keyaddedEvent->setTarget(this);
-            enqueueEvent(WTFMove(keyaddedEvent));
+            m_asyncEventQueue->enqueueEvent(WTFMove(keyaddedEvent));
 
             ASSERT(m_keys);
             m_keys->keyAdded();
@@ -205,7 +207,7 @@ void WebKitMediaKeySession::sendMessage(Uint8Array* message, String destinationU
 {
     auto event = WebKitMediaKeyMessageEvent::create(eventNames().webkitkeymessageEvent, message, destinationURL);
     event->setTarget(this);
-    enqueueEvent(WTFMove(event));
+    m_asyncEventQueue->enqueueEvent(WTFMove(event));
 }
 
 void WebKitMediaKeySession::sendError(MediaKeyErrorCode errorCode, uint32_t systemCode)
@@ -214,7 +216,7 @@ void WebKitMediaKeySession::sendError(MediaKeyErrorCode errorCode, uint32_t syst
 
     auto keyerrorEvent = Event::create(eventNames().webkitkeyerrorEvent, Event::CanBubble::No, Event::IsCancelable::No);
     keyerrorEvent->setTarget(this);
-    enqueueEvent(WTFMove(keyerrorEvent));
+    m_asyncEventQueue->enqueueEvent(WTFMove(keyerrorEvent));
 }
 
 String WebKitMediaKeySession::mediaKeysStorageDirectory() const
@@ -236,7 +238,7 @@ String WebKitMediaKeySession::mediaKeysStorageDirectory() const
 
 bool WebKitMediaKeySession::hasPendingActivity() const
 {
-    return (m_keys && m_session) || ActiveDOMObject::hasPendingActivity();
+    return (m_keys && m_session) || m_asyncEventQueue->hasPendingEvents();
 }
 
 void WebKitMediaKeySession::stop()
@@ -249,15 +251,10 @@ const char* WebKitMediaKeySession::activeDOMObjectName() const
     return "WebKitMediaKeySession";
 }
 
-void WebKitMediaKeySession::enqueueEvent(Ref<Event>&& event)
+bool WebKitMediaKeySession::shouldPreventEnteringBackForwardCache_DEPRECATED() const
 {
-    auto* context = scriptExecutionContext();
-    if (!context)
-        return;
-
-    context->eventLoop().queueTask(TaskSource::Networking, *context, [this, pendingActivity = makePendingActivity(*this), event = WTFMove(event)]() mutable {
-        dispatchEvent(WTFMove(event));
-    });
+    // FIXME: This should never prevent entering the back/forward cache.
+    return true;
 }
 
 }
index 3d4e627..cfdeb24 100644 (file)
@@ -30,6 +30,7 @@
 #include "ActiveDOMObject.h"
 #include "EventTarget.h"
 #include "ExceptionOr.h"
+#include "GenericEventQueue.h"
 #include "LegacyCDMSession.h"
 #include "Timer.h"
 #include <JavaScriptCore/Uint8Array.h>
@@ -40,7 +41,7 @@ namespace WebCore {
 class WebKitMediaKeyError;
 class WebKitMediaKeys;
 
-class WebKitMediaKeySession final : public RefCounted<WebKitMediaKeySession>, public EventTargetWithInlineData, public ActiveDOMObject, private LegacyCDMSessionClient {
+class WebKitMediaKeySession final : public RefCounted<WebKitMediaKeySession>, public EventTargetWithInlineData, private ActiveDOMObject, private LegacyCDMSessionClient {
     WTF_MAKE_ISO_ALLOCATED(WebKitMediaKeySession);
 public:
     static Ref<WebKitMediaKeySession> create(ScriptExecutionContext&, WebKitMediaKeys&, const String& keySystem);
@@ -73,12 +74,11 @@ private:
     void sendError(MediaKeyErrorCode, uint32_t systemCode) final;
     String mediaKeysStorageDirectory() const final;
 
-    void enqueueEvent(Ref<Event>&&);
-
     void refEventTarget() final { ref(); }
     void derefEventTarget() final { deref(); }
 
     void stop() final;
+    bool shouldPreventEnteringBackForwardCache_DEPRECATED() const final;
     const char* activeDOMObjectName() const final;
 
     EventTargetInterface eventTargetInterface() const final { return WebKitMediaKeySessionEventTargetInterfaceType; }
@@ -88,6 +88,7 @@ private:
     String m_keySystem;
     String m_sessionId;
     RefPtr<WebKitMediaKeyError> m_error;
+    UniqueRef<MainThreadGenericEventQueue> m_asyncEventQueue;
     std::unique_ptr<LegacyCDMSession> m_session;
 
     struct PendingKeyRequest {