reflow comments in core/input

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"
@@ skipping 45 matching lines @@
                                            ScrollManager* scrollManager)
     : m_frame(frame), m_scrollManager(scrollManager) {}
 
 DEFINE_TRACE(KeyboardEventManager) {
   visitor->trace(m_frame);
   visitor->trace(m_scrollManager);
 }
 
 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.
+  // 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);
   Element* elem = m_frame->document()->getElementByAccessKey(key.lower());
   if (!elem)
     return false;
   elem->accessKeyAction(false);
   return true;
 }
 
 WebInputEventResult KeyboardEventManager::keyEvent(
     const WebKeyboardEvent& initialKeyEvent) {
   m_frame->chromeClient().clearToolTip(*m_frame);
 
   if (initialKeyEvent.windowsKeyCode == VK_CAPITAL)
     capsLockStateMayHaveChanged();
 
   if (m_scrollManager->middleClickAutoscrollInProgress()) {
     DCHECK(RuntimeEnabledFeatures::middleClickAutoscrollEnabled());
-    // If a key is pressed while the middleClickAutoscroll is in progress then we want to stop
+    // If a key is pressed while the middleClickAutoscroll is in progress then
+    // we want to stop.
     if (initialKeyEvent.type == WebInputEvent::KeyDown ||
         initialKeyEvent.type == WebInputEvent::RawKeyDown)
       m_scrollManager->stopAutoscroll();
 
     // If we were in panscroll mode, we swallow the key event
     return WebInputEventResult::HandledSuppressed;
   }
 
-  // Check for cases where we are too early for events -- possible unmatched key up
-  // from pressing return in the location bar.
+  // Check for cases where we are too early for events -- possible unmatched key
+  // up from pressing return in the location bar.
   Node* node = eventTargetNodeForDocument(m_frame->document());
   if (!node)
     return WebInputEventResult::NotHandled;
 
   UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
-  // 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.
+  // 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 == WebInputEvent::KeyDown)
     matchedAnAccessKey = handleAccessKey(initialKeyEvent);
 
-  // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
+  // 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 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 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.
+  // 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.
+  // But if we are dispatching a fake backward compatibility keypress, then we
+  // pretend that the keypress happened on the original node.
   node = eventTargetNodeForDocument(m_frame->document());
   if (!node)
     return WebInputEventResult::NotHandled;
 
 #if OS(MACOSX)
   // According to NSEvents.h, OpenStep reserves the range 0xF700-0xF8FF for
   // function keys. However, some actual private use characters happen to be
   // in this range, e.g. the Apple logo (Option+Shift+K). 0xF7FF is an
   // arbitrary cut-off.
   if (initialKeyEvent.text[0U] >= 0xF700 &&
@@ skipping 113 matching lines @@
   if (m_frame->document()->inDesignMode())
     return;
 
   if (page->focusController().advanceFocus(focusType))
     event->setDefaultHandled();
 }
 
 void KeyboardEventManager::defaultTabEventHandler(KeyboardEvent* event) {
   DCHECK_EQ(event->type(), EventTypeNames::keydown);
 
-  // We should only advance focus on tabs if no special modifier keys are held down.
+  // We should only advance focus on tabs if no special modifier keys are held
+  // down.
   if (event->ctrlKey() || event->metaKey())
     return;
 
 #if !OS(MACOSX)
   // Option-Tab is a shortcut based on a system-wide preference on Mac but
   // should be ignored on all other platforms.
   if (event->altKey())
     return;
 #endif
 
@@ skipping 68 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