Unstrangle unhandled key event callback for webview

third_party/WebKit/Source/core/input/EventHandler.cpp

Index: third_party/WebKit/Source/core/input/EventHandler.cpp
diff --git a/third_party/WebKit/Source/core/input/EventHandler.cpp b/third_party/WebKit/Source/core/input/EventHandler.cpp
index 898e7d53aeac75f92ae1735d289de4cfb5aceade..29c4de12caaaff98df42f60c776190d248a33d6a 100644
--- a/third_party/WebKit/Source/core/input/EventHandler.cpp
+++ b/third_party/WebKit/Source/core/input/EventHandler.cpp
@@ -304,6 +304,8 @@ EventHandler::EventHandler(LocalFrame* frame)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
+    , m_overrideNextKeyupEvent(false)
+    , m_returnValueForNextKeyupEvent(false)
 {
 }
 
@@ -3150,6 +3152,24 @@ bool EventHandler::handleAccessKey(const PlatformKeyboardEvent& evt)
 
 bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
 {
+    bool overrideKeyupEvent = false;

[dtapuska, 2015/12/02 14:25:12]

Not every keyup corresponds to a keydown.
Ctrl-Tab
Alt-Tab
Drag and Drop when the key modifiers go up.

Switching the application and changing the focus with the mouse.

Are we certain these events are covered and the right result code is returned? I
don't care for tracking state
based on previous events when possible because these valid streams of events are
typically thought to be invalid.

+    bool returnValueForKeyupEvent = false;
+    switch (initialKeyEvent.type()) {
+    case PlatformEvent::KeyUp:
+        overrideKeyupEvent = m_overrideNextKeyupEvent;
+        returnValueForKeyupEvent = m_returnValueForNextKeyupEvent;
+        m_returnValueForNextKeyupEvent = false;
+        m_overrideNextKeyupEvent = false;
+        break;
+    case PlatformEvent::RawKeyDown:
+    case PlatformEvent::KeyDown:
+        m_returnValueForNextKeyupEvent = false;
+        m_overrideNextKeyupEvent = false;
+        break;
+    default:
+        break;
+    }
+
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
     m_frame->chromeClient().setToolTip(String(), LTR);
 
@@ -3184,9 +3204,18 @@ bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
     if (initialKeyEvent.type() == PlatformEvent::KeyDown)
         matchedAnAccessKey = handleAccessKey(initialKeyEvent);
 
-    // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
-    if (initialKeyEvent.type() == PlatformEvent::KeyUp || initialKeyEvent.type() == PlatformEvent::Char)
-        return !node->dispatchKeyEvent(initialKeyEvent);
+    if (initialKeyEvent.type() == PlatformEvent::Char) {
+        bool result = !node->dispatchKeyEvent(initialKeyEvent);
+        if (m_overrideNextKeyupEvent) {
+            m_returnValueForNextKeyupEvent |= result;
+        }
+        return result;
+    }
+
+    if (initialKeyEvent.type() == PlatformEvent::KeyUp) {
+        bool result = !node->dispatchKeyEvent(initialKeyEvent);
+        return overrideKeyupEvent ? returnValueForKeyupEvent : result;
+    }
 
     PlatformKeyboardEvent keyDownEvent = initialKeyEvent;
     if (keyDownEvent.type() != PlatformEvent::RawKeyDown)
@@ -3200,7 +3229,12 @@ bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
         node->dispatchEvent(keydown);
         // If frame changed as a result of keydown dispatch, then return true to avoid sending a subsequent keypress message to the new frame.
         bool changedFocusedFrame = m_frame->page() && m_frame != m_frame->page()->focusController().focusedOrMainFrame();
-        return keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
+        bool result = keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
+        // We are returning a value that may be different from the return value of dispatchEvent().
+        // We should return the same value for the next keyup event.
+        m_overrideNextKeyupEvent = true;
+        m_returnValueForNextKeyupEvent = result;
+        return result;
     }
 
     node->dispatchEvent(keydown);