Refactor RenderWidgetHostViewQt

Make RenderWidgetHostViewQtDelegateClient class instantiable and remove
its implementation from RenderWidgetHostViewQt.

Change-Id: Idcad3a805defe8b910f418b91f14808b6dbf083b
Reviewed-by: Jüri Valdmann <juri.valdmann@qt.io>

1 files changed, 973 insertions, 0 deletions

diff --git a/src/core/render_widget_host_view_qt_delegate_client.cpp b/src/core/render_widget_host_view_qt_delegate_client.cpp
new file mode 100644
index 000000000..d7674fd13
--- /dev/null
+++ b/src/core/render_widget_host_view_qt_delegate_client.cpp
@@ -0,0 +1,973 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "render_widget_host_view_qt_delegate_client.h"
+
+#include "render_widget_host_view_qt.h"
+#include "touch_selection_controller_client_qt.h"
+#include "type_conversion.h"
+#include "web_contents_adapter.h"
+#include "web_contents_adapter_client.h"
+#include "web_event_factory.h"
+
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "ui/touch_selection/touch_selection_controller.h"
+
+#include <QEvent>
+#include <QInputMethodEvent>
+#include <QSGNode>
+#include <QStyleHints>
+#include <QTextFormat>
+#include <QVariant>
+
+#include <private/qguiapplication_p.h>
+#include <qpa/qplatforminputcontext.h>
+#include <qpa/qplatformintegration.h>
+#include <QtGui/private/qinputcontrol_p.h>
+
+namespace QtWebEngineCore {
+
+static inline int firstAvailableId(const QMap<int, int> &map)
+{
+    ui::BitSet32 usedIds;
+    QMap<int, int>::const_iterator end = map.end();
+    for (QMap<int, int>::const_iterator it = map.begin(); it != end; ++it)
+        usedIds.mark_bit(it.value());
+    return usedIds.first_unmarked_bit();
+}
+
+static QList<QTouchEvent::TouchPoint>
+mapTouchPointIds(const QList<QTouchEvent::TouchPoint> &inputPoints)
+{
+    static QMap<int, int> touchIdMapping;
+    QList<QTouchEvent::TouchPoint> outputPoints = inputPoints;
+    for (int i = 0; i < outputPoints.size(); ++i) {
+        QTouchEvent::TouchPoint &point = outputPoints[i];
+
+        int qtId = point.id();
+        QMap<int, int>::const_iterator it = touchIdMapping.find(qtId);
+        if (it == touchIdMapping.end())
+            it = touchIdMapping.insert(qtId, firstAvailableId(touchIdMapping));
+        point.setId(it.value());
+
+        if (point.state() == Qt::TouchPointReleased)
+            touchIdMapping.remove(qtId);
+    }
+
+    return outputPoints;
+}
+
+static inline bool compareTouchPoints(const QTouchEvent::TouchPoint &lhs,
+                                      const QTouchEvent::TouchPoint &rhs)
+{
+    // TouchPointPressed < TouchPointMoved < TouchPointReleased
+    return lhs.state() < rhs.state();
+}
+
+static uint32_t s_eventId = 0;
+class MotionEventQt : public ui::MotionEvent
+{
+public:
+    MotionEventQt(const QList<QTouchEvent::TouchPoint> &touchPoints,
+                  const base::TimeTicks &eventTime, Action action,
+                  const Qt::KeyboardModifiers modifiers, int index = -1)
+        : touchPoints(touchPoints)
+        , eventTime(eventTime)
+        , action(action)
+        , eventId(++s_eventId)
+        , flags(flagsFromModifiers(modifiers))
+        , index(index)
+    {
+        // ACTION_DOWN and ACTION_UP must be accesssed through pointer_index 0
+        Q_ASSERT((action != Action::DOWN && action != Action::UP) || index == 0);
+    }
+
+    uint32_t GetUniqueEventId() const override { return eventId; }
+    Action GetAction() const override { return action; }
+    int GetActionIndex() const override { return index; }
+    size_t GetPointerCount() const override { return touchPoints.size(); }
+    int GetPointerId(size_t pointer_index) const override
+    {
+        return touchPoints.at(pointer_index).id();
+    }
+    float GetX(size_t pointer_index) const override
+    {
+        return touchPoints.at(pointer_index).pos().x();
+    }
+    float GetY(size_t pointer_index) const override
+    {
+        return touchPoints.at(pointer_index).pos().y();
+    }
+    float GetRawX(size_t pointer_index) const override
+    {
+        return touchPoints.at(pointer_index).screenPos().x();
+    }
+    float GetRawY(size_t pointer_index) const override
+    {
+        return touchPoints.at(pointer_index).screenPos().y();
+    }
+    float GetTouchMajor(size_t pointer_index) const override
+    {
+        QSizeF diams = touchPoints.at(pointer_index).ellipseDiameters();
+        return std::max(diams.height(), diams.width());
+    }
+    float GetTouchMinor(size_t pointer_index) const override
+    {
+        QSizeF diams = touchPoints.at(pointer_index).ellipseDiameters();
+        return std::min(diams.height(), diams.width());
+    }
+    float GetOrientation(size_t pointer_index) const override { return 0; }
+    int GetFlags() const override { return flags; }
+    float GetPressure(size_t pointer_index) const override
+    {
+        return touchPoints.at(pointer_index).pressure();
+    }
+    float GetTiltX(size_t pointer_index) const override { return 0; }
+    float GetTiltY(size_t pointer_index) const override { return 0; }
+    float GetTwist(size_t) const override { return 0; }
+    float GetTangentialPressure(size_t) const override { return 0; }
+    base::TimeTicks GetEventTime() const override { return eventTime; }
+
+    size_t GetHistorySize() const override { return 0; }
+    base::TimeTicks GetHistoricalEventTime(size_t historical_index) const override
+    {
+        return base::TimeTicks();
+    }
+    float GetHistoricalTouchMajor(size_t pointer_index, size_t historical_index) const override
+    {
+        return 0;
+    }
+    float GetHistoricalX(size_t pointer_index, size_t historical_index) const override { return 0; }
+    float GetHistoricalY(size_t pointer_index, size_t historical_index) const override { return 0; }
+    ToolType GetToolType(size_t pointer_index) const override
+    {
+        return (touchPoints.at(pointer_index).flags() & QTouchEvent::TouchPoint::InfoFlag::Pen)
+                ? ui::MotionEvent::ToolType::STYLUS
+                : ui::MotionEvent::ToolType::FINGER;
+    }
+    int GetButtonState() const override { return 0; }
+
+private:
+    QList<QTouchEvent::TouchPoint> touchPoints;
+    base::TimeTicks eventTime;
+    Action action;
+    const uint32_t eventId;
+    int flags;
+    int index;
+};
+
+RenderWidgetHostViewQtDelegateClient::RenderWidgetHostViewQtDelegateClient(
+        RenderWidgetHostViewQt *rwhv)
+    : m_rwhv(rwhv)
+{
+    Q_ASSERT(rwhv);
+
+    const QPlatformInputContext *context =
+            QGuiApplicationPrivate::platformIntegration()->inputContext();
+    m_imeHasHiddenTextCapability =
+            context && context->hasCapability(QPlatformInputContext::HiddenTextCapability);
+}
+
+QSGNode *RenderWidgetHostViewQtDelegateClient::updatePaintNode(QSGNode *oldNode)
+{
+    return m_rwhv->updatePaintNode(oldNode);
+}
+
+void RenderWidgetHostViewQtDelegateClient::notifyShown()
+{
+    m_rwhv->notifyShown();
+}
+
+void RenderWidgetHostViewQtDelegateClient::notifyHidden()
+{
+    m_rwhv->notifyHidden();
+}
+
+void RenderWidgetHostViewQtDelegateClient::visualPropertiesChanged()
+{
+    RenderWidgetHostViewQtDelegate *delegate = m_rwhv->delegate();
+    if (!delegate)
+        return;
+
+    QRect oldViewRect = m_viewRectInDips;
+    m_viewRectInDips = delegate->viewGeometry().toAlignedRect();
+
+    QRect oldWindowRect = m_windowRectInDips;
+    m_windowRectInDips = delegate->windowGeometry();
+
+    bool screenInfoChanged = m_rwhv->updateScreenInfo();
+
+    if (m_viewRectInDips != oldViewRect || m_windowRectInDips != oldWindowRect)
+        m_rwhv->host()->SendScreenRects();
+
+    if (m_viewRectInDips.size() != oldViewRect.size() || screenInfoChanged)
+        m_rwhv->synchronizeVisualProperties(base::nullopt);
+}
+
+bool RenderWidgetHostViewQtDelegateClient::forwardEvent(QEvent *event)
+{
+    Q_ASSERT(m_rwhv->host()->GetView());
+
+    switch (event->type()) {
+    case QEvent::ShortcutOverride: {
+        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
+
+        auto acceptKeyOutOfInputField = [](QKeyEvent *keyEvent) -> bool {
+#ifdef Q_OS_MACOS
+            // Check if a shortcut is registered for this key sequence.
+            QKeySequence sequence = QKeySequence((keyEvent->modifiers() | keyEvent->key())
+                                                 & ~(Qt::KeypadModifier | Qt::GroupSwitchModifier));
+            if (QGuiApplicationPrivate::instance()->shortcutMap.hasShortcutForKeySequence(sequence))
+                return false;
+
+            // The following shortcuts are handled out of input field too but
+            // disabled on macOS to let the blinking menu handling to the
+            // embedder application (see kKeyboardCodeKeyDownEntries in
+            // third_party/WebKit/Source/core/editing/EditingBehavior.cpp).
+            // Let them pass on macOS to generate the corresponding edit command.
+            return keyEvent->matches(QKeySequence::Copy) || keyEvent->matches(QKeySequence::Paste)
+                    || keyEvent->matches(QKeySequence::Cut)
+                    || keyEvent->matches(QKeySequence::SelectAll);
+#else
+            return false;
+#endif
+        };
+
+        if (!inputMethodQuery(Qt::ImEnabled).toBool()
+            && !(inputMethodQuery(Qt::ImHints).toInt() & Qt::ImhHiddenText)
+            && !acceptKeyOutOfInputField(keyEvent))
+            return false;
+
+        Q_ASSERT(m_editCommand.empty());
+        if (WebEventFactory::getEditCommand(keyEvent, &m_editCommand)
+            || QInputControl::isCommonTextEditShortcut(keyEvent)) {
+            event->accept();
+            return true;
+        }
+
+        return false;
+    }
+    case QEvent::MouseButtonPress:
+        m_rwhv->Focus();
+        Q_FALLTHROUGH();
+    case QEvent::MouseButtonRelease:
+    case QEvent::MouseMove:
+        // Skip second MouseMove event when a window is being adopted, so that Chromium
+        // can properly handle further move events.
+        // Also make sure the adapter client exists to prevent a null pointer dereference,
+        // because it's possible for a QWebEnginePagePrivate (adapter) instance to be destroyed,
+        // and then the OS (observed on Windows) might still send mouse move events to a still
+        // existing popup RWHVQDW instance.
+        if (m_rwhv->adapterClient() && m_rwhv->adapterClient()->isBeingAdopted())
+            return false;
+        handleMouseEvent(static_cast<QMouseEvent *>(event));
+        break;
+    case QEvent::KeyPress:
+    case QEvent::KeyRelease:
+        handleKeyEvent(static_cast<QKeyEvent *>(event));
+        break;
+    case QEvent::Wheel:
+        m_rwhv->handleWheelEvent(static_cast<QWheelEvent *>(event));
+        break;
+    case QEvent::TouchBegin:
+        m_rwhv->Focus();
+        Q_FALLTHROUGH();
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
+    case QEvent::TouchCancel:
+        handleTouchEvent(static_cast<QTouchEvent *>(event));
+        break;
+#if QT_CONFIG(tabletevent)
+    case QEvent::TabletPress:
+        m_rwhv->Focus();
+        Q_FALLTHROUGH();
+    case QEvent::TabletRelease:
+    case QEvent::TabletMove:
+        handleTabletEvent(static_cast<QTabletEvent *>(event));
+        break;
+#endif
+#if QT_CONFIG(gestures)
+    case QEvent::NativeGesture:
+        handleGestureEvent(static_cast<QNativeGestureEvent *>(event));
+        break;
+#endif
+    case QEvent::HoverMove:
+        handleHoverEvent(static_cast<QHoverEvent *>(event));
+        break;
+    case QEvent::FocusIn:
+    case QEvent::FocusOut:
+        handleFocusEvent(static_cast<QFocusEvent *>(event));
+        break;
+    case QEvent::InputMethod:
+        handleInputMethodEvent(static_cast<QInputMethodEvent *>(event));
+        break;
+    case QEvent::InputMethodQuery:
+        handleInputMethodQueryEvent(static_cast<QInputMethodQueryEvent *>(event));
+        break;
+    case QEvent::Leave:
+#ifdef Q_OS_WIN
+        if (m_mouseButtonPressed > 0)
+            return false;
+#endif
+    case QEvent::HoverLeave:
+        m_rwhv->host()->ForwardMouseEvent(WebEventFactory::toWebMouseEvent(event));
+        break;
+    default:
+        return false;
+    }
+    return true;
+}
+
+QVariant RenderWidgetHostViewQtDelegateClient::inputMethodQuery(Qt::InputMethodQuery query)
+{
+    switch (query) {
+    case Qt::ImEnabled: {
+        ui::TextInputType type = m_rwhv->getTextInputType();
+        bool editorVisible = type != ui::TEXT_INPUT_TYPE_NONE;
+        // IME manager should disable composition on input fields with ImhHiddenText hint if
+        // supported
+        if (m_imeHasHiddenTextCapability)
+            return QVariant(editorVisible);
+
+        bool passwordInput = type == ui::TEXT_INPUT_TYPE_PASSWORD;
+        return QVariant(editorVisible && !passwordInput);
+    }
+    case Qt::ImFont:
+        // TODO: Implement this
+        return QVariant();
+    case Qt::ImCursorRectangle: {
+        if (m_rwhv->GetTextInputManager()) {
+            if (auto *region = m_rwhv->GetTextInputManager()->GetSelectionRegion()) {
+                if (region->focus.GetHeight() > 0) {
+                    gfx::Rect caretRect =
+                            gfx::RectBetweenSelectionBounds(region->anchor, region->focus);
+                    if (caretRect.width() == 0)
+                        caretRect.set_width(1); // IME API on Windows expects a width > 0
+                    return toQt(caretRect);
+                }
+            }
+        }
+        return QVariant();
+    }
+    case Qt::ImCursorPosition:
+        return m_cursorPosition;
+    case Qt::ImAnchorPosition:
+        return m_rwhv->GetSelectedText().empty() ? m_cursorPosition
+                                                 : m_anchorPositionWithinSelection;
+    case Qt::ImSurroundingText:
+        return m_surroundingText;
+    case Qt::ImCurrentSelection:
+        return toQt(m_rwhv->GetSelectedText());
+    case Qt::ImMaximumTextLength:
+        // TODO: Implement this
+        return QVariant(); // No limit.
+    case Qt::ImHints:
+#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
+        return int(toQtInputMethodHints(m_rwhv->getTextInputType()) | Qt::ImhNoPredictiveText
+                   | Qt::ImhNoTextHandles | Qt::ImhNoEditMenu);
+#else
+        return int(toQtInputMethodHints(m_rwhv->getTextInputType()) | Qt::ImhNoPredictiveText);
+#endif
+    default:
+        return QVariant();
+    }
+}
+
+void RenderWidgetHostViewQtDelegateClient::closePopup()
+{
+    // We notify the popup to be closed by telling it that it lost focus. WebKit does the rest
+    // (hiding the widget and automatic memory cleanup via
+    // RenderWidget::CloseWidgetSoon() -> RenderWidgetHostImpl::ShutdownAndDestroyWidget(true).
+    m_rwhv->host()->SetActive(false);
+    m_rwhv->host()->LostFocus();
+}
+
+template<class T>
+void RenderWidgetHostViewQtDelegateClient::handlePointerEvent(T *event)
+{
+    // Currently WebMouseEvent is a subclass of WebPointerProperties, so basically
+    // tablet events are mouse events with extra properties.
+    blink::WebMouseEvent webEvent = WebEventFactory::toWebMouseEvent(event);
+    if ((webEvent.GetType() == blink::WebInputEvent::kMouseDown
+         || webEvent.GetType() == blink::WebInputEvent::kMouseUp)
+        && webEvent.button == blink::WebMouseEvent::Button::kNoButton) {
+        // Blink can only handle the 3 main mouse-buttons and may assert when processing mouse-down
+        // for no button.
+        LOG(INFO) << "Unhandled mouse button";
+        return;
+    }
+
+    if (webEvent.GetType() == blink::WebInputEvent::kMouseDown) {
+        if (event->button() != m_clickHelper.lastPressButton
+            || (event->timestamp() - m_clickHelper.lastPressTimestamp
+                > static_cast<ulong>(qGuiApp->styleHints()->mouseDoubleClickInterval()))
+            || (event->pos() - m_clickHelper.lastPressPosition).manhattanLength()
+                    > qGuiApp->styleHints()->startDragDistance()
+            || m_clickHelper.clickCounter >= 3)
+            m_clickHelper.clickCounter = 0;
+
+        m_clickHelper.lastPressTimestamp = event->timestamp();
+        webEvent.click_count = ++m_clickHelper.clickCounter;
+        m_clickHelper.lastPressButton = event->button();
+        m_clickHelper.lastPressPosition = QPointF(event->pos()).toPoint();
+    }
+
+    webEvent.movement_x = event->globalX() - m_previousMousePosition.x();
+    webEvent.movement_y = event->globalY() - m_previousMousePosition.y();
+
+    if (m_rwhv->IsMouseLocked())
+        QCursor::setPos(m_previousMousePosition);
+    else
+        m_previousMousePosition = event->globalPos();
+
+    if (m_imeInProgress && webEvent.GetType() == blink::WebInputEvent::kMouseDown) {
+        m_imeInProgress = false;
+        // Tell input method to commit the pre-edit string entered so far, and finish the
+        // composition operation.
+#ifdef Q_OS_WIN
+        // Yes the function name is counter-intuitive, but commit isn't actually implemented
+        // by the Windows QPA, and reset does exactly what is necessary in this case.
+        qApp->inputMethod()->reset();
+#else
+        qApp->inputMethod()->commit();
+#endif
+    }
+
+    m_rwhv->host()->ForwardMouseEvent(webEvent);
+}
+
+void RenderWidgetHostViewQtDelegateClient::handleMouseEvent(QMouseEvent *event)
+{
+    if (event->type() == QEvent::MouseButtonPress)
+        m_mouseButtonPressed++;
+    if (event->type() == QEvent::MouseButtonRelease)
+        m_mouseButtonPressed--;
+
+    // Don't forward mouse events synthesized by the system, which are caused by genuine touch
+    // events. Chromium would then process for e.g. a mouse click handler twice, once due to the
+    // system synthesized mouse event, and another time due to a touch-to-gesture-to-mouse
+    // transformation done by Chromium.
+    if (event->source() == Qt::MouseEventSynthesizedBySystem)
+        return;
+    handlePointerEvent<QMouseEvent>(event);
+}
+
+void RenderWidgetHostViewQtDelegateClient::handleKeyEvent(QKeyEvent *event)
+{
+    if (m_rwhv->IsMouseLocked() && event->key() == Qt::Key_Escape
+        && event->type() == QEvent::KeyRelease)
+        m_rwhv->UnlockMouse();
+
+    if (m_receivedEmptyImeEvent) {
+        // IME composition was not finished with a valid commit string.
+        // We're getting the composition result in a key event.
+        if (event->key() != 0) {
+            // The key event is not a result of an IME composition. Cancel IME.
+            m_rwhv->host()->ImeCancelComposition();
+            m_receivedEmptyImeEvent = false;
+        } else {
+            if (event->type() == QEvent::KeyRelease) {
+                m_rwhv->host()->ImeCommitText(toString16(event->text()),
+                                              std::vector<ui::ImeTextSpan>(),
+                                              gfx::Range::InvalidRange(), 0);
+                m_receivedEmptyImeEvent = false;
+                m_imeInProgress = false;
+            }
+            return;
+        }
+    }
+
+    // Ignore autorepeating KeyRelease events so that the generated web events
+    // conform to the spec, which requires autorepeat to result in a sequence of
+    // keypress events and only one final keyup event:
+    // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Auto-repeat_handling
+    // https://w3c.github.io/uievents/#dom-keyboardevent-repeat
+    if (event->type() == QEvent::KeyRelease && event->isAutoRepeat())
+        return;
+
+    content::NativeWebKeyboardEvent webEvent = WebEventFactory::toWebKeyboardEvent(event);
+    if (webEvent.GetType() == blink::WebInputEvent::kRawKeyDown && !m_editCommand.empty()) {
+        ui::LatencyInfo latency;
+        latency.set_source_event_type(ui::SourceEventType::KEY_PRESS);
+        content::EditCommands commands;
+        commands.emplace_back(m_editCommand, "");
+        m_editCommand.clear();
+        m_rwhv->host()->ForwardKeyboardEventWithCommands(webEvent, latency, &commands, nullptr);
+        return;
+    }
+
+    bool keyDownTextInsertion =
+            webEvent.GetType() == blink::WebInputEvent::kRawKeyDown && webEvent.text[0];
+    webEvent.skip_in_browser = keyDownTextInsertion;
+    m_rwhv->host()->ForwardKeyboardEvent(webEvent);
+
+    if (keyDownTextInsertion) {
+        // Blink won't consume the RawKeyDown, but rather the Char event in this case.
+        // The RawKeyDown is skipped on the way back (see above).
+        // The same os_event will be set on both NativeWebKeyboardEvents.
+        webEvent.skip_in_browser = false;
+        webEvent.SetType(blink::WebInputEvent::kChar);
+        m_rwhv->host()->ForwardKeyboardEvent(webEvent);
+    }
+}
+
+void RenderWidgetHostViewQtDelegateClient::handleTouchEvent(QTouchEvent *event)
+{
+    // On macOS instead of handling touch events, we use the OS provided QNativeGestureEvents.
+#ifdef Q_OS_MACOS
+    if (event->spontaneous()) {
+        return;
+    } else {
+        VLOG(1) << "Sending simulated touch events to Chromium does not work properly on macOS. "
+                   "Consider using QNativeGestureEvents or QMouseEvents.";
+    }
+#endif
+
+    // Chromium expects the touch event timestamps to be comparable to base::TimeTicks::Now().
+    // Most importantly we also have to preserve the relative time distance between events.
+    // Calculate a delta between event timestamps and Now() on the first received event, and
+    // apply this delta to all successive events. This delta is most likely smaller than it
+    // should by calculating it here but this will hopefully cause less than one frame of delay.
+    base::TimeTicks eventTimestamp =
+            base::TimeTicks() + base::TimeDelta::FromMilliseconds(event->timestamp());
+    static base::TimeDelta eventsToNowDelta = base::TimeTicks::Now() - eventTimestamp;
+    eventTimestamp += eventsToNowDelta;
+
+    QList<QTouchEvent::TouchPoint> touchPoints = mapTouchPointIds(event->touchPoints());
+    // Make sure that ACTION_POINTER_DOWN is delivered before ACTION_MOVE,
+    // and ACTION_MOVE before ACTION_POINTER_UP.
+    std::sort(touchPoints.begin(), touchPoints.end(), compareTouchPoints);
+
+    // Check first if the touch event should be routed to the selectionController
+    if (!touchPoints.isEmpty()) {
+        ui::MotionEvent::Action action;
+        switch (touchPoints[0].state()) {
+        case Qt::TouchPointPressed:
+            action = ui::MotionEvent::Action::DOWN;
+            break;
+        case Qt::TouchPointMoved:
+            action = ui::MotionEvent::Action::MOVE;
+            break;
+        case Qt::TouchPointReleased:
+            action = ui::MotionEvent::Action::UP;
+            break;
+        default:
+            action = ui::MotionEvent::Action::NONE;
+            break;
+        }
+
+        MotionEventQt motionEvent(touchPoints, eventTimestamp, action, event->modifiers(), 0);
+        if (m_rwhv->getTouchSelectionController()->WillHandleTouchEvent(motionEvent)) {
+            m_previousTouchPoints = touchPoints;
+            event->accept();
+            return;
+        }
+    } else {
+        // An empty touchPoints always corresponds to a TouchCancel event.
+        // We can't forward touch cancellations without a previously processed touch event,
+        // as Chromium expects the previous touchPoints for Action::CANCEL.
+        // If both are empty that means the TouchCancel was sent without an ongoing touch,
+        // so there's nothing to cancel anyway.
+        touchPoints = m_previousTouchPoints;
+        if (touchPoints.isEmpty())
+            return;
+
+        MotionEventQt cancelEvent(touchPoints, eventTimestamp, ui::MotionEvent::Action::CANCEL,
+                                  event->modifiers());
+        if (m_rwhv->getTouchSelectionController()->WillHandleTouchEvent(cancelEvent)) {
+            m_previousTouchPoints.clear();
+            event->accept();
+            return;
+        }
+    }
+
+    switch (event->type()) {
+    case QEvent::TouchBegin:
+        m_sendMotionActionDown = true;
+        m_touchMotionStarted = true;
+        m_rwhv->getTouchSelectionControllerClient()->onTouchDown();
+        break;
+    case QEvent::TouchUpdate:
+        m_touchMotionStarted = true;
+        break;
+    case QEvent::TouchCancel: {
+        // Only process TouchCancel events received following a TouchBegin or TouchUpdate event
+        if (m_touchMotionStarted) {
+            MotionEventQt cancelEvent(touchPoints, eventTimestamp, ui::MotionEvent::Action::CANCEL,
+                                      event->modifiers());
+            m_rwhv->processMotionEvent(cancelEvent);
+        }
+
+        clearPreviousTouchMotionState();
+        return;
+    }
+    case QEvent::TouchEnd:
+        clearPreviousTouchMotionState();
+        m_rwhv->getTouchSelectionControllerClient()->onTouchUp();
+        break;
+    default:
+        break;
+    }
+
+    if (m_imeInProgress && event->type() == QEvent::TouchBegin) {
+        m_imeInProgress = false;
+        // Tell input method to commit the pre-edit string entered so far, and finish the
+        // composition operation.
+#ifdef Q_OS_WIN
+        // Yes the function name is counter-intuitive, but commit isn't actually implemented
+        // by the Windows QPA, and reset does exactly what is necessary in this case.
+        qApp->inputMethod()->reset();
+#else
+        qApp->inputMethod()->commit();
+#endif
+    }
+
+    for (int i = 0; i < touchPoints.size(); ++i) {
+        ui::MotionEvent::Action action;
+        switch (touchPoints[i].state()) {
+        case Qt::TouchPointPressed:
+            if (m_sendMotionActionDown) {
+                action = ui::MotionEvent::Action::DOWN;
+                m_sendMotionActionDown = false;
+            } else {
+                action = ui::MotionEvent::Action::POINTER_DOWN;
+            }
+            break;
+        case Qt::TouchPointMoved:
+            action = ui::MotionEvent::Action::MOVE;
+            break;
+        case Qt::TouchPointReleased:
+            action = touchPoints.size() > 1 ? ui::MotionEvent::Action::POINTER_UP
+                                            : ui::MotionEvent::Action::UP;
+            break;
+        default:
+            // Ignore Qt::TouchPointStationary
+            continue;
+        }
+
+        MotionEventQt motionEvent(touchPoints, eventTimestamp, action, event->modifiers(), i);
+        m_rwhv->processMotionEvent(motionEvent);
+    }
+
+    m_previousTouchPoints = touchPoints;
+}
+
+#if QT_CONFIG(tabletevent)
+void RenderWidgetHostViewQtDelegateClient::handleTabletEvent(QTabletEvent *event)
+{
+    handlePointerEvent<QTabletEvent>(event);
+}
+#endif
+
+#if QT_CONFIG(gestures)
+void RenderWidgetHostViewQtDelegateClient::handleGestureEvent(QNativeGestureEvent *event)
+{
+    const Qt::NativeGestureType type = event->gestureType();
+    // These are the only supported gestures by Chromium so far.
+    if (type == Qt::ZoomNativeGesture || type == Qt::SmartZoomNativeGesture) {
+        m_rwhv->host()->ForwardGestureEvent(WebEventFactory::toWebGestureEvent(event));
+    }
+}
+#endif
+
+void RenderWidgetHostViewQtDelegateClient::handleHoverEvent(QHoverEvent *event)
+{
+    m_rwhv->host()->ForwardMouseEvent(WebEventFactory::toWebMouseEvent(event));
+}
+
+void RenderWidgetHostViewQtDelegateClient::handleFocusEvent(QFocusEvent *event)
+{
+    if (event->gotFocus()) {
+        m_rwhv->host()->GotFocus();
+        m_rwhv->host()->SetActive(true);
+        content::RenderViewHostImpl *rvh = content::RenderViewHostImpl::From(m_rwhv->host());
+        Q_ASSERT(rvh);
+        if (event->reason() == Qt::TabFocusReason)
+            rvh->SetInitialFocus(false);
+        else if (event->reason() == Qt::BacktabFocusReason)
+            rvh->SetInitialFocus(true);
+        event->accept();
+
+        m_rwhv->adapterClient()->webContentsAdapter()->handlePendingMouseLockPermission();
+    } else if (event->lostFocus()) {
+        m_rwhv->host()->SetActive(false);
+        m_rwhv->host()->LostFocus();
+        event->accept();
+    }
+}
+
+void RenderWidgetHostViewQtDelegateClient::handleInputMethodEvent(QInputMethodEvent *event)
+{
+    m_rwhv->resetInputManagerState();
+
+    if (!m_rwhv->host())
+        return;
+
+    QString commitString = event->commitString();
+    QString preeditString = event->preeditString();
+
+    int cursorPositionInPreeditString = -1;
+    gfx::Range selectionRange = gfx::Range::InvalidRange();
+
+    const QList<QInputMethodEvent::Attribute> &attributes = event->attributes();
+    std::vector<ui::ImeTextSpan> underlines;
+    bool hasSelection = false;
+
+    for (const auto &attribute : attributes) {
+        switch (attribute.type) {
+        case QInputMethodEvent::TextFormat: {
+            if (preeditString.isEmpty())
+                break;
+
+            int start = qMin(attribute.start, (attribute.start + attribute.length));
+            int end = qMax(attribute.start, (attribute.start + attribute.length));
+
+            // Blink does not support negative position values. Adjust start and end positions
+            // to non-negative values.
+            if (start < 0) {
+                start = 0;
+                end = qMax(0, start + end);
+            }
+
+            underlines.push_back(ui::ImeTextSpan(ui::ImeTextSpan::Type::kComposition, start, end,
+                                                 ui::ImeTextSpan::Thickness::kThin,
+                                                 SK_ColorTRANSPARENT));
+
+            QTextCharFormat format = qvariant_cast<QTextFormat>(attribute.value).toCharFormat();
+            if (format.underlineStyle() != QTextCharFormat::NoUnderline)
+                underlines.back().underline_color = toSk(format.underlineColor());
+
+            break;
+        }
+        case QInputMethodEvent::Cursor:
+            // Always set the position of the cursor, even if it's marked invisible by Qt, otherwise
+            // there is no way the user will know which part of the composition string will be
+            // changed, when performing an IME-specific action (like selecting a different word
+            // suggestion).
+            cursorPositionInPreeditString = attribute.start;
+            break;
+        case QInputMethodEvent::Selection:
+            hasSelection = true;
+
+            // Cancel IME composition
+            if (preeditString.isEmpty() && attribute.start + attribute.length == 0) {
+                selectionRange.set_start(0);
+                selectionRange.set_end(0);
+                break;
+            }
+
+            selectionRange.set_start(qMin(attribute.start, (attribute.start + attribute.length)));
+            selectionRange.set_end(qMax(attribute.start, (attribute.start + attribute.length)));
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (!selectionRange.IsValid()) {
+        // We did not receive a valid selection range, hence the range is going to mark the
+        // cursor position.
+        int newCursorPosition = (cursorPositionInPreeditString < 0) ? preeditString.length()
+                                                                    : cursorPositionInPreeditString;
+        selectionRange.set_start(newCursorPosition);
+        selectionRange.set_end(newCursorPosition);
+    }
+
+    if (hasSelection) {
+        content::mojom::FrameInputHandler *frameInputHandler = m_rwhv->getFrameInputHandler();
+        if (frameInputHandler)
+            frameInputHandler->SetEditableSelectionOffsets(selectionRange.start(),
+                                                           selectionRange.end());
+    }
+
+    int replacementLength = event->replacementLength();
+    gfx::Range replacementRange = gfx::Range::InvalidRange();
+
+    if (replacementLength > 0) {
+        int replacementStart = event->replacementStart() < 0
+                ? m_cursorPosition + event->replacementStart()
+                : event->replacementStart();
+        if (replacementStart >= 0 && replacementStart < m_surroundingText.length())
+            replacementRange = gfx::Range(replacementStart, replacementStart + replacementLength);
+    }
+
+    // There are so-far two known cases, when an empty QInputMethodEvent is received.
+    // First one happens when backspace is used to remove the last character in the pre-edit
+    // string, thus signaling the end of the composition.
+    // The second one happens (on Windows) when a Korean char gets composed, but instead of
+    // the event having a commit string, both strings are empty, and the actual char is received
+    // as a QKeyEvent after the QInputMethodEvent is processed.
+    // In lieu of the second case, we can't simply cancel the composition on an empty event,
+    // and then add the Korean char when QKeyEvent is received, because that leads to text
+    // flickering in the textarea (or any other element).
+    // Instead we postpone the processing of the empty QInputMethodEvent by posting it
+    // to the same focused object, and cancelling the composition on the next event loop tick.
+    if (commitString.isEmpty() && preeditString.isEmpty() && replacementLength == 0) {
+        if (!m_receivedEmptyImeEvent && m_imeInProgress && !hasSelection) {
+            m_receivedEmptyImeEvent = true;
+            QInputMethodEvent *eventCopy = new QInputMethodEvent(*event);
+            QGuiApplication::postEvent(qApp->focusObject(), eventCopy);
+        } else {
+            m_receivedEmptyImeEvent = false;
+            if (m_imeInProgress) {
+                m_imeInProgress = false;
+                m_rwhv->host()->ImeCancelComposition();
+            }
+        }
+
+        return;
+    }
+
+    m_receivedEmptyImeEvent = false;
+
+    // Finish compostion: insert or erase text.
+    if (!commitString.isEmpty() || replacementLength > 0) {
+        m_rwhv->host()->ImeCommitText(toString16(commitString), underlines, replacementRange, 0);
+        m_imeInProgress = false;
+    }
+
+    // Update or start new composition.
+    // Be aware of that, we might get a commit string and a pre-edit string in a single event and
+    // this means a new composition.
+    if (!preeditString.isEmpty()) {
+        m_rwhv->host()->ImeSetComposition(toString16(preeditString), underlines, replacementRange,
+                                          selectionRange.start(), selectionRange.end());
+        m_imeInProgress = true;
+    }
+}
+
+void RenderWidgetHostViewQtDelegateClient::handleInputMethodQueryEvent(
+        QInputMethodQueryEvent *event)
+{
+    Qt::InputMethodQueries queries = event->queries();
+    for (uint i = 0; i < 32; ++i) {
+        Qt::InputMethodQuery query = (Qt::InputMethodQuery)(int)(queries & (1 << i));
+        if (query) {
+            QVariant v = inputMethodQuery(query);
+            event->setValue(query, v);
+        }
+    }
+    event->accept();
+}
+
+void RenderWidgetHostViewQtDelegateClient::clearPreviousTouchMotionState()
+{
+    m_previousTouchPoints.clear();
+    m_touchMotionStarted = false;
+}
+
+void RenderWidgetHostViewQtDelegateClient::selectionChanged()
+{
+    m_rwhv->resetInputManagerState();
+    ui::TextInputType type = m_rwhv->getTextInputType();
+    content::TextInputManager *text_input_manager = m_rwhv->GetTextInputManager();
+
+    // Handle text selection out of an input field
+    if (type == ui::TEXT_INPUT_TYPE_NONE) {
+        if (m_rwhv->GetSelectedText().empty() && m_emptyPreviousSelection)
+            return;
+
+        // Reset position values to emit selectionChanged signal when clearing text selection
+        // by clicking into an input field. These values are intended to be used by inputMethodQuery
+        // so they are not expected to be valid when selection is out of an input field.
+        m_anchorPositionWithinSelection = -1;
+        m_cursorPositionWithinSelection = -1;
+
+        m_emptyPreviousSelection = m_rwhv->GetSelectedText().empty();
+        m_rwhv->adapterClient()->selectionChanged();
+        return;
+    }
+
+    if (m_rwhv->GetSelectedText().empty()) {
+        // RenderWidgetHostViewQt::OnUpdateTextInputStateCalled() does not update the cursor
+        // position if the selection is cleared because TextInputState changes before the
+        // TextSelection change.
+        Q_ASSERT(text_input_manager->GetTextInputState());
+        m_cursorPosition = text_input_manager->GetTextInputState()->selection_start;
+        m_rwhv->delegate()->inputMethodStateChanged(true /*editorVisible*/,
+                                                    type == ui::TEXT_INPUT_TYPE_PASSWORD);
+
+        m_anchorPositionWithinSelection = m_cursorPosition;
+        m_cursorPositionWithinSelection = m_cursorPosition;
+
+        if (!m_emptyPreviousSelection) {
+            m_emptyPreviousSelection = true;
+            m_rwhv->adapterClient()->selectionChanged();
+        }
+
+        return;
+    }
+
+    const content::TextInputManager::TextSelection *selection =
+            text_input_manager->GetTextSelection();
+    if (!selection)
+        return;
+
+    if (!selection->range().IsValid())
+        return;
+
+    int newAnchorPositionWithinSelection = 0;
+    int newCursorPositionWithinSelection = 0;
+
+    if (text_input_manager->GetSelectionRegion()->anchor.type() == gfx::SelectionBound::RIGHT) {
+        newAnchorPositionWithinSelection = selection->range().GetMax() - selection->offset();
+        newCursorPositionWithinSelection = selection->range().GetMin() - selection->offset();
+    } else {
+        newAnchorPositionWithinSelection = selection->range().GetMin() - selection->offset();
+        newCursorPositionWithinSelection = selection->range().GetMax() - selection->offset();
+    }
+
+    if (m_anchorPositionWithinSelection == newAnchorPositionWithinSelection
+        && m_cursorPositionWithinSelection == newCursorPositionWithinSelection) {
+        return;
+    }
+
+    m_anchorPositionWithinSelection = newAnchorPositionWithinSelection;
+    m_cursorPositionWithinSelection = newCursorPositionWithinSelection;
+
+    if (!selection->selected_text().empty())
+        m_cursorPosition = newCursorPositionWithinSelection;
+
+    m_emptyPreviousSelection = selection->selected_text().empty();
+    m_rwhv->delegate()->inputMethodStateChanged(true /*editorVisible*/,
+                                                type == ui::TEXT_INPUT_TYPE_PASSWORD);
+    m_rwhv->adapterClient()->selectionChanged();
+}
+
+} // namespace QtWebEngineCore