Changeset 279641 in webkit


Ignore:
Timestamp:
Jul 7, 2021, 6:15:15 AM (4 years ago)
Author:
Adrian Perez de Castro
Message:

Merge r279037 - [WPE] Rework touch-based gesture controller
​https://bugs.webkit.org/show_bug.cgi?id=226456

Patch by Zan Dobersek <​zdobersek@igalia.com> on 2021-06-18
Reviewed by Alejandro G. Castro.

Rename WPE's ScrollGestureController to TouchGestureController since now
it also handles production of touch-based click events.

TouchGestureController now internally manages all the related state,
tracking the touch interaction and determining whether it progresses
into a scrolling gesture or whether, upon finishing, it should be
translated into a simple click event.

In PageClientImpl, any unhandled event is pushed into
TouchGestureController and a variant of different outcomes is returned.
No-event result is ignored, and click or axis events are dispatched as
appropriate.

In WPEView, where the touch events arrive into the engine, we keep the
shortcut where touch events are piped directly into the controller if
said controller is already gesturing scrolling behavior. In that case
the touch events are not dispatched into the engine, with the exception
of touch-up events which are, to provide matching closure for the
touch-down events.

  • SourcesWPE.txt:
  • UIProcess/API/wpe/PageClientImpl.cpp:

(WebKit::PageClientImpl::doneWithTouchEvent):

  • UIProcess/API/wpe/TouchGestureController.cpp: Renamed from Source/WebKit/UIProcess/API/wpe/ScrollGestureController.cpp.

(WebKit::TouchGestureController::handleEvent):

  • UIProcess/API/wpe/TouchGestureController.h: Renamed from Source/WebKit/UIProcess/API/wpe/ScrollGestureController.h.

(WebKit::TouchGestureController::gesturedEvent const):

  • UIProcess/API/wpe/WPEView.cpp:

(WKWPE::View::View):
(WKWPE::m_backend):

  • UIProcess/API/wpe/WPEView.h:

(WKWPE::View::touchGestureController const):
(WKWPE::View::scrollGestureController const): Deleted.

Location:
releases/WebKitGTK/webkit-2.32/Source/WebKit
Files:
5 edited
2 moved

Legend:

Unmodified
Added
Removed

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/ChangeLog

    r279617 r279641  
     12021-06-18  Zan Dobersek  <zdobersek@igalia.com>
     2
     3        [WPE] Rework touch-based gesture controller
     4        https://bugs.webkit.org/show_bug.cgi?id=226456
     5
     6        Reviewed by Alejandro G. Castro.
     7
     8        Rename WPE's ScrollGestureController to TouchGestureController since now
     9        it also handles production of touch-based click events.
     10
     11        TouchGestureController now internally manages all the related state,
     12        tracking the touch interaction and determining whether it progresses
     13        into a scrolling gesture or whether, upon finishing, it should be
     14        translated into a simple click event.
     15
     16        In PageClientImpl, any unhandled event is pushed into
     17        TouchGestureController and a variant of different outcomes is returned.
     18        No-event result is ignored, and click or axis events are dispatched as
     19        appropriate.
     20
     21        In WPEView, where the touch events arrive into the engine, we keep the
     22        shortcut where touch events are piped directly into the controller if
     23        said controller is already gesturing scrolling behavior. In that case
     24        the touch events are not dispatched into the engine, with the exception
     25        of touch-up events which are, to provide matching closure for the
     26        touch-down events.
     27
     28        * SourcesWPE.txt:
     29        * UIProcess/API/wpe/PageClientImpl.cpp:
     30        (WebKit::PageClientImpl::doneWithTouchEvent):
     31        * UIProcess/API/wpe/TouchGestureController.cpp: Renamed from Source/WebKit/UIProcess/API/wpe/ScrollGestureController.cpp.
     32        (WebKit::TouchGestureController::handleEvent):
     33        * UIProcess/API/wpe/TouchGestureController.h: Renamed from Source/WebKit/UIProcess/API/wpe/ScrollGestureController.h.
     34        (WebKit::TouchGestureController::gesturedEvent const):
     35        * UIProcess/API/wpe/WPEView.cpp:
     36        (WKWPE::View::View):
     37        (WKWPE::m_backend):
     38        * UIProcess/API/wpe/WPEView.h:
     39        (WKWPE::View::touchGestureController const):
     40        (WKWPE::View::scrollGestureController const): Deleted.
     41
    1422021-06-11  Michael Catanzaro  <mcatanzaro@gnome.org>
    243

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/SourcesWPE.txt

    r273131 r279641  
    180180UIProcess/API/wpe/InputMethodFilterWPE.cpp @no-unify
    181181UIProcess/API/wpe/PageClientImpl.cpp @no-unify
    182 UIProcess/API/wpe/ScrollGestureController.cpp @no-unify
     182UIProcess/API/wpe/TouchGestureController.cpp @no-unify
    183183UIProcess/API/wpe/WebKitColor.cpp @no-unify
    184184UIProcess/API/wpe/WebKitInputMethodContextWPE.cpp @no-unify

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/UIProcess/API/wpe/PageClientImpl.cpp

    r271292 r279641  
    3131#include "NativeWebMouseEvent.h"
    3232#include "NativeWebWheelEvent.h"
    33 #include "ScrollGestureController.h"
     33#include "TouchGestureController.h"
    3434#include "WPEView.h"
    3535#include "WebContextMenuProxy.h"
    … …  
    213213
    214214    auto& page = m_view.page();
    215     auto& scrollGestureController = m_view.scrollGestureController();
    216 
    217     if (scrollGestureController.handleEvent(touchPoint)) {
    218         struct wpe_input_axis_event* axisEvent = scrollGestureController.axisEvent();
    219         if (axisEvent->type != wpe_input_axis_event_type_null)
    220             page.handleWheelEvent(WebKit::NativeWebWheelEvent(axisEvent, m_view.page().deviceScaleFactor(), scrollGestureController.phase(), WebWheelEvent::Phase::PhaseNone));
    221         return;
    222     }
    223 
    224     struct wpe_input_pointer_event pointerEvent {
    225         wpe_input_pointer_event_type_null, touchPoint->time,
    226         touchPoint->x, touchPoint->y,
    227         1, 0, 0
    228     };
    229 
    230     switch (touchPoint->type) {
    231     case wpe_input_touch_event_type_down:
    232         pointerEvent.type = wpe_input_pointer_event_type_button;
    233         pointerEvent.state = 1;
    234         pointerEvent.modifiers |= wpe_input_pointer_modifier_button1;
    235         break;
    236     case wpe_input_touch_event_type_motion:
    237         pointerEvent.type = wpe_input_pointer_event_type_motion;
    238         pointerEvent.state = 1;
    239         break;
    240     case wpe_input_touch_event_type_up:
    241         pointerEvent.type = wpe_input_pointer_event_type_button;
    242         pointerEvent.state = 0;
    243         pointerEvent.modifiers &= ~wpe_input_pointer_modifier_button1;
    244         break;
    245     case wpe_input_touch_event_type_null:
    246         ASSERT_NOT_REACHED();
    247         return;
    248     }
    249 
    250     page.handleMouseEvent(NativeWebMouseEvent(&pointerEvent, page.deviceScaleFactor()));
     215    auto& touchGestureController = m_view.touchGestureController();
     216
     217    auto generatedEvent = touchGestureController.handleEvent(touchPoint);
     218    WTF::switchOn(generatedEvent,
     219        [](TouchGestureController::NoEvent&) { },
     220        [&](TouchGestureController::ClickEvent& clickEvent)
     221        {
     222            auto* event = &clickEvent.event;
     223
     224            // Mouse motion towards the point of the click.
     225            event->type = wpe_input_pointer_event_type_motion;
     226            page.handleMouseEvent(NativeWebMouseEvent(event, page.deviceScaleFactor()));
     227
     228            event->type = wpe_input_pointer_event_type_button;
     229            event->button = 1;
     230
     231            // Mouse down on the point of the click.
     232            event->state = 1;
     233            event->modifiers |= wpe_input_pointer_modifier_button1;
     234            page.handleMouseEvent(NativeWebMouseEvent(event, page.deviceScaleFactor()));
     235
     236            // Mouse up on the same location.
     237            event->state = 0;
     238            event->modifiers &= ~wpe_input_pointer_modifier_button1;
     239            page.handleMouseEvent(NativeWebMouseEvent(event, page.deviceScaleFactor()));
     240        },
     241        [&](TouchGestureController::AxisEvent& axisEvent)
     242        {
     243#if WPE_CHECK_VERSION(1, 5, 0)
     244            auto* event = &axisEvent.event.base;
     245#else
     246            auto* event = &axisEvent.event;
     247#endif
     248            if (event->type != wpe_input_axis_event_type_null) {
     249                page.handleWheelEvent(WebKit::NativeWebWheelEvent(event, page.deviceScaleFactor(),
     250                    axisEvent.phase, WebWheelEvent::Phase::PhaseNone));
     251            }
     252        });
    251253}
    252254#endif

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/UIProcess/API/wpe/TouchGestureController.cpp

    r279618 r279641  
    2525
    2626#include "config.h"
    27 #include "ScrollGestureController.h"
     27#include "TouchGestureController.h"
    2828
    2929#include "WebKitSettings.h"
    … …  
    3939static constexpr uint32_t axisLockReleaseThreshold { 30 };
    4040
    41 bool ScrollGestureController::handleEvent(const struct wpe_input_touch_event_raw* touchPoint)
     41TouchGestureController::EventVariant TouchGestureController::handleEvent(const struct wpe_input_touch_event_raw* touchPoint)
    4242{
    4343    switch (touchPoint->type) {
    4444    case wpe_input_touch_event_type_down:
    45         m_start.active = true;
    46         m_start.time = touchPoint->time;
    47         m_start.x = touchPoint->x;
    48         m_start.y = touchPoint->y;
    49         m_offset.x = touchPoint->x;
    50         m_offset.y = touchPoint->y;
    51         m_xAxisLockBroken = false;
    52         m_yAxisLockBroken = false;
    53         return false;
     45        // Start of the touch interaction, first possible event is a mouse click.
     46        m_gesturedEvent = GesturedEvent::Click;
     47        m_start = { true, touchPoint->time, touchPoint->x, touchPoint->y };
     48        m_offset = { touchPoint->x, touchPoint->y };
     49        m_xAxisLockBroken = m_yAxisLockBroken = false;
     50        break;
    5451    case wpe_input_touch_event_type_motion:
    55         if (m_start.active && !m_handling) {
     52    {
     53        switch (m_gesturedEvent) {
     54        case GesturedEvent::None:
     55            break;
     56        case GesturedEvent::Click:
     57        {
     58            // If currently only gesturing a click, determine if the touch has progressed
     59            // so far that it should become a scrolling gesture.
    5660            int32_t deltaX = touchPoint->x - m_start.x;
    5761            int32_t deltaY = touchPoint->y - m_start.y;
    … …  
    5963
    6064            int pixelsPerLineStep = WebCore::Scrollbar::pixelsPerLineStep();
    61             m_handling = std::abs(deltaX) >= pixelsPerLineStep
     65            bool overThreshold = std::abs(deltaX) >= pixelsPerLineStep
    6266                || std::abs(deltaY) >= pixelsPerLineStep
    6367                || deltaTime >= scrollCaptureThreshold;
     68            if (!overThreshold)
     69                break;
     70
     71            // Over threshold, bump the gestured event and directly fall through to handling it.
     72            m_gesturedEvent = GesturedEvent::Axis;
     73            FALLTHROUGH;
    6474        }
    65         if (m_handling) {
     75        case GesturedEvent::Axis:
     76        {
     77            AxisEvent generatedEvent;
     78            generatedEvent.phase = WebWheelEvent::Phase::PhaseChanged;
     79
    6680#if WPE_CHECK_VERSION(1, 5, 0)
    67             m_axisEvent.base = {
     81            generatedEvent.event.base = {
    6882                static_cast<enum wpe_input_axis_event_type>(wpe_input_axis_event_type_mask_2d | wpe_input_axis_event_type_motion_smooth),
    6983                touchPoint->time, m_start.x, m_start.y,
    … …  
    8498            }
    8599
    86             m_axisEvent.x_axis = (m_xAxisLockBroken || yOffset < axisLockActivationThreshold) ?  -(m_offset.x - touchPoint->x) : 0;
    87             m_axisEvent.y_axis = (m_yAxisLockBroken || xOffset < axisLockActivationThreshold) ?  -(m_offset.y - touchPoint->y) : 0;
     100            generatedEvent.event.x_axis = (m_xAxisLockBroken || yOffset < axisLockActivationThreshold) ?  -(m_offset.x - touchPoint->x) : 0;
     101            generatedEvent.event.y_axis = (m_yAxisLockBroken || xOffset < axisLockActivationThreshold) ?  -(m_offset.y - touchPoint->y) : 0;
    88102#else
    89             m_axisEvent = {
     103            generatedEvent.event = {
    90104                wpe_input_axis_event_type_motion,
    91105                touchPoint->time, m_start.x, m_start.y,
    … …  
    95109            m_offset.x = touchPoint->x;
    96110            m_offset.y = touchPoint->y;
    97             m_phase = WebWheelEvent::Phase::PhaseChanged;
    98             return true;
     111            return generatedEvent;
    99112        }
    100         return false;
     113        }
     114        break;
     115    }
    101116    case wpe_input_touch_event_type_up:
    102         if (m_handling) {
    103             m_start.active = false;
    104             m_handling = false;
     117    {
     118        switch (m_gesturedEvent) {
     119        case GesturedEvent::None:
     120            break;
     121        case GesturedEvent::Click:
     122        {
     123            m_gesturedEvent = GesturedEvent::None;
     124
     125            ClickEvent generatedEvent;
     126            generatedEvent.event = {
     127                wpe_input_pointer_event_type_null, touchPoint->time, touchPoint->x, touchPoint->y,
     128                0, 0, 0,
     129            };
     130            return generatedEvent;
     131        }
     132        case GesturedEvent::Axis:
     133        {
     134            m_gesturedEvent = GesturedEvent::None;
     135
     136            AxisEvent generatedEvent;
     137            generatedEvent.phase = WebWheelEvent::Phase::PhaseEnded;
     138
    105139#if WPE_CHECK_VERSION(1, 5, 0)
    106             m_axisEvent.base = {
    107                 m_axisEvent.base.type,
     140            generatedEvent.event.base = {
     141                static_cast<enum wpe_input_axis_event_type>(wpe_input_axis_event_type_mask_2d | wpe_input_axis_event_type_motion_smooth),
    108142                touchPoint->time, m_start.x, m_start.y,
    109143                0, 0, 0
    110144            };
    111             m_axisEvent.x_axis = m_axisEvent.y_axis = 0;
     145            generatedEvent.event.x_axis = generatedEvent.event.y_axis = 0;
    112146#else
    113             m_axisEvent = {
    114                 m_axisEvent.type,
     147            generatedEvent.event = {
     148                wpe_input_axis_event_type_motion,
    115149                touchPoint->time, m_start.x, m_start.y,
    116150                0, 0, 0
    … …  
    118152#endif
    119153            m_offset.x = m_offset.y = 0;
    120             m_phase = WebWheelEvent::Phase::PhaseEnded;
     154            return generatedEvent;
    121155        }
    122         return false;
     156        }
     157        break;
     158    }
    123159    default:
    124         return false;
     160        break;
    125161    }
     162
     163    return NoEvent { };
    126164}
    127165

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/UIProcess/API/wpe/TouchGestureController.h

    r279618 r279641  
    2828#include "WebWheelEvent.h"
    2929#include <wpe/wpe.h>
     30#include <wtf/Variant.h>
    3031
    3132namespace WebKit {
    3233
    33 class ScrollGestureController {
     34class TouchGestureController {
    3435    WTF_MAKE_FAST_ALLOCATED;
    3536public:
    36     ScrollGestureController() = default;
     37    TouchGestureController() = default;
    3738
    38     struct wpe_input_axis_event* axisEvent()
    39     {
     39    enum class GesturedEvent {
     40        None,
     41        Click,
     42        Axis,
     43    };
     44
     45    struct NoEvent { };
     46
     47    struct ClickEvent {
     48        struct wpe_input_pointer_event event;
     49    };
     50
     51    struct AxisEvent {
    4052#if WPE_CHECK_VERSION(1, 5, 0)
    41         return &m_axisEvent.base;
     53        struct wpe_input_axis_2d_event event;
    4254#else
    43         return &m_axisEvent;
     55        struct wpe_input_axis_event event;
    4456#endif
    45     }
     57        WebWheelEvent::Phase phase;
     58    };
    4659
    47     WebWheelEvent::Phase phase() { return m_phase; }
     60    using EventVariant = Variant<NoEvent, ClickEvent, AxisEvent>;
    4861
    49     bool isHandling() const { return m_handling; }
    50     bool handleEvent(const struct wpe_input_touch_event_raw*);
     62    GesturedEvent gesturedEvent() const { return m_gesturedEvent; }
     63    EventVariant handleEvent(const struct wpe_input_touch_event_raw*);
    5164
    5265private:
     66    GesturedEvent m_gesturedEvent { GesturedEvent::None };
     67
    5368    struct {
    5469        bool active { false };
    … …  
    6378    } m_offset;
    6479
    65     bool m_handling { false };
    66 #if WPE_CHECK_VERSION(1, 5, 0)
    67     struct wpe_input_axis_2d_event m_axisEvent;
    68 #else
    69     struct wpe_input_axis_event m_axisEvent;
    70 #endif
    71     WebWheelEvent::Phase m_phase { WebWheelEvent::Phase::PhaseNone };
    72 
    7380    bool m_xAxisLockBroken { false };
    7481    bool m_yAxisLockBroken { false };

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/UIProcess/API/wpe/WPEView.cpp

    r279334 r279641  
    3636#include "NativeWebTouchEvent.h"
    3737#include "NativeWebWheelEvent.h"
    38 #include "ScrollGestureController.h"
     38#include "TouchGestureController.h"
    3939#include "WebPageGroup.h"
    4040#include "WebProcessPool.h"
    … …  
    4848View::View(struct wpe_view_backend* backend, const API::PageConfiguration& baseConfiguration)
    4949    : m_client(makeUnique<API::ViewClient>())
    50     , m_scrollGestureController(makeUnique<ScrollGestureController>())
     50    , m_touchGestureController(makeUnique<TouchGestureController>())
    5151    , m_pageClient(makeUnique<PageClientImpl>(*this))
    5252    , m_size { 800, 600 }
    … …  
    217217            WebKit::NativeWebTouchEvent touchEvent(event, page.deviceScaleFactor());
    218218
    219             auto& scrollGestureController = *view.m_scrollGestureController;
    220             if (scrollGestureController.isHandling()) {
    221                 const struct wpe_input_touch_event_raw* touchPoint = touchEvent.nativeFallbackTouchPoint();
    222                 if (touchPoint->type != wpe_input_touch_event_type_null && scrollGestureController.handleEvent(touchPoint)) {
    223                     page.handleWheelEvent(WebKit::NativeWebWheelEvent(scrollGestureController.axisEvent(), page.deviceScaleFactor(), scrollGestureController.phase(), WebWheelEvent::Phase::PhaseNone));
     219            // If already gesturing axis events, short-cut directly to the controller,
     220            // avoiding the usual roundtrip.
     221            auto& touchGestureController = *view.m_touchGestureController;
     222            if (touchGestureController.gesturedEvent() == TouchGestureController::GesturedEvent::Axis) {
     223                bool handledThroughGestureController = false;
     224
     225                auto generatedEvent = touchGestureController.handleEvent(touchEvent.nativeFallbackTouchPoint());
     226                WTF::switchOn(generatedEvent,
     227                    [](TouchGestureController::NoEvent&) { },
     228                    [](TouchGestureController::ClickEvent&) { },
     229                    [&](TouchGestureController::AxisEvent& axisEvent)
     230                    {
     231#if WPE_CHECK_VERSION(1, 5, 0)
     232                        auto* event = &axisEvent.event.base;
     233#else
     234                        auto* event = &axisEvent.event;
     235#endif
     236                        if (event->type != wpe_input_axis_event_type_null) {
     237                            page.handleWheelEvent(WebKit::NativeWebWheelEvent(event, page.deviceScaleFactor(),
     238                                axisEvent.phase, WebWheelEvent::Phase::PhaseNone));
     239                            handledThroughGestureController = true;
     240                        }
     241                    });
     242
     243                // In case of the axis event gesturing, the generic touch event handling should be skipped.
     244                // Exception to this are touch-up events that should still be handled just like the corresponding
     245                // touch-down events were.
     246                if (handledThroughGestureController && event->type != wpe_input_touch_event_type_up)
    224247                    return;
    225                 }
    226248            }
    227249

  • releases/WebKitGTK/webkit-2.32/Source/WebKit/UIProcess/API/wpe/WPEView.h

    r271292 r279641  
    5555namespace WebKit {
    5656class DownloadProxy;
    57 class ScrollGestureController;
     57class TouchGestureController;
    5858class WebPageGroup;
    5959class WebProcessPool;
    … …  
    108108#endif
    109109
    110     WebKit::ScrollGestureController& scrollGestureController() const { return *m_scrollGestureController; }
     110    WebKit::TouchGestureController& touchGestureController() const { return *m_touchGestureController; }
    111111
    112112private:
    … …  
    119119    std::unique_ptr<API::ViewClient> m_client;
    120120
    121     std::unique_ptr<WebKit::ScrollGestureController> m_scrollGestureController;
     121    std::unique_ptr<WebKit::TouchGestureController> m_touchGestureController;
    122122    std::unique_ptr<WebKit::PageClientImpl> m_pageClient;
    123123    RefPtr<WebKit::WebPageProxy> m_pageProxy;
Note: See TracChangeset for help on using the changeset viewer.