Unstrangle unhandled key event callback for webview

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 286 matching lines @@
     , m_mouseDownTimestamp(0)
     , m_touchPressed(false)
     , m_preventMouseEventForPointerTypeMouse(false)
     , m_inPointerCanceledState(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
+    , m_overrideNextKeyupEvent(false)
+    , m_returnValueForNextKeyupEvent(false)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
@@ skipping 2826 matching lines @@
     String key = evt.unmodifiedText();
     Element* elem = m_frame->document()->getElementByAccessKey(key.lower());
     if (!elem)
         return false;
     elem->accessKeyAction(false);
     return true;
 }
 
 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);
 
     if (initialKeyEvent.windowsVirtualKeyCode() == VK_CAPITAL)
         capsLockStateMayHaveChanged();
 
 #if OS(WIN)
     if (panScrollInProgress()) {
         // If a key is pressed while the panScroll is in progress then we want to stop
         if (initialKeyEvent.type() == PlatformEvent::KeyDown || initialKeyEvent.type() == PlatformEvent::RawKeyDown)
@@ skipping 14 matching lines @@
 
     // In IE, access keys are special, they are handled after default keydown processing, but cannot be canceled - this is hard to match.
     // On Mac OS X, we process them before dispatching keydown, as the default keydown handler implements Emacs key bindings, which may conflict
     // with access keys. Then we dispatch keydown, but suppress its default handling.
     // On Windows, WebKit explicitly calls handleAccessKey() instead of dispatching a keypress event for WM_SYSCHAR messages.
     // Other platforms currently match either Mac or Windows behavior, depending on whether they send combined KeyDown events.
     bool matchedAnAccessKey = false;
     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)
         keyDownEvent.disambiguateKeyDownEvent(PlatformEvent::RawKeyDown);
     RefPtrWillBeRawPtr<KeyboardEvent> keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->domWindow());
     if (matchedAnAccessKey)
         keydown->setDefaultPrevented(true);
     keydown->setTarget(node);
 
     if (initialKeyEvent.type() == PlatformEvent::RawKeyDown) {
         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);
     // If frame changed as a result of keydown dispatch, then return early to avoid sending a subsequent keypress message to the new frame.
     bool changedFocusedFrame = m_frame->page() && m_frame != m_frame->page()->focusController().focusedOrMainFrame();
     bool keydownResult = keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
     if (keydownResult)
         return keydownResult;
 
     // Focus may have changed during keydown handling, so refetch node.
@@ skipping 874 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink