Changeset 167698 in webkit

Timestamp:

Apr 22, 2014 10:53:05 PM (10 years ago)

Author:

benjamin@webkit.org

Message:

[iOS][WK2] Split iOS touch event dispatch for the regular touch event dispatch
​https://bugs.webkit.org/show_bug.cgi?id=132033

Patch by Benjamin Poulain <​bpoulain@apple.com> on 2014-04-22
Reviewed by Simon Fraser.

The generic touch event dispatching does not work well with iOS gesture recognizers.
Some events are required to be synchronous, while other needs can be asynchronous and
can even use event coalescing. We only need UI callback for the synchronous events.

Previously, that was implemented by changing the property ShouldSendEventsSynchronously
on WebPageProxy. That is causing issues when synchronous events are sent right after asynchronous
events because the responses in WebPageProxy::didReceiveEvent() easily get out of order.

This patch completely split the UIGestureRecognizerDispatching from the normal asynchronous event dispatching.

Synchronous events are sent directly to the WebProcess and report the result to the PageClient right away.

Asynchronous events are sent to the EventDispatcher where they are coalesced until the main thread is free
to process events.

There can be a race where a synchronous event comes before the asynchronous events are processed. In that case,
the synchronous event handler starts by getting the events out of the EventDispatcher and dispatch them first.

• Shared/NativeWebTouchEvent.h:

(WebKit::NativeWebTouchEvent::uniqueId): Deleted.

• Shared/ios/NativeWebTouchEventIOS.mm:

(WebKit::NativeWebTouchEvent::NativeWebTouchEvent):

• UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::handleSynchronousTouchEvent):
(WebKit::WebPageProxy::sendAsynchronousTouchEvent):
(WebKit::WebPageProxy::didReceiveEvent):
(WebKit::WebPageProxy::resetStateAfterProcessExited):

• UIProcess/WebPageProxy.h:
• UIProcess/ios/WKContentViewInteraction.h:
• UIProcess/ios/WKContentViewInteraction.mm:

(-[WKContentView _webTouchEventsRecognized:]):
(-[WKContentView _webTouchEvent:WebKit::preventsNativeGestures:]):

• WebProcess/WebPage/EventDispatcher.cpp:

(WebKit::EventDispatcher::EventDispatcher):
(WebKit::EventDispatcher::clearQueuedTouchEventsForPage):
(WebKit::EventDispatcher::getQueuedTouchEventsForPage):
(WebKit::EventDispatcher::touchEvent):
(WebKit::EventDispatcher::dispatchTouchEvents):

• WebProcess/WebPage/EventDispatcher.h:
• WebProcess/WebPage/EventDispatcher.messages.in:
• WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::dispatchTouchEvent):
(WebKit::WebPage::touchEventSync):
(WebKit::WebPage::touchEvent):
(WebKit::WebPage::touchEventSyncForTesting):
(WebKit::WebPage::didCommitLoad):

• WebProcess/WebPage/WebPage.h:
• WebProcess/WebPage/WebPage.messages.in:
• WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::dispatchAsynchronousTouchEventsQueue):

Location:

trunk/Source/WebKit2

Files:

• ChangeLog (modified) (1 diff)
• Shared/NativeWebTouchEvent.h (modified) (2 diffs)
• Shared/ios/NativeWebTouchEventIOS.mm (modified) (2 diffs)
• UIProcess/WebPageProxy.cpp (modified) (3 diffs)
• UIProcess/WebPageProxy.h (modified) (2 diffs)
• UIProcess/ios/WKContentViewInteraction.h (modified) (1 diff)
• UIProcess/ios/WKContentViewInteraction.mm (modified) (2 diffs)
• WebProcess/WebPage/EventDispatcher.cpp (modified) (3 diffs)
• WebProcess/WebPage/EventDispatcher.h (modified) (5 diffs)
• WebProcess/WebPage/EventDispatcher.messages.in (modified) (1 diff)
• WebProcess/WebPage/WebPage.cpp (modified) (3 diffs)
• WebProcess/WebPage/WebPage.h (modified) (3 diffs)
• WebProcess/WebPage/WebPage.messages.in (modified) (1 diff)
• WebProcess/WebPage/ios/WebPageIOS.mm (modified) (1 diff)

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2014-04-22  Benjamin Poulain  <bpoulain@apple.com>
+
+        [iOS][WK2] Split iOS touch event dispatch for the regular touch event dispatch
+        https://bugs.webkit.org/show_bug.cgi?id=132033
+
+        Reviewed by Simon Fraser.
+
+        The generic touch event dispatching does not work well with iOS gesture recognizers.
+        Some events are required to be synchronous, while other needs can be asynchronous and
+        can even use event coalescing. We only need UI callback for the synchronous events.
+
+        Previously, that was implemented by changing the property ShouldSendEventsSynchronously
+        on WebPageProxy. That is causing issues when synchronous events are sent right after asynchronous
+        events because the responses in WebPageProxy::didReceiveEvent() easily get out of order.
+
+        This patch completely split the UIGestureRecognizerDispatching from the normal asynchronous event dispatching.
+
+        Synchronous events are sent directly to the WebProcess and report the result to the PageClient right away.
+
+        Asynchronous events are sent to the EventDispatcher where they are coalesced until the main thread is free
+        to process events.
+
+        There can be a race where a synchronous event comes before the asynchronous events are processed. In that case,
+        the synchronous event handler starts by getting the events out of the EventDispatcher and dispatch them first.
+
+        * Shared/NativeWebTouchEvent.h:
+        (WebKit::NativeWebTouchEvent::uniqueId): Deleted.
+        * Shared/ios/NativeWebTouchEventIOS.mm:
+        (WebKit::NativeWebTouchEvent::NativeWebTouchEvent):
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::handleSynchronousTouchEvent):
+        (WebKit::WebPageProxy::sendAsynchronousTouchEvent):
+        (WebKit::WebPageProxy::didReceiveEvent):
+        (WebKit::WebPageProxy::resetStateAfterProcessExited):
+        * UIProcess/WebPageProxy.h:
+        * UIProcess/ios/WKContentViewInteraction.h:
+        * UIProcess/ios/WKContentViewInteraction.mm:
+        (-[WKContentView _webTouchEventsRecognized:]):
+        (-[WKContentView _webTouchEvent:WebKit::preventsNativeGestures:]):
+        * WebProcess/WebPage/EventDispatcher.cpp:
+        (WebKit::EventDispatcher::EventDispatcher):
+        (WebKit::EventDispatcher::clearQueuedTouchEventsForPage):
+        (WebKit::EventDispatcher::getQueuedTouchEventsForPage):
+        (WebKit::EventDispatcher::touchEvent):
+        (WebKit::EventDispatcher::dispatchTouchEvents):
+        * WebProcess/WebPage/EventDispatcher.h:
+        * WebProcess/WebPage/EventDispatcher.messages.in:
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::dispatchTouchEvent):
+        (WebKit::WebPage::touchEventSync):
+        (WebKit::WebPage::touchEvent):
+        (WebKit::WebPage::touchEventSyncForTesting):
+        (WebKit::WebPage::didCommitLoad):
+        * WebProcess/WebPage/WebPage.h:
+        * WebProcess/WebPage/WebPage.messages.in:
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::dispatchAsynchronousTouchEventsQueue):
+
 2014-04-22  Chris Fleizach  <cfleizach@apple.com>
 

trunk/Source/WebKit2/Shared/NativeWebTouchEvent.h

@@ -49 +49 @@
 #if PLATFORM(IOS)
     explicit NativeWebTouchEvent(UIWebTouchEventsGestureRecognizer *);
-    unsigned uniqueId() const { return m_uniqueID; }
 #elif PLATFORM(GTK)
     NativeWebTouchEvent(const NativeWebTouchEvent&);
@@ -61 +60 @@
 
 private:
-#if PLATFORM(IOS)
-    unsigned m_uniqueID;
-#elif PLATFORM(GTK)
+#if PLATFORM(GTK)
     GUniquePtr<GdkEvent> m_nativeEvent;
     const WebCore::GtkTouchContextHelper& m_touchContext;

trunk/Source/WebKit2/Shared/ios/NativeWebTouchEventIOS.mm

@@ -37 +37 @@
 
 namespace WebKit {
-
-static unsigned uniqueTouchEventIdIndex = 0;
 
 static inline WebEvent::Type webEventTypeForUIWebTouchEventType(UIWebTouchEventType type)
@@ -100 +98 @@
 NativeWebTouchEvent::NativeWebTouchEvent(UIWebTouchEventsGestureRecognizer *gestureRecognizer)
     : WebTouchEvent(webEventTypeForUIWebTouchEventType(gestureRecognizer.type), static_cast<Modifiers>(0), WTF::currentTime(), extractWebTouchPoint(gestureRecognizer), positionForCGPoint(gestureRecognizer.locationInWindow), gestureRecognizer.inJavaScriptGesture, gestureRecognizer.scale, gestureRecognizer.rotation)
-    , m_uniqueID(uniqueTouchEventIdIndex++)
 {
 }

trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

@@ -1494 +1494 @@
     return true;
 }
-
+#endif
+
+#if ENABLE(IOS_TOUCH_EVENTS)
+void WebPageProxy::handleTouchEventSynchronously(const NativeWebTouchEvent& event)
+{
+    if (!isValid())
+        return;
+
+    if (event.type() == WebEvent::TouchStart)
+        m_isTrackingTouchEvents = shouldStartTrackingTouchEvents(event);
+
+    if (!m_isTrackingTouchEvents)
+        return;
+
+    m_process->responsivenessTimer()->start();
+    bool handled = false;
+    m_process->sendSync(Messages::WebPage::TouchEventSync(event), Messages::WebPage::TouchEventSync::Reply(handled), m_pageID);
+    didReceiveEvent(event.type(), handled);
+    m_pageClient.doneWithTouchEvent(event, handled);
+    m_process->responsivenessTimer()->stop();
+
+    if (event.type() == WebEvent::TouchEnd || event.type() == WebEvent::TouchCancel)
+        m_isTrackingTouchEvents = false;
+}
+
+void WebPageProxy::handleTouchEventAsynchronously(const NativeWebTouchEvent& event)
+{
+    if (!isValid())
+        return;
+
+    ASSERT(event.type() != WebEvent::TouchStart);
+
+    if (!m_isTrackingTouchEvents)
+        return;
+
+    m_process->send(Messages::EventDispatcher::TouchEvent(m_pageID, event), 0);
+
+    if (event.type() == WebEvent::TouchEnd || event.type() == WebEvent::TouchCancel)
+        m_isTrackingTouchEvents = false;
+}
+
+#elif ENABLE(TOUCH_EVENTS)
 void WebPageProxy::handleTouchEvent(const NativeWebTouchEvent& event)
 {
@@ -3798 +3839 @@
         break;
     }
-#if ENABLE(TOUCH_EVENTS)
+#if ENABLE(IOS_TOUCH_EVENTS)
+    case WebEvent::TouchStart:
+    case WebEvent::TouchMove:
+    case WebEvent::TouchEnd:
+    case WebEvent::TouchCancel:
+        break;
+#elif ENABLE(TOUCH_EVENTS)
     case WebEvent::TouchStart:
     case WebEvent::TouchMove:
@@ -4154 +4201 @@
     m_processingMouseMoveEvent = false;
 
-#if ENABLE(TOUCH_EVENTS)
+#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
     m_touchEventQueue.clear();
 #endif

trunk/Source/WebKit2/UIProcess/WebPageProxy.h

@@ -695 +695 @@
     void handleWheelEvent(const NativeWebWheelEvent&);
     void handleKeyboardEvent(const NativeWebKeyboardEvent&);
-#if ENABLE(TOUCH_EVENTS)
+#if ENABLE(IOS_TOUCH_EVENTS)
+    void handleTouchEventSynchronously(const NativeWebTouchEvent&);
+    void handleTouchEventAsynchronously(const NativeWebTouchEvent&);
+#elif ENABLE(TOUCH_EVENTS)
     void handleTouchEvent(const NativeWebTouchEvent&);
 #endif
@@ -1564 +1567 @@
 #if ENABLE(TOUCH_EVENTS)
     bool m_isTrackingTouchEvents;
+#endif
+#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
     Deque<QueuedTouchEvents> m_touchEventQueue;
 #endif
+
 #if ENABLE(INPUT_TYPE_COLOR)
     RefPtr<WebColorPicker> m_colorPicker;

trunk/Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h

@@ -81 +81 @@
 
     BOOL _canSendTouchEventsAsynchronously;
-    unsigned _nativeWebTouchEventUniqueIdBeingSentSynchronously;
 
     RetainPtr<UITapGestureRecognizer> _singleTapGestureRecognizer;

trunk/Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm

@@ -292 +292 @@
 {
     NativeWebTouchEvent nativeWebTouchEvent(gestureRecognizer);
-
     if (nativeWebTouchEvent.type() == WebKit::WebEvent::TouchStart)
         _canSendTouchEventsAsynchronously = NO;
 
-    if (!_canSendTouchEventsAsynchronously)
-        _nativeWebTouchEventUniqueIdBeingSentSynchronously = nativeWebTouchEvent.uniqueId();
-
-    _page->setShouldSendEventsSynchronously(!_canSendTouchEventsAsynchronously);
-    _page->handleTouchEvent(nativeWebTouchEvent);
-    _page->setShouldSendEventsSynchronously(false);
+    if (_canSendTouchEventsAsynchronously)
+        _page->handleTouchEventAsynchronously(nativeWebTouchEvent);
+    else
+        _page->handleTouchEventSynchronously(nativeWebTouchEvent);
 }
 
