Create MouseEventManager and EventHandlingUtil

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "KeyboardEventManager.h"
 
 #include "core/dom/Element.h"
 #include "core/editing/Editor.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/html/HTMLDialogElement.h"
-#include "core/input/EventHandler.h"
+#include "core/input/EventHandlingUtil.h"
+#include "core/input/ScrollManager.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTextControlSingleLine.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/SpatialNavigation.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/WindowsKeyboardCodes.h"
 #include "public/platform/WebInputEvent.h"
@@ skipping 91 matching lines @@
     // 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 == WebInputEvent::KeyDown)
         matchedAnAccessKey = handleAccessKey(initialKeyEvent);
 
     // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
     if (initialKeyEvent.type == WebInputEvent::KeyUp || initialKeyEvent.type == WebInputEvent::Char) {
         KeyboardEvent* domEvent = KeyboardEvent::create(initialKeyEvent, m_frame->document()->domWindow());
 
-        return EventHandler::toWebInputEventResult(node->dispatchEvent(domEvent));
+        return EventHandlingUtil::toWebInputEventResult(node->dispatchEvent(domEvent));
     }
 
     WebKeyboardEvent keyDownEvent = initialKeyEvent;
     if (keyDownEvent.type != WebInputEvent::RawKeyDown)
         keyDownEvent.type = WebInputEvent::RawKeyDown;
     KeyboardEvent* keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->domWindow());
     if (matchedAnAccessKey)
         keydown->setDefaultPrevented(true);
     keydown->setTarget(node);
 
     DispatchEventResult dispatchResult = node->dispatchEvent(keydown);
     if (dispatchResult != DispatchEventResult::NotCanceled)
-        return EventHandler::toWebInputEventResult(dispatchResult);
+        return EventHandlingUtil::toWebInputEventResult(dispatchResult);
     // 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();
     if (changedFocusedFrame)
         return WebInputEventResult::HandledSystem;
 
     if (initialKeyEvent.type == WebInputEvent::RawKeyDown)
         return WebInputEventResult::NotHandled;
 
     // Focus may have changed during keydown handling, so refetch node.
     // But if we are dispatching a fake backward compatibility keypress, then we pretend that the keypress happened on the original node.
@@ skipping 10 matching lines @@
         return WebInputEventResult::NotHandled;
     }
 #endif
 
     WebKeyboardEvent keyPressEvent = initialKeyEvent;
     keyPressEvent.type = WebInputEvent::Char;
     if (keyPressEvent.text[0] == 0)
         return WebInputEventResult::NotHandled;
     KeyboardEvent* keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->domWindow());
     keypress->setTarget(node);
-    return EventHandler::toWebInputEventResult(node->dispatchEvent(keypress));
+    return EventHandlingUtil::toWebInputEventResult(node->dispatchEvent(keypress));
 }
 
 void KeyboardEventManager::capsLockStateMayHaveChanged()
 {
     if (Element* element = m_frame->document()->focusedElement()) {
         if (LayoutObject* r = element->layoutObject()) {
             if (r->isTextField())
                 toLayoutTextControlSingleLine(r)->capsLockStateMayHaveChanged();
         }
     }
@@ skipping 180 matching lines @@
     if (currentModifiers & ::cmdKey)
         modifiers |= WebInputEvent::MetaKey;
 #else
     // TODO(crbug.com/538289): Implement on other platforms.
     return static_cast<WebInputEvent::Modifiers>(0);
 #endif
     return static_cast<WebInputEvent::Modifiers>(modifiers);
 }
 
 } // namespace blink