Changeset 244823 in webkit

Timestamp:

May 1, 2019 8:56:34 AM (5 years ago)

Author:

eric.carlson@apple.com

Message:

XMLHttpRequest should propagate user gestures for media playback
​https://bugs.webkit.org/show_bug.cgi?id=197428
<rdar://problem/46677392>

Reviewed by Jer Noble.

Source/WebCore:

A user gesture the would allow media state change in effect when XMLHttpRequest.send is
called should be active when the event handlers fire after the transaction completes successfully.

Test: http/tests/media/user-gesture-preserved-across-xmlhttprequest.html

• dom/UserGestureIndicator.cpp:

(WebCore::UserGestureIndicator::UserGestureIndicator): Add a 'scope' parameter to potentially
limit the scope of the gesture to just media.
(WebCore::UserGestureIndicator::~UserGestureIndicator): Clear the scope.

• dom/UserGestureIndicator.h:

(WebCore::UserGestureToken::processingUserGesture const):
(WebCore::UserGestureToken::setScope):
(WebCore::UserGestureToken::resetScope):
(WebCore::UserGestureToken::hasExpired const):

• page/DOMTimer.cpp:

(WebCore::DOMTimerFireState::DOMTimerFireState): Don't need to store the nested timer interval,
UserGestureIndicator knows when it started.
(WebCore::DOMTimer::DOMTimer): Ditto.
(WebCore::DOMTimer::fired): Ditto.
(WebCore::DOMTimerFireState::nestedTimerInterval const): Deleted.
(WebCore::shouldForwardUserGesture): Deleted.
(WebCore::userGestureTokenToForward): Deleted.
(WebCore::currentNestedTimerInterval): Deleted.

• page/DOMTimer.h:

• testing/Internals.cpp:

(WebCore::Internals::setXHRMaximumIntervalForUserGestureForwarding): Override the maximum
user gesture interval for testing.

• testing/Internals.h:
• testing/Internals.idl:

• xml/XMLHttpRequest.cpp:

(WebCore::XMLHttpRequest::XMLHttpRequest):
(WebCore::XMLHttpRequest::send): Stash the user gesture token.
(WebCore::XMLHttpRequest::dispatchEvent): Clear user gesture token if it has expired. If still
valid, activate it.

• xml/XMLHttpRequest.h:

LayoutTests:

• fast/events/popup-blocking-timers5-expected.txt:
• fast/events/popup-blocking-timers5.html: Decrease the timer interval from 1000 to 900

because the user gesture is invalidated based on wall clock time.

• fast/events/popup-blocking-timers6-expected.txt:
• fast/events/popup-blocking-timers6.html: Increase the timer interval from 1001 to 1100

because the user gesture is invalidated based on wall clock time.

• http/tests/media/user-gesture-preserved-across-xmlhttprequest-expected.txt: Added.
• http/tests/media/user-gesture-preserved-across-xmlhttprequest.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/events/popup-blocking-timers5-expected.txt (modified) (1 diff)
• LayoutTests/fast/events/popup-blocking-timers5.html (modified) (1 diff)
• LayoutTests/fast/events/popup-blocking-timers6-expected.txt (modified) (1 diff)
• LayoutTests/fast/events/popup-blocking-timers6.html (modified) (1 diff)
• LayoutTests/http/tests/media/user-gesture-preserved-across-xmlhttprequest-expected.txt (added)
• LayoutTests/http/tests/media/user-gesture-preserved-across-xmlhttprequest.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/dom/UserGestureIndicator.cpp (modified) (3 diffs)
• Source/WebCore/dom/UserGestureIndicator.h (modified) (5 diffs)
• Source/WebCore/page/DOMTimer.cpp (modified) (6 diffs)
• Source/WebCore/page/DOMTimer.h (modified) (1 diff)
• Source/WebCore/testing/Internals.cpp (modified) (1 diff)
• Source/WebCore/testing/Internals.h (modified) (1 diff)
• Source/WebCore/testing/Internals.idl (modified) (1 diff)
• Source/WebCore/xml/XMLHttpRequest.cpp (modified) (5 diffs)
• Source/WebCore/xml/XMLHttpRequest.h (modified) (4 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2019-05-01  Eric Carlson  <eric.carlson@apple.com>
+
+        XMLHttpRequest should propagate user gestures for media playback
+        https://bugs.webkit.org/show_bug.cgi?id=197428
+        <rdar://problem/46677392>
+
+        Reviewed by Jer Noble.
+
+        * fast/events/popup-blocking-timers5-expected.txt:
+        * fast/events/popup-blocking-timers5.html: Decrease the timer interval from 1000 to 900
+        because the user gesture is invalidated based on wall clock time.
+        * fast/events/popup-blocking-timers6-expected.txt:
+        * fast/events/popup-blocking-timers6.html: Increase the timer interval from 1001 to 1100
+        because the user gesture is invalidated based on wall clock time.
+        * http/tests/media/user-gesture-preserved-across-xmlhttprequest-expected.txt: Added.
+        * http/tests/media/user-gesture-preserved-across-xmlhttprequest.html: Added.
+
 2019-04-29  Darin Adler  <darin@apple.com>
 

trunk/LayoutTests/fast/events/popup-blocking-timers5-expected.txt

@@ -1 +1 @@
 Click Here
-Test calling window.open() with a 1000 ms delay. A popup should be allowed.
+Test calling window.open() with a 900 ms delay. A popup should be allowed.
 PASS newWindow is non-null.
 

trunk/LayoutTests/fast/events/popup-blocking-timers5.html

@@ -16 +16 @@
                 newWindow = window.open("about:blank");
                 self.focus();
-                debug("Test calling window.open() with a 1000 ms delay. A popup should be allowed.")
+                debug("Test calling window.open() with a 900 ms delay. A popup should be allowed.")
                 shouldBeNonNull("newWindow");
                 if (window.testRunner)
                     testRunner.notifyDone();
-            }, 1000);
+            }, 900);
 
             if (window.eventSender)
-                eventSender.leapForward(1000);
+                eventSender.leapForward(900);
         }
         

trunk/LayoutTests/fast/events/popup-blocking-timers6-expected.txt

@@ -1 +1 @@
 Click Here
-Test calling window.open() with a 1001 ms delay. A popup should not be allowed.
+Test calling window.open() with a 1100 ms delay. A popup should not be allowed.
 PASS newWindow is null
 

trunk/LayoutTests/fast/events/popup-blocking-timers6.html

@@ -16 +16 @@
                 newWindow = window.open("about:blank");
                 self.focus();
-                debug("Test calling window.open() with a 1001 ms delay. A popup should not be allowed.")
+                debug("Test calling window.open() with a 1100 ms delay. A popup should not be allowed.")
                 shouldBeNull("newWindow");
 
                 if (window.testRunner)
                     testRunner.notifyDone();
-            }, 1001);
+            }, 1100);
             if (window.eventSender)