@@ -344 +341 @@
 {
     if (preventsNativeGesture) {
-        // If we are dispatching events synchronously and the event coming back is not the one we are sending, it is a callback
-        // from an event sent asynchronously prior to the synchronous event. In that case, it should not use that information
-        // to update UIWebTouchEventsGestureRecognizer.
-        if (!_canSendTouchEventsAsynchronously && _nativeWebTouchEventUniqueIdBeingSentSynchronously != touchEvent.uniqueId())
-            return;
-
         _canSendTouchEventsAsynchronously = YES;
         [_touchEventGestureRecognizer setDefaultPrevented:YES];

trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -55 +55 @@
     : m_queue(WorkQueue::create("com.apple.WebKit.EventDispatcher"))
     , m_recentWheelEventDeltaTracker(adoptPtr(new WheelEventDeltaTracker))
+#if ENABLE(IOS_TOUCH_EVENTS)
+    , m_touchEventsLock(SPINLOCK_INITIALIZER)
+#endif
 {
 }
@@ -144 +147 @@
 }
 
+#if ENABLE(IOS_TOUCH_EVENTS)
+void EventDispatcher::clearQueuedTouchEventsForPage(const WebPage& webPage)
+{
+    SpinLockHolder locker(&m_touchEventsLock);
+    m_touchEvents.remove(webPage.pageID());
+}
+
+void EventDispatcher::getQueuedTouchEventsForPage(const WebPage& webPage, TouchEventQueue& destinationQueue)
+{
+    SpinLockHolder locker(&m_touchEventsLock);
+    destinationQueue = std::move(m_touchEvents.take(webPage.pageID()));
+}
+
+void EventDispatcher::touchEvent(uint64_t pageID, const WebKit::WebTouchEvent& touchEvent)
+{
+    bool updateListWasEmpty;
+    {
+        SpinLockHolder locker(&m_touchEventsLock);
+        updateListWasEmpty = m_touchEvents.isEmpty();
+        auto addResult = m_touchEvents.add(pageID, std::move(TouchEventQueue()));
+        if (addResult.isNewEntry)
+            addResult.iterator->value.append(touchEvent);
+        else {
+            TouchEventQueue& queuedEvents = addResult.iterator->value;
+            ASSERT(!queuedEvents.isEmpty());
+            const WebTouchEvent& lastTouchEvent = queuedEvents.last();
+
+            // Coalesce touch move events.
+            WebEvent::Type type = lastTouchEvent.type();
+            if (type == WebEvent::TouchMove)
+                queuedEvents.last() = touchEvent;
+            else
+                queuedEvents.append(touchEvent);
+        }
+    }
+
+    if (updateListWasEmpty)
+        RunLoop::main().dispatch(bind(&EventDispatcher::dispatchTouchEvents, this));
+}
+
+void EventDispatcher::dispatchTouchEvents()
+{
+    HashMap<uint64_t, TouchEventQueue> localCopy;
+    {
+        SpinLockHolder locker(&m_touchEventsLock);
+        localCopy.swap(m_touchEvents);
+    }
+
+    for (auto& slot : localCopy) {
+        if (WebPage* webPage = WebProcess::shared().webPage(slot.key))
+            webPage->dispatchAsynchronousTouchEvents(slot.value);
+    }
+}
+#endif
+
 void EventDispatcher::dispatchWheelEvent(uint64_t pageID, const WebWheelEvent& wheelEvent)
 {

trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30 +30 @@
 
 #include <WebCore/WheelEventDeltaTracker.h>
+#include <WebEvent.h>
 #include <wtf/HashMap.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/RefPtr.h>
+#include <wtf/TCSpinLock.h>
 #include <wtf/ThreadingPrimitives.h>
 
@@ -55 +57 @@
 #endif
 
+#if ENABLE(IOS_TOUCH_EVENTS)
+    typedef Vector<WebTouchEvent, 1> TouchEventQueue;
+
+    void clearQueuedTouchEventsForPage(const WebPage&);
+    void getQueuedTouchEventsForPage(const WebPage&, TouchEventQueue&);
+#endif
+
     void initializeConnection(IPC::Connection*);
 
@@ -65 +74 @@
     // Message handlers
     void wheelEvent(uint64_t pageID, const WebWheelEvent&, bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom);
+#if ENABLE(IOS_TOUCH_EVENTS)
+    void touchEvent(uint64_t pageID, const WebTouchEvent&);
+#endif
+
 
     // This is called on the main thread.
     void dispatchWheelEvent(uint64_t pageID, const WebWheelEvent&);
+#if ENABLE(IOS_TOUCH_EVENTS)
+    void dispatchTouchEvents();
+#endif
 
 #if ENABLE(ASYNC_SCROLLING)
@@ -80 +96 @@
 #endif
     OwnPtr<WebCore::WheelEventDeltaTracker> m_recentWheelEventDeltaTracker;
+#if ENABLE(IOS_TOUCH_EVENTS)
+    SpinLock m_touchEventsLock;
+    HashMap<uint64_t, TouchEventQueue> m_touchEvents;
+#endif
 };
 

trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.messages.in

@@ -23 +23 @@
 messages -> EventDispatcher {
     WheelEvent(uint64_t pageID, WebKit::WebWheelEvent event, bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom)
+#if ENABLE(IOS_TOUCH_EVENTS)
+    TouchEvent(uint64_t pageID, WebKit::WebTouchEvent event)
+#endif
 }

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

@@ -1949 +1949 @@
     return page->mainFrame().eventHandler().handleTouchEvent(platform(touchEvent));
 }
