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 30 matching lines @@
 
 } // namespace
 
 KeyboardEventManager::KeyboardEventManager(
     LocalFrame* frame, ScrollManager* scrollManager)
 : m_frame(frame)
 , m_scrollManager(scrollManager)
 {
 }
 
-KeyboardEventManager::~KeyboardEventManager()
-{
-}
-
 bool KeyboardEventManager::handleAccessKey(const WebKeyboardEvent& evt)
 {
     // FIXME: Ignoring the state of Shift key is what neither IE nor Firefox do.
     // IE matches lower and upper case access keys regardless of Shift key state - but if both upper and
     // lower case variants are present in a document, the correct element is matched based on Shift key state.
     // Firefox only matches an access key if Shift is not pressed, and does that case-insensitively.
     DCHECK(!(kAccessKeyModifiers & WebInputEvent::ShiftKey));
     if ((evt.modifiers & (WebKeyboardEvent::KeyModifiers & ~WebInputEvent::ShiftKey)) != kAccessKeyModifiers)
         return false;
     String key = String(evt.unmodifiedText);
@@ skipping 37 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 125 matching lines @@
 
 void KeyboardEventManager::defaultEscapeEventHandler(KeyboardEvent* event)
 {
     if (HTMLDialogElement* dialog = m_frame->document()->activeModalDialog())
         dialog->dispatchEvent(Event::createCancelable(EventTypeNames::cancel));
 }
 
 DEFINE_TRACE(KeyboardEventManager)
 {
     visitor->trace(m_frame);
+    visitor->trace(m_scrollManager);
 }
 
 static OverrideCapsLockState s_overrideCapsLockState;
 
 void KeyboardEventManager::setCurrentCapsLockState(OverrideCapsLockState state) { s_overrideCapsLockState = state; }
 
 bool KeyboardEventManager::currentCapsLockState()
 {
     switch (s_overrideCapsLockState) {
     case OverrideCapsLockState::Default:
@@ skipping 35 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