-                eventSender.leapForward(1001);
+                eventSender.leapForward(1100);
         }
         

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-05-01  Eric Carlson  <eric.carlson@apple.com>
+
+        XMLHttpRequest should propagate user gestures for media playback
+        https://bugs.webkit.org/show_bug.cgi?id=197428
+        <rdar://problem/46677392>
+
+        Reviewed by Jer Noble.
+
+        A user gesture the would allow media state change in effect when XMLHttpRequest.send is 
+        called should be active when the event handlers fire after the transaction completes successfully.
+
+        Test: http/tests/media/user-gesture-preserved-across-xmlhttprequest.html
+
+        * dom/UserGestureIndicator.cpp:
+        (WebCore::UserGestureIndicator::UserGestureIndicator): Add a 'scope' parameter to potentially
+        limit the scope of the gesture to just media.
+        (WebCore::UserGestureIndicator::~UserGestureIndicator): Clear the scope.
+        * dom/UserGestureIndicator.h:
+        (WebCore::UserGestureToken::processingUserGesture const):
+        (WebCore::UserGestureToken::setScope):
+        (WebCore::UserGestureToken::resetScope):
+        (WebCore::UserGestureToken::hasExpired const):
+
+        * page/DOMTimer.cpp:
+        (WebCore::DOMTimerFireState::DOMTimerFireState): Don't need to store the nested timer interval,
+        UserGestureIndicator knows when it started.
+        (WebCore::DOMTimer::DOMTimer): Ditto.
+        (WebCore::DOMTimer::fired): Ditto.
+        (WebCore::DOMTimerFireState::nestedTimerInterval const): Deleted.
+        (WebCore::shouldForwardUserGesture): Deleted.
+        (WebCore::userGestureTokenToForward): Deleted.
+        (WebCore::currentNestedTimerInterval): Deleted.
+        * page/DOMTimer.h:
+
+        * testing/Internals.cpp:
+        (WebCore::Internals::setXHRMaximumIntervalForUserGestureForwarding): Override the maximum
+        user gesture interval for testing.
+        * testing/Internals.h:
+        * testing/Internals.idl:
+
+        * xml/XMLHttpRequest.cpp:
+        (WebCore::XMLHttpRequest::XMLHttpRequest): 
+        (WebCore::XMLHttpRequest::send): Stash the user gesture token.
+        (WebCore::XMLHttpRequest::dispatchEvent): Clear user gesture token if it has expired. If still
+        valid, activate it.
+        * xml/XMLHttpRequest.h:
+
 2019-04-29  Darin Adler  <darin@apple.com>
 

trunk/Source/WebCore/dom/UserGestureIndicator.cpp

@@ -71 +71 @@
 }
 
-UserGestureIndicator::UserGestureIndicator(RefPtr<UserGestureToken> token)
+UserGestureIndicator::UserGestureIndicator(RefPtr<UserGestureToken> token, UserGestureToken::GestureScope scope)
 {
     // Silently ignore UserGestureIndicators on non main threads.
@@ -80 +80 @@
     m_previousToken = currentToken();
 
-    if (token)
+    if (token) {
+        token->setScope(scope);
         currentToken() = token;
+    }
 }
 
@@ -89 +91 @@
         return;
     
-    if (auto token = currentToken())
+    if (auto token = currentToken()) {
         token->resetDOMPasteAccess();
+        token->resetScope();
+    }
 
     currentToken() = m_previousToken;

trunk/Source/WebCore/dom/UserGestureIndicator.h

@@ -28 +28 @@
 #include "DOMPasteAccess.h"
 #include <wtf/Function.h>
+#include <wtf/MonotonicTime.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/RefCounted.h>
@@ -54 +55 @@
 
     ProcessingUserGestureState state() const { return m_state; }
-    bool processingUserGesture() const { return m_state == ProcessingUserGesture; }
+    bool processingUserGesture() const { return m_scope == GestureScope::All && m_state == ProcessingUserGesture; }
     bool processingUserGestureForMedia() const { return m_state == ProcessingUserGesture || m_state == ProcessingPotentialUserGesture; }
     UserGestureType gestureType() const { return m_gestureType; }
@@ -79 +80 @@
     void resetDOMPasteAccess() { m_domPasteAccessPolicy = DOMPasteAccessPolicy::NotRequestedYet; }
 
+    enum class GestureScope { All, MediaOnly };
+    void setScope(GestureScope scope) { m_scope = scope; }
+    void resetScope() { m_scope = GestureScope::All; }
+
+    bool hasExpired(Seconds expirationInterval) const
+    {
+        return m_startTime + expirationInterval < MonotonicTime::now();
+    }
+
 private:
     UserGestureToken(ProcessingUserGestureState state, UserGestureType gestureType)
@@ -90 +100 @@
     UserGestureType m_gestureType;
     DOMPasteAccessPolicy m_domPasteAccessPolicy { DOMPasteAccessPolicy::NotRequestedYet };
+    GestureScope m_scope { GestureScope::All };
+    MonotonicTime m_startTime { MonotonicTime::now() };
 };
 
@@ -104 +116 @@
     enum class ProcessInteractionStyle { Immediate, Delayed };
     WEBCORE_EXPORT explicit UserGestureIndicator(Optional<ProcessingUserGestureState>, Document* = nullptr, UserGestureType = UserGestureType::Other, ProcessInteractionStyle = ProcessInteractionStyle::Immediate);
-    WEBCORE_EXPORT explicit UserGestureIndicator(RefPtr<UserGestureToken>);
+    WEBCORE_EXPORT explicit UserGestureIndicator(RefPtr<UserGestureToken>, UserGestureToken::GestureScope = UserGestureToken::GestureScope::All);
     WEBCORE_EXPORT ~UserGestureIndicator();
 

trunk/Source/WebCore/page/DOMTimer.cpp

@@ -54 +54 @@
 class DOMTimerFireState {
 public:
-    DOMTimerFireState(ScriptExecutionContext& context, int nestingLevel, const Seconds& nestedTimerInterval)
+    DOMTimerFireState(ScriptExecutionContext& context, int nestingLevel)
         : m_context(context)
-        , m_nestedTimerInterval(nestedTimerInterval)
         , m_contextIsDocument(is<Document>(m_context))
     {
@@ -79 +78 @@
     Document* contextDocument() const { return m_contextIsDocument ? &downcast<Document>(m_context) : nullptr; }
 
-    const Seconds& nestedTimerInterval() const { return m_nestedTimerInterval; }
-
     void setScriptMadeUserObservableChanges() { m_scriptMadeUserObservableChanges = true; }
     void setScriptMadeNonUserObservableChanges() { m_scriptMadeNonUserObservableChanges = true; }
@@ -99 +96 @@
 private:
     ScriptExecutionContext& m_context;
-    Seconds m_nestedTimerInterval;
     uint64_t m_initialDOMTreeVersion;
     DOMTimerFireState* m_previous;
@@ -163 +159 @@
 
 bool NestedTimersMap::isTrackingNestedTimers = false;
-
-static inline bool shouldForwardUserGesture(Seconds interval)
-{
-    return UserGestureIndicator::processingUserGesture()
-        && interval <= maxIntervalForUserGestureForwarding;
-}
-
-static inline RefPtr<UserGestureToken> userGestureTokenToForward(Seconds interval)
-{
-    if (!shouldForwardUserGesture(interval))
-        return nullptr;
-
-    return UserGestureIndicator::currentUserGesture();
-}
-
-static inline Seconds currentNestedTimerInterval()
-{
-    if (DOMTimerFireState::current)
-        return DOMTimerFireState::current->nestedTimerInterval();
-    return { };
-}
 
 DOMTimer::DOMTimer(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, Seconds interval, bool singleShot)
@@ -192 +167 @@
     , m_throttleState(Undetermined)
     , m_currentTimerInterval(intervalClampedToMinimum())
-    , m_nestedTimerInterval(currentNestedTimerInterval())
-    , m_userGestureTokenToForward(userGestureTokenToForward(m_nestedTimerInterval + m_currentTimerInterval))
+    , m_userGestureTokenToForward(UserGestureIndicator::currentUserGesture())
 {
     RefPtr<DOMTimer> reference = adoptRef(this);
@@ -311 +285 @@
     ScriptExecutionContext& context = *scriptExecutionContext();
 
-    DOMTimerFireState fireState(context, std::min(m_nestingLevel + 1, maxTimerNestingLevel), m_nestedTimerInterval + m_currentTimerInterval);
+    DOMTimerFireState fireState(context, std::min(m_nestingLevel + 1, maxTimerNestingLevel));
+
+    if (m_userGestureTokenToForward && m_userGestureTokenToForward->hasExpired(maxIntervalForUserGestureForwarding))
+        m_userGestureTokenToForward = nullptr;
 
     ASSERT(!isSuspended());

trunk/Source/WebCore/page/DOMTimer.h

@@ -93 +93 @@
     TimerThrottleState m_throttleState;
     Seconds m_currentTimerInterval;
-    Seconds m_nestedTimerInterval;
     RefPtr<UserGestureToken> m_userGestureTokenToForward;
 };

trunk/Source/WebCore/testing/Internals.cpp

@@ -5033 +5033 @@
 }
 
+void Internals::setXHRMaximumIntervalForUserGestureForwarding(XMLHttpRequest& request, double interval)
+{
+    request.setMaximumIntervalForUserGestureForwarding(interval);
+}
+
 } // namespace WebCore

trunk/Source/WebCore/testing/Internals.h

@@ -817 +817 @@
 
     void testDictionaryLogging();
-        
+
+    void setXHRMaximumIntervalForUserGestureForwarding(XMLHttpRequest&, double);
+
 private:
     explicit Internals(Document&);

trunk/Source/WebCore/testing/Internals.idl

@@ -748 +748 @@
 
     void testDictionaryLogging();
-};
+
+    void setXHRMaximumIntervalForUserGestureForwarding(XMLHttpRequest xhr, double interval);
+};

trunk/Source/WebCore/xml/XMLHttpRequest.cpp

@@ -67 +67 @@
 namespace WebCore {
 
+static const Seconds maximumIntervalForUserGestureForwarding { 10_s };
+
 WTF_MAKE_ISO_ALLOCATED_IMPL(XMLHttpRequest);
 
@@ -122 +124 @@
     , m_networkErrorTimer(*this, &XMLHttpRequest::networkErrorTimerFired)
     , m_timeoutTimer(*this, &XMLHttpRequest::didReachTimeout)
+    , m_maximumIntervalForUserGestureForwarding(maximumIntervalForUserGestureForwarding)
 {
 #ifndef NDEBUG
@@ -437 +440 @@
 {
     InspectorInstrumentation::willSendXMLHttpRequest(scriptExecutionContext(), url());
+    m_userGestureToken = UserGestureIndicator::currentUserGesture();
 
     ExceptionOr<void> result;
@@ -1090 +1094 @@
 }
 
+void XMLHttpRequest::dispatchEvent(Event& event)
+{
+    if (m_userGestureToken && m_userGestureToken->hasExpired(m_maximumIntervalForUserGestureForwarding))
+        m_userGestureToken = nullptr;
+
+    if (readyState() != DONE || !m_userGestureToken || !m_userGestureToken->processingUserGesture()) {
+        EventTarget::dispatchEvent(event);
+        return;
+    }
+
+    UserGestureIndicator gestureIndicator(m_userGestureToken, UserGestureToken::GestureScope::MediaOnly);
+    EventTarget::dispatchEvent(event);
+}
+
 void XMLHttpRequest::dispatchErrorEvents(const AtomicString& type)
 {
@@ -1189 +1207 @@
 }
 
+void XMLHttpRequest::setMaximumIntervalForUserGestureForwarding(double interval)
+{
+    m_maximumIntervalForUserGestureForwarding = Seconds(interval);    
+}
+
 } // namespace WebCore

trunk/Source/WebCore/xml/XMLHttpRequest.h

@@ -27 +27 @@
 #include "ResourceResponse.h"
 #include "ThreadableLoaderClient.h"
+#include "UserGestureIndicator.h"
 #include <wtf/URL.h>
 #include "XMLHttpRequestEventTarget.h"
@@ -128 +129 @@
     size_t memoryCost() const;
 
+    WEBCORE_EXPORT void setMaximumIntervalForUserGestureForwarding(double);
+
 private:
     explicit XMLHttpRequest(ScriptExecutionContext&);
@@ -187 +190 @@
 
     void dispatchErrorEvents(const AtomicString&);
+
+    using EventTarget::dispatchEvent;
+    void dispatchEvent(Event&) override;
 
     void resumeTimerFired();
@@ -244 +250 @@
 
     Optional<ExceptionCode> m_exceptionCode;
+    RefPtr<UserGestureToken> m_userGestureToken;
+    Seconds m_maximumIntervalForUserGestureForwarding;
 };