-
+#endif
+
+#if ENABLE(IOS_TOUCH_EVENTS)
+void WebPage::dispatchTouchEvent(const WebTouchEvent& touchEvent, bool& handled)
+{
+    m_lastInteractionLocation = touchEvent.position();
+    CurrentEvent currentEvent(touchEvent);
+    handled = handleTouchEvent(touchEvent, m_page.get());
+}
+
+void WebPage::touchEventSync(const WebTouchEvent& touchEvent, bool& handled)
+{
+    EventDispatcher::TouchEventQueue queuedEvents;
+    WebProcess::shared().eventDispatcher().getQueuedTouchEventsForPage(*this, queuedEvents);
+    dispatchAsynchronousTouchEvents(queuedEvents);
+
+    dispatchTouchEvent(touchEvent, handled);
+}
+#elif ENABLE(TOUCH_EVENTS)
 void WebPage::touchEvent(const WebTouchEvent& touchEvent)
 {
-#if PLATFORM(IOS)
-    m_lastInteractionLocation = touchEvent.position();
-#endif
+
     bool handled = false;
     if (canHandleUserEvents()) {
@@ -1966 +1982 @@
 void WebPage::touchEventSyncForTesting(const WebTouchEvent& touchEvent, bool& handled)
 {
-#if PLATFORM(IOS)
-    m_lastInteractionLocation = touchEvent.position();
-#endif
     CurrentEvent currentEvent(touchEvent);
     handled = handleTouchEvent(touchEvent, m_page.get());
@@ -4240 +4253 @@
     m_userHasChangedPageScaleFactor = false;
 
+    WebProcess::shared().eventDispatcher().clearQueuedTouchEventsForPage(*this);
+
     Document* document = frame->coreFrame()->document();
     if (document->isImageDocument())

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

@@ -479 +479 @@
     WebCore::IntRect rectForElementAtInteractionLocation();
 
+    void dispatchAsynchronousTouchEvents(const Vector<WebTouchEvent, 1>& queue);
 #if ENABLE(INSPECTOR)
     void showInspectorIndication();
@@ -706 +707 @@
     void applicationDidBecomeActive();
     void zoomToRect(WebCore::FloatRect, double minimumScale, double maximumScale);
+    void dispatchTouchEvent(const WebTouchEvent&, bool& handled);
 #endif
 
@@ -856 +858 @@
     void keyEvent(const WebKeyboardEvent&);
     void keyEventSyncForTesting(const WebKeyboardEvent&, bool&);
-#if ENABLE(TOUCH_EVENTS)
+#if ENABLE(IOS_TOUCH_EVENTS)
+    void touchEventSync(const WebTouchEvent&, bool& handled);
+#elif ENABLE(TOUCH_EVENTS)
     void touchEvent(const WebTouchEvent&);
     void touchEventSyncForTesting(const WebTouchEvent&, bool& handled);

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

@@ -82 +82 @@
 #endif
 
-#if ENABLE(TOUCH_EVENTS)
+#if ENABLE(IOS_TOUCH_EVENTS)
+    TouchEventSync(WebKit::WebTouchEvent event) -> (bool handled)
+#endif
+#if !ENABLE(IOS_TOUCH_EVENTS) && ENABLE(TOUCH_EVENTS)
     TouchEvent(WebKit::WebTouchEvent event)
     TouchEventSyncForTesting(WebKit::WebTouchEvent event) -> (bool handled)

trunk/Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

@@ -2060 +2060 @@
 }
 
+void WebPage::dispatchAsynchronousTouchEvents(const Vector<WebTouchEvent, 1>& queue)
+{
+    bool ignored;
+    for (const WebTouchEvent& event : queue)
+        dispatchTouchEvent(event, ignored);
+}
+
 } // namespace WebKit