reflow comments in core/input

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

 /*
- * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 87 matching lines @@
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
-// Refetch the event target node if it is removed or currently is the shadow node inside an <input> element.
-// If a mouse event handler changes the input element type to one that has a widget associated,
-// we'd like to EventHandler::handleMousePressEvent to pass the event to the widget and thus the
-// event target node can't still be the shadow node.
+// Refetch the event target node if it is removed or currently is the shadow
+// node inside an <input> element.  If a mouse event handler changes the input
+// element type to one that has a widget associated, we'd like to
+// EventHandler::handleMousePressEvent to pass the event to the widget and thus
+// the event target node can't still be the shadow node.
 bool shouldRefetchEventTarget(const MouseEventWithHitTestResults& mev) {
   Node* targetNode = mev.innerNode();
   if (!targetNode || !targetNode->parentNode())
     return true;
   return targetNode->isShadowRoot() &&
          isHTMLInputElement(toShadowRoot(targetNode)->host());
 }
 
 }  // namespace
 
 using namespace HTMLNames;
 
 // The amount of time to wait for a cursor update on style and layout changes
 // Set to 50Hz, no need to be faster than common screen refresh rate
 static const double cursorUpdateInterval = 0.02;
 
 static const int maximumCursorSize = 128;
 
-// It's pretty unlikely that a scale of less than one would ever be used. But all we really
-// need to ensure here is that the scale isn't so small that integer overflow can occur when
-// dividing cursor sizes (limited above) by the scale.
+// It's pretty unlikely that a scale of less than one would ever be used. But
+// all we really need to ensure here is that the scale isn't so small that
+// integer overflow can occur when dividing cursor sizes (limited above) by the
+// scale.
 static const double minimumCursorScale = 0.001;
 
 // The minimum amount of time an element stays active after a ShowPress
 // This is roughly 9 frames, which should be long enough to be noticeable.
 static const double minimumActiveInterval = 0.15;
 
 enum NoCursorChangeType { NoCursorChange };
 
 class OptionalCursor {
  public:
@@ skipping 103 matching lines @@
       FrameView* mainView = mainFrame->view();
       if (frameView && mainView) {
         IntPoint mainFramePoint = mainView->rootFrameToContents(
             frameView->contentsToRootFrame(roundedIntPoint(point)));
         return mainFrame->eventHandler().hitTestResultAtPoint(mainFramePoint,
                                                               hitType, padding);
       }
     }
   }
 
-  // hitTestResultAtPoint is specifically used to hitTest into all frames, thus it always allows child frame content.
+  // hitTestResultAtPoint is specifically used to hitTest into all frames, thus
+  // it always allows child frame content.
   HitTestRequest request(hitType | HitTestRequest::AllowChildFrameContent);
   HitTestResult result(request, point, padding.height().toUnsigned(),
                        padding.width().toUnsigned(),
                        padding.height().toUnsigned(),
                        padding.width().toUnsigned());
 
-  // LayoutView::hitTest causes a layout, and we don't want to hit that until the first
-  // layout because until then, there is nothing shown on the screen - the user can't
-  // have intentionally clicked on something belonging to this page. Furthermore,
-  // mousemove events before the first layout should not lead to a premature layout()
-  // happening, which could show a flash of white.
+  // LayoutView::hitTest causes a layout, and we don't want to hit that until
+  // the first layout because until then, there is nothing shown on the screen -
+  // the user can't have intentionally clicked on something belonging to this
+  // page.  Furthermore, mousemove events before the first layout should not
+  // lead to a premature layout() happening, which could show a flash of white.
   // See also the similar code in Document::performMouseEventHitTest.
   if (m_frame->contentLayoutItem().isNull() || !m_frame->view() ||
       !m_frame->view()->didFirstLayout())
     return result;
 
   m_frame->contentLayoutItem().hitTest(result);
   if (!request.readOnly())
     m_frame->document()->updateHoverActiveState(request, result.innerElement());
 
   return result;
@@ skipping 60 matching lines @@
 void EventHandler::cursorUpdateTimerFired(TimerBase*) {
   ASSERT(m_frame);
   ASSERT(m_frame->document());
 
   updateCursor();
 }
 
 void EventHandler::updateCursor() {
   TRACE_EVENT0("input", "EventHandler::updateCursor");
 
-  // We must do a cross-frame hit test because the frame that triggered the cursor
-  // update could be occluded by a different frame.
+  // We must do a cross-frame hit test because the frame that triggered the
+  // cursor update could be occluded by a different frame.
   ASSERT(m_frame == m_frame->localFrameRoot());
 
   if (m_mouseEventManager->isMousePositionUnknown())
     return;
 
   FrameView* view = m_frame->view();
   if (!view || !view->shouldSetCursor())
     return;
 
   LayoutViewItem layoutViewItem = view->layoutViewItem();
@@ skipping 172 matching lines @@
   bool inResizer = false;
   LayoutObject* layoutObject = node ? node->layoutObject() : nullptr;
   if (layoutObject && m_frame->view()) {
     PaintLayer* layer = layoutObject->enclosingLayer();
     inResizer = layer->getScrollableArea() &&
                 layer->getScrollableArea()->isPointInResizeControl(
                     result.roundedPointInMainFrame(), ResizerForPointer);
   }
 
   // During selection, use an I-beam no matter what we're over.
-  // If a drag may be starting or we're capturing mouse events for a particular node, don't treat this as a selection.
+  // If a drag may be starting or we're capturing mouse events for a particular
+  // node, don't treat this as a selection.
   if (m_mouseEventManager->mousePressed() &&
       selectionController().mouseDownMayStartSelect() &&
       !m_mouseEventManager->mouseDownMayStartDrag() &&
       !m_frame->selection().isNone() && !m_capturingMouseEventsNode) {
     return iBeam;
   }
 
   if ((editable ||
        (layoutObject && layoutObject->isText() && node->canStartSelection())) &&
       !inResizer && !result.scrollbar())
@@ skipping 17 matching lines @@
       UserGestureIndicator::currentToken();
 
   if (m_eventHandlerWillResetCapturingMouseEventsNode)
     m_capturingMouseEventsNode = nullptr;
   m_mouseEventManager->handleMousePressEventUpdateStates(mouseEvent);
   selectionController().setMouseDownMayStartSelect(false);
   if (!m_frame->view())
     return WebInputEventResult::NotHandled;
 
   HitTestRequest request(HitTestRequest::Active);
-  // Save the document point we generate in case the window coordinate is invalidated by what happens
-  // when we dispatch the event.
+  // Save the document point we generate in case the window coordinate is
+  // invalidated by what happens when we dispatch the event.
   LayoutPoint documentPoint =
       m_frame->view()->rootFrameToContents(mouseEvent.position());
   MouseEventWithHitTestResults mev =
       m_frame->document()->performMouseEventHitTest(request, documentPoint,
                                                     mouseEvent);
 
   if (!mev.innerNode()) {
     m_mouseEventManager->invalidateClick();
     return WebInputEventResult::NotHandled;
   }
 
   m_mouseEventManager->setMousePressNode(mev.innerNode());
   m_frame->document()->setSequentialFocusNavigationStartingPoint(
       mev.innerNode());
 
   LocalFrame* subframe = subframeForHitTestResult(mev);
   if (subframe) {
     WebInputEventResult result = passMousePressEventToSubframe(mev, subframe);
-    // Start capturing future events for this frame.  We only do this if we didn't clear
-    // the m_mousePressed flag, which may happen if an AppKit widget entered a modal event loop.
-    // The capturing should be done only when the result indicates it
-    // has been handled. See crbug.com/269917
+    // Start capturing future events for this frame.  We only do this if we
+    // didn't clear the m_mousePressed flag, which may happen if an AppKit
+    // widget entered a modal event loop.  The capturing should be done only
+    // when the result indicates it has been handled. See crbug.com/269917
     m_mouseEventManager->setCapturesDragging(
         subframe->eventHandler().m_mouseEventManager->capturesDragging());
     if (m_mouseEventManager->mousePressed() &&
         m_mouseEventManager->capturesDragging()) {
       m_capturingMouseEventsNode = mev.innerNode();
       m_eventHandlerWillResetCapturingMouseEventsNode = true;
     }
     m_mouseEventManager->invalidateClick();
     return result;
   }
 
   if (RuntimeEnabledFeatures::middleClickAutoscrollEnabled()) {
-    // We store whether middle click autoscroll is in progress before calling stopAutoscroll()
-    // because it will set m_autoscrollType to NoAutoscroll on return.
+    // We store whether middle click autoscroll is in progress before calling
+    // stopAutoscroll() because it will set m_autoscrollType to NoAutoscroll on
+    // return.
     bool isMiddleClickAutoscrollInProgress =
         m_scrollManager->middleClickAutoscrollInProgress();
     m_scrollManager->stopAutoscroll();
     if (isMiddleClickAutoscrollInProgress) {
-      // We invalidate the click when exiting middle click auto scroll so that we don't inadvertently navigate
-      // away from the current page (e.g. the click was on a hyperlink). See <rdar://problem/6095023>.
+      // We invalidate the click when exiting middle click auto scroll so that
+      // we don't inadvertently navigate away from the current page (e.g. the
+      // click was on a hyperlink). See <rdar://problem/6095023>.
       m_mouseEventManager->invalidateClick();
       return WebInputEventResult::HandledSuppressed;
     }
   }
 
   m_mouseEventManager->setClickCount(mouseEvent.clickCount());
   m_mouseEventManager->setClickNode(
       mev.innerNode()->isTextNode()
           ? FlatTreeTraversal::parent(*mev.innerNode())
           : mev.innerNode());
@@ skipping 30 matching lines @@
       mouseEvent.getSyntheticEventType() == PlatformMouseEvent::FromTouch
           ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities()
           : InputDeviceCapabilities::doesntFireTouchEventsSourceCapabilities();
   if (eventResult == WebInputEventResult::NotHandled) {
     eventResult = m_mouseEventManager->handleMouseFocus(hitTestResult,
                                                         sourceCapabilities);
   }
   m_mouseEventManager->setCapturesDragging(
       eventResult == WebInputEventResult::NotHandled || mev.scrollbar());
 
-  // If the hit testing originally determined the event was in a scrollbar, refetch the MouseEventWithHitTestResults
-  // in case the scrollbar widget was destroyed when the mouse event was handled.
+  // If the hit testing originally determined the event was in a scrollbar,
+  // refetch the MouseEventWithHitTestResults in case the scrollbar widget was
+  // destroyed when the mouse event was handled.
   if (mev.scrollbar()) {
     const bool wasLastScrollBar =
         mev.scrollbar() == m_lastScrollbarUnderMouse.get();
     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
     mev = m_frame->document()->performMouseEventHitTest(request, documentPoint,
                                                         mouseEvent);
     if (wasLastScrollBar && mev.scrollbar() != m_lastScrollbarUnderMouse.get())
       m_lastScrollbarUnderMouse = nullptr;
   }
 
   if (eventResult != WebInputEventResult::NotHandled) {
-    // scrollbars should get events anyway, even disabled controls might be scrollable
+    // Scrollbars should get events anyway, even disabled controls might be
+    // scrollable.
     passMousePressEventToScrollbar(mev);
   } else {
     if (shouldRefetchEventTarget(mev)) {
       HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
       mev = m_frame->document()->performMouseEventHitTest(
           request, documentPoint, mouseEvent);
     }
 
     if (passMousePressEventToScrollbar(mev))
       eventResult = WebInputEventResult::HandledSystem;
@@ skipping 76 matching lines @@
     return WebInputEventResult::HandledSystem;
   }
 
   // Mouse events simulated from touch should not hit-test again.
   ASSERT(!mouseEvent.fromTouch());
 
   HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move;
   if (m_mouseEventManager->mousePressed()) {
     hitType |= HitTestRequest::Active;
   } else if (onlyUpdateScrollbars) {
-    // Mouse events should be treated as "read-only" if we're updating only scrollbars. This
-    // means that :hover and :active freeze in the state they were in, rather than updating
-    // for nodes the mouse moves while the window is not key (which will be the case if
-    // onlyUpdateScrollbars is true).
+    // Mouse events should be treated as "read-only" if we're updating only
+    // scrollbars. This means that :hover and :active freeze in the state they
+    // were in, rather than updating for nodes the mouse moves while the window
+    // is not key (which will be the case if onlyUpdateScrollbars is true).
     hitType |= HitTestRequest::ReadOnly;
   }
 
-  // Treat any mouse move events as readonly if the user is currently touching the screen.
+  // Treat any mouse move events as readonly if the user is currently touching
+  // the screen.
   if (m_pointerEventManager->isAnyTouchActive())
     hitType |= HitTestRequest::Active | HitTestRequest::ReadOnly;
   HitTestRequest request(hitType);
   MouseEventWithHitTestResults mev = MouseEventWithHitTestResults(
       mouseEvent, HitTestResult(request, LayoutPoint()));
 
-  // We don't want to do a hit-test in forceLeave scenarios because there might actually be some other frame above this one at the specified co-ordinate.
-  // So we must force the hit-test to fail, while still clearing hover/active state.
+  // We don't want to do a hit-test in forceLeave scenarios because there might
+  // actually be some other frame above this one at the specified co-ordinate.
+  // So we must force the hit-test to fail, while still clearing hover/active
+  // state.
   if (forceLeave) {
     m_frame->document()->updateHoverActiveState(request, 0);
   } else {
     mev = EventHandlingUtil::performMouseEventHitTest(m_frame, request,
                                                       mouseEvent);
   }
 
   if (hoveredNode)
     *hoveredNode = mev.hitTestResult();
 
@@ skipping 10 matching lines @@
     if (onlyUpdateScrollbars)
       return WebInputEventResult::HandledSuppressed;
   }
 
   WebInputEventResult eventResult = WebInputEventResult::NotHandled;
   LocalFrame* newSubframe =
       m_capturingMouseEventsNode.get()
           ? subframeForTargetNode(m_capturingMouseEventsNode.get())
           : subframeForHitTestResult(mev);
 
-  // We want mouseouts to happen first, from the inside out.  First send a move event to the last subframe so that it will fire mouseouts.
+  // We want mouseouts to happen first, from the inside out.  First send a move
+  // event to the last subframe so that it will fire mouseouts.
   if (m_lastMouseMoveEventSubframe &&
       m_lastMouseMoveEventSubframe->tree().isDescendantOf(m_frame) &&
       m_lastMouseMoveEventSubframe != newSubframe)
     m_lastMouseMoveEventSubframe->eventHandler().handleMouseLeaveEvent(
         mev.event());
 
   if (newSubframe) {
     // Update over/out state before passing the event to the subframe.
     m_pointerEventManager->sendMouseAndPointerBoundaryEvents(
         updateMouseEventTargetNode(mev.innerNode()), mev.event());
 
-    // Event dispatch in sendMouseAndPointerBoundaryEvents may have caused the subframe of the target
-    // node to be detached from its FrameView, in which case the event should not be passed.
+    // Event dispatch in sendMouseAndPointerBoundaryEvents may have caused the
+    // subframe of the target node to be detached from its FrameView, in which
+    // case the event should not be passed.
     if (newSubframe->view())
       eventResult = passMouseMoveEventToSubframe(mev, newSubframe, hoveredNode);
   } else {
-    if (scrollbar && !m_mouseEventManager->mousePressed())
-      scrollbar->mouseMoved(
-          mev.event());  // Handle hover effects on platforms that support visual feedback on scrollbar hovering.
+    if (scrollbar && !m_mouseEventManager->mousePressed()) {
+      // Handle hover effects on platforms that support visual feedback on
+      // scrollbar hovering.
+      scrollbar->mouseMoved(mev.event());
+    }
     if (FrameView* view = m_frame->view()) {
       OptionalCursor optionalCursor = selectCursor(mev.hitTestResult());
       if (optionalCursor.isCursorChange()) {
         view->setCursor(optionalCursor.cursor());
       }
     }
   }
 
   m_lastMouseMoveEventSubframe = newSubframe;
 
@@ skipping 150 matching lines @@
     DataTransfer* dataTransfer) {
   WebInputEventResult eventResult = WebInputEventResult::NotHandled;
 
   if (!m_frame->view())
     return eventResult;
 
   HitTestRequest request(HitTestRequest::ReadOnly);
   MouseEventWithHitTestResults mev =
       EventHandlingUtil::performMouseEventHitTest(m_frame, request, event);
 
-  // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
+  // Drag events should never go to text nodes (following IE, and proper
+  // mouseover/out dispatch)
   Node* newTarget = mev.innerNode();
   if (newTarget && newTarget->isTextNode())
     newTarget = FlatTreeTraversal::parent(*newTarget);
 
   if (AutoscrollController* controller =
           m_scrollManager->autoscrollController())
     controller->updateDragAndDrop(newTarget, event.position(),
                                   event.timestamp());
 
   if (m_dragTarget != newTarget) {
     // FIXME: this ordering was explicitly chosen to match WinIE. However,
     // it is sometimes incorrect when dragging within subframes, as seen with
     // LayoutTests/fast/events/drag-in-frames.html.
     //
-    // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
+    // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec.
+    // <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
     LocalFrame* targetFrame;
     if (targetIsFrame(newTarget, targetFrame)) {
       if (targetFrame)
         eventResult =
             targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
     } else if (newTarget) {
-      // As per section 7.9.4 of the HTML 5 spec., we must always fire a drag event before firing a dragenter, dragleave, or dragover event.
+      // As per section 7.9.4 of the HTML 5 spec., we must always fire a drag
+      // event before firing a dragenter, dragleave, or dragover event.
       if (m_mouseEventManager->dragState().m_dragSrc) {
-        // for now we don't care if event handler cancels default behavior, since there is none
+        // For now we don't care if event handler cancels default behavior,
+        // since there is none.
         m_mouseEventManager->dispatchDragSrcEvent(EventTypeNames::drag, event);
       }
       eventResult = m_mouseEventManager->dispatchDragEvent(
           EventTypeNames::dragenter, newTarget, event, dataTransfer);
       if (eventResult == WebInputEventResult::NotHandled &&
           findDropZone(newTarget, dataTransfer))
         eventResult = WebInputEventResult::HandledSystem;
     }
 
     if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
       if (targetFrame)
         eventResult =
             targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
     } else if (m_dragTarget) {
       m_mouseEventManager->dispatchDragEvent(
           EventTypeNames::dragleave, m_dragTarget.get(), event, dataTransfer);
     }
 
     if (newTarget) {
-      // We do not explicitly call m_mouseEventManager->dispatchDragEvent here because it could ultimately result in the appearance that
-      // two dragover events fired. So, we mark that we should only fire a dragover event on the next call to this function.
+      // We do not explicitly call m_mouseEventManager->dispatchDragEvent here
+      // because it could ultimately result in the appearance that two dragover
+      // events fired. So, we mark that we should only fire a dragover event on
+      // the next call to this function.
       m_shouldOnlyFireDragOverEvent = true;
     }
   } else {
     LocalFrame* targetFrame;
     if (targetIsFrame(newTarget, targetFrame)) {
       if (targetFrame)
         eventResult =
             targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
     } else if (newTarget) {
-      // Note, when dealing with sub-frames, we may need to fire only a dragover event as a drag event may have been fired earlier.
+      // Note, when dealing with sub-frames, we may need to fire only a dragover
+      // event as a drag event may have been fired earlier.
       if (!m_shouldOnlyFireDragOverEvent &&
           m_mouseEventManager->dragState().m_dragSrc) {
-        // for now we don't care if event handler cancels default behavior, since there is none
+        // For now we don't care if event handler cancels default behavior,
+        // since there is none.
         m_mouseEventManager->dispatchDragSrcEvent(EventTypeNames::drag, event);
       }
       eventResult = m_mouseEventManager->dispatchDragEvent(
           EventTypeNames::dragover, newTarget, event, dataTransfer);
       if (eventResult == WebInputEventResult::NotHandled &&
           findDropZone(newTarget, dataTransfer))
         eventResult = WebInputEventResult::HandledSystem;
       m_shouldOnlyFireDragOverEvent = false;
     }
   }
@@ skipping 52 matching lines @@
   // If we're capturing, we always go right to that node.
   EventTarget* mousePointerCapturingNode =
       m_pointerEventManager->getMouseCapturingNode();
   if (mousePointerCapturingNode &&
       !RuntimeEnabledFeatures::pointerEventV1SpecCapturingEnabled()) {
     newNodeUnderMouse = mousePointerCapturingNode->toNode();
     DCHECK(newNodeUnderMouse);
   } else if (m_capturingMouseEventsNode) {
     newNodeUnderMouse = m_capturingMouseEventsNode.get();
   } else {
-    // If the target node is a text node, dispatch on the parent node - rdar://4196646
+    // If the target node is a text node, dispatch on the parent node -
+    // rdar://4196646
     if (newNodeUnderMouse && newNodeUnderMouse->isTextNode())
       newNodeUnderMouse = FlatTreeTraversal::parent(*newNodeUnderMouse);
   }
   return newNodeUnderMouse;
 }
 
 bool EventHandler::isPointerEventActive(int pointerId) {
   return m_pointerEventManager->isActive(pointerId);
 }
 
 void EventHandler::setPointerCapture(int pointerId, EventTarget* target) {
-  // TODO(crbug.com/591387): This functionality should be per page not per frame.
+  // TODO(crbug.com/591387): This functionality should be per page not per
+  // frame.
   m_pointerEventManager->setPointerCapture(pointerId, target);
 }
 
 void EventHandler::releasePointerCapture(int pointerId, EventTarget* target) {
   m_pointerEventManager->releasePointerCapture(pointerId, target);
 }
 
 bool EventHandler::hasPointerCapture(int pointerId,
                                      const EventTarget* target) const {
   return m_pointerEventManager->hasPointerCapture(pointerId, target);
@@ skipping 19 matching lines @@
   const auto& eventResult = m_pointerEventManager->sendMousePointerEvent(
       updateMouseEventTargetNode(targetNode), mouseEventType, mouseEvent);
   return eventResult;
 }
 
 WebInputEventResult EventHandler::handleWheelEvent(
     const PlatformWheelEvent& event) {
 #if OS(MACOSX)
   // Filter Mac OS specific phases, usually with a zero-delta.
   // https://crbug.com/553732
-  // TODO(chongz): EventSender sends events with |PlatformWheelEventPhaseNone|, but it shouldn't.
+  // TODO(chongz): EventSender sends events with |PlatformWheelEventPhaseNone|,
+  // but it shouldn't.
   const int kPlatformWheelEventPhaseNoEventMask =
       PlatformWheelEventPhaseEnded | PlatformWheelEventPhaseCancelled |
       PlatformWheelEventPhaseMayBegin;
   if ((event.phase() & kPlatformWheelEventPhaseNoEventMask) ||
       (event.momentumPhase() & kPlatformWheelEventPhaseNoEventMask))
     return WebInputEventResult::NotHandled;
 #endif
   Document* doc = m_frame->document();
 
   if (doc->layoutViewItem().isNull())
@@ skipping 36 matching lines @@
   }
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult EventHandler::handleGestureEvent(
     const PlatformGestureEvent& gestureEvent) {
   // Propagation to inner frames is handled below this function.
   ASSERT(m_frame == m_frame->localFrameRoot());
 
-  // Scrolling-related gesture events invoke EventHandler recursively for each frame down
-  // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
+  // Scrolling-related gesture events invoke EventHandler recursively for each
+  // frame down the chain, doing a single-frame hit-test per frame. This matches
+  // handleWheelEvent.
   // FIXME: Add a test that traverses this path, e.g. for devtools overlay.
   if (gestureEvent.isScrollEvent())
     return handleGestureScrollEvent(gestureEvent);
 
-  // Hit test across all frames and do touch adjustment as necessary for the event type.
+  // Hit test across all frames and do touch adjustment as necessary for the
+  // event type.
   GestureEventWithHitTestResults targetedEvent =
       targetGestureEvent(gestureEvent);
 
   return handleGestureEvent(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEvent(
     const GestureEventWithHitTestResults& targetedEvent) {
   TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
 
   // Propagation to inner frames is handled below this function.
   ASSERT(m_frame == m_frame->localFrameRoot());
 
-  // Non-scrolling related gesture events do a single cross-frame hit-test and jump
-  // directly to the inner most frame. This matches handleMousePressEvent etc.
+  // Non-scrolling related gesture events do a single cross-frame hit-test and
+  // jump directly to the inner most frame. This matches handleMousePressEvent
+  // etc.
   ASSERT(!targetedEvent.event().isScrollEvent());
 
-  // update mouseout/leave/over/enter events before jumping directly to the inner most frame
+  // Update mouseout/leave/over/enter events before jumping directly to the
+  // inner most frame.
   if (targetedEvent.event().type() == PlatformEvent::GestureTap)
     updateGestureTargetNodeForMouseEvent(targetedEvent);
 
   // Route to the correct frame.
   if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
     return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
-  // No hit test result, handle in root instance. Perhaps we should just return false instead?
+  // No hit test result, handle in root instance. Perhaps we should just return
+  // false instead?
   return m_gestureManager->handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEventInFrame(
     const GestureEventWithHitTestResults& targetedEvent) {
   return m_gestureManager->handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEvent(
     const PlatformGestureEvent& gestureEvent) {
@@ skipping 24 matching lines @@
 
 bool EventHandler::bestClickableNodeForHitTestResult(
     const HitTestResult& result,
     IntPoint& targetPoint,
     Node*& targetNode) {
   // FIXME: Unify this with the other best* functions which are very similar.
 
   TRACE_EVENT0("input", "EventHandler::bestClickableNodeForHitTestResult");
   ASSERT(result.isRectBasedTest());
 
-  // If the touch is over a scrollbar, don't adjust the touch point since touch adjustment only takes into account
-  // DOM nodes so a touch over a scrollbar will be adjusted towards nearby nodes. This leads to things like textarea
+  // If the touch is over a scrollbar, don't adjust the touch point since touch
+  // adjustment only takes into account DOM nodes so a touch over a scrollbar
+  // will be adjusted towards nearby nodes. This leads to things like textarea
   // scrollbars being untouchable.
   if (result.scrollbar()) {
     targetNode = 0;
     return false;
   }
 
   IntPoint touchCenter =
       m_frame->view()->contentsToRootFrame(result.roundedPointInMainFrame());
   IntRect touchRect = m_frame->view()->contentsToRootFrame(
       result.hitTestLocation().boundingBox());
 
   HeapVector<Member<Node>, 11> nodes;
   copyToVector(result.listBasedTestResult(), nodes);
 
-  // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
+  // FIXME: the explicit Vector conversion copies into a temporary and is
+  // wasteful.
   return findBestClickableCandidate(targetNode, targetPoint, touchCenter,
                                     touchRect, HeapVector<Member<Node>>(nodes));
 }
 
 bool EventHandler::bestContextMenuNodeForHitTestResult(
     const HitTestResult& result,
     IntPoint& targetPoint,
     Node*& targetNode) {
   ASSERT(result.isRectBasedTest());
   IntPoint touchCenter =
       m_frame->view()->contentsToRootFrame(result.roundedPointInMainFrame());
   IntRect touchRect = m_frame->view()->contentsToRootFrame(
       result.hitTestLocation().boundingBox());
   HeapVector<Member<Node>, 11> nodes;
   copyToVector(result.listBasedTestResult(), nodes);
 
-  // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
+  // FIXME: the explicit Vector conversion copies into a temporary and is
+  // wasteful.
   return findBestContextMenuCandidate(targetNode, targetPoint, touchCenter,
                                       touchRect,
                                       HeapVector<Member<Node>>(nodes));
 }
 
 bool EventHandler::bestZoomableAreaForTouchPoint(const IntPoint& touchCenter,
                                                  const IntSize& touchRadius,
                                                  IntRect& targetArea,
                                                  Node*& targetNode) {
   if (touchRadius.isEmpty())
     return false;
 
   IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(touchCenter);
 
   HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly |
                                                HitTestRequest::Active |
                                                HitTestRequest::ListBased;
   HitTestResult result =
       hitTestResultAtPoint(hitTestPoint, hitType, LayoutSize(touchRadius));
 
   IntRect touchRect(touchCenter - touchRadius, touchRadius + touchRadius);
   HeapVector<Member<Node>, 11> nodes;
   copyToVector(result.listBasedTestResult(), nodes);
 
-  // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
+  // FIXME: the explicit Vector conversion copies into a temporary and is
+  // wasteful.
   return findBestZoomableArea(targetNode, targetArea, touchCenter, touchRect,
                               HeapVector<Member<Node>>(nodes));
 }
 
 // Update the hover and active state across all frames for this gesture.
-// This logic is different than the mouse case because mice send MouseLeave events to frames as they're exited.
-// With gestures, a single event conceptually both 'leaves' whatever frame currently had hover and enters a new frame
+// This logic is different than the mouse case because mice send MouseLeave
+// events to frames as they're exited.  With gestures, a single event
+// conceptually both 'leaves' whatever frame currently had hover and enters a
+// new frame
 void EventHandler::updateGestureHoverActiveState(const HitTestRequest& request,
                                                  Element* innerElement) {
   ASSERT(m_frame == m_frame->localFrameRoot());
 
   HeapVector<Member<LocalFrame>> newHoverFrameChain;
   LocalFrame* newHoverFrameInDocument =
       innerElement ? innerElement->document().frame() : nullptr;
-  // Insert the ancestors of the frame having the new hovered node to the frame chain
-  // The frame chain doesn't include the main frame to avoid the redundant work that cleans the hover state.
-  // Because the hover state for the main frame is updated by calling Document::updateHoverActiveState
+  // Insert the ancestors of the frame having the new hovered node to the frame
+  // chain The frame chain doesn't include the main frame to avoid the redundant
+  // work that cleans the hover state.  Because the hover state for the main
+  // frame is updated by calling Document::updateHoverActiveState
   while (newHoverFrameInDocument && newHoverFrameInDocument != m_frame) {
     newHoverFrameChain.append(newHoverFrameInDocument);
     Frame* parentFrame = newHoverFrameInDocument->tree().parent();
     newHoverFrameInDocument = parentFrame && parentFrame->isLocalFrame()
                                   ? toLocalFrame(parentFrame)
                                   : nullptr;
   }
 
   Node* oldHoverNodeInCurDoc = m_frame->document()->hoverNode();
   Node* newInnermostHoverNode = innerElement;
 
   if (newInnermostHoverNode != oldHoverNodeInCurDoc) {
     size_t indexFrameChain = newHoverFrameChain.size();
 
-    // Clear the hover state on any frames which are no longer in the frame chain of the hovered elemen
+    // Clear the hover state on any frames which are no longer in the frame
+    // chain of the hovered element.
     while (oldHoverNodeInCurDoc &&
            oldHoverNodeInCurDoc->isFrameOwnerElement()) {
       LocalFrame* newHoverFrame = nullptr;
       // If we can't get the frame from the new hover frame chain,
       // the newHoverFrame will be null and the old hover state will be cleared.
       if (indexFrameChain > 0)
         newHoverFrame = newHoverFrameChain[--indexFrameChain];
 
       HTMLFrameOwnerElement* owner =
           toHTMLFrameOwnerElement(oldHoverNodeInCurDoc);
       if (!owner->contentFrame() || !owner->contentFrame()->isLocalFrame())
         break;
 
       LocalFrame* oldHoverFrame = toLocalFrame(owner->contentFrame());
       Document* doc = oldHoverFrame->document();
       if (!doc)
         break;
 
       oldHoverNodeInCurDoc = doc->hoverNode();
       // If the old hovered frame is different from the new hovered frame.
       // we should clear the old hovered node from the old hovered frame.
       if (newHoverFrame != oldHoverFrame)
         doc->updateHoverActiveState(request, nullptr);
     }
   }
 
-  // Recursively set the new active/hover states on every frame in the chain of innerElement.
+  // Recursively set the new active/hover states on every frame in the chain of
+  // innerElement.
   m_frame->document()->updateHoverActiveState(request, innerElement);
 }
 
-// Update the mouseover/mouseenter/mouseout/mouseleave events across all frames for this gesture,
-// before passing the targeted gesture event directly to a hit frame.
+// Update the mouseover/mouseenter/mouseout/mouseleave events across all frames
+// for this gesture, before passing the targeted gesture event directly to a hit
+// frame.
 void EventHandler::updateGestureTargetNodeForMouseEvent(
     const GestureEventWithHitTestResults& targetedEvent) {
   ASSERT(m_frame == m_frame->localFrameRoot());
 
   // Behaviour of this function is as follows:
   // - Create the chain of all entered frames.
-  // - Compare the last frame chain under the gesture to newly entered frame chain from the main frame one by one.
-  // - If the last frame doesn't match with the entered frame, then create the chain of exited frames from the last frame chain.
-  // - Dispatch mouseout/mouseleave events of the exited frames from the inside out.
-  // - Dispatch mouseover/mouseenter events of the entered frames into the inside.
+  // - Compare the last frame chain under the gesture to newly entered frame
+  //   chain from the main frame one by one.
+  // - If the last frame doesn't match with the entered frame, then create the
+  //   chain of exited frames from the last frame chain.
+  // - Dispatch mouseout/mouseleave events of the exited frames from the inside
+  //   out.
+  // - Dispatch mouseover/mouseenter events of the entered frames into the
+  //   inside.
 
-  // Insert the ancestors of the frame having the new target node to the entered frame chain
+  // Insert the ancestors of the frame having the new target node to the entered
+  // frame chain.
   HeapVector<Member<LocalFrame>> enteredFrameChain;
   LocalFrame* enteredFrameInDocument =
       targetedEvent.hitTestResult().innerNodeFrame();
   while (enteredFrameInDocument) {
     enteredFrameChain.append(enteredFrameInDocument);
     Frame* parentFrame = enteredFrameInDocument->tree().parent();
     enteredFrameInDocument = parentFrame && parentFrame->isLocalFrame()
                                  ? toLocalFrame(parentFrame)
                                  : nullptr;
   }
 
   size_t indexEnteredFrameChain = enteredFrameChain.size();
   LocalFrame* exitedFrameInDocument = m_frame;
   HeapVector<Member<LocalFrame>> exitedFrameChain;
-  // Insert the frame from the disagreement between last frames and entered frames
+  // Insert the frame from the disagreement between last frames and entered
+  // frames.
   while (exitedFrameInDocument) {
     Node* lastNodeUnderTap = exitedFrameInDocument->eventHandler()
                                  .m_mouseEventManager->getNodeUnderMouse();
     if (!lastNodeUnderTap)
       break;
 
     LocalFrame* nextExitedFrameInDocument = nullptr;
     if (lastNodeUnderTap->isFrameOwnerElement()) {
       HTMLFrameOwnerElement* owner = toHTMLFrameOwnerElement(lastNodeUnderTap);
       if (owner->contentFrame() && owner->contentFrame()->isLocalFrame())
@@ skipping 87 matching lines @@
     m_activeIntervalTimer.startOneShot(minimumActiveInterval - activeInterval,
                                        BLINK_FROM_HERE);
   }
 
   return eventWithHitTestResults;
 }
 
 GestureEventWithHitTestResults EventHandler::hitTestResultForGestureEvent(
     const PlatformGestureEvent& gestureEvent,
     HitTestRequest::HitTestRequestType hitType) {
-  // Perform the rect-based hit-test (or point-based if adjustment is disabled). Note that
-  // we don't yet apply hover/active state here because we need to resolve touch adjustment
-  // first so that we apply hover/active it to the final adjusted node.
+  // Perform the rect-based hit-test (or point-based if adjustment is disabled).
+  // Note that we don't yet apply hover/active state here because we need to
+  // resolve touch adjustment first so that we apply hover/active it to the
+  // final adjusted node.
   IntPoint hitTestPoint =
       m_frame->view()->rootFrameToContents(gestureEvent.position());
   LayoutSize padding;
   if (shouldApplyTouchAdjustment(gestureEvent)) {
     padding = LayoutSize(gestureEvent.area());
     if (!padding.isEmpty()) {
       padding.scale(1.f / 2);
       hitType |= HitTestRequest::ListBased;
     }
   }
   HitTestResult hitTestResult = hitTestResultAtPoint(
       hitTestPoint, hitType | HitTestRequest::ReadOnly, padding);
 
-  // Adjust the location of the gesture to the most likely nearby node, as appropriate for the
-  // type of event.
+  // Adjust the location of the gesture to the most likely nearby node, as
+  // appropriate for the type of event.
   PlatformGestureEvent adjustedEvent = gestureEvent;
   applyTouchAdjustment(&adjustedEvent, &hitTestResult);
 
-  // Do a new hit-test at the (adjusted) gesture co-ordinates. This is necessary because
-  // rect-based hit testing and touch adjustment sometimes return a different node than
-  // what a point-based hit test would return for the same point.
-  // FIXME: Fix touch adjustment to avoid the need for a redundant hit test. http://crbug.com/398914
+  // Do a new hit-test at the (adjusted) gesture co-ordinates. This is necessary
+  // because rect-based hit testing and touch adjustment sometimes return a
+  // different node than what a point-based hit test would return for the same
+  // point.
+  // FIXME: Fix touch adjustment to avoid the need for a redundant hit test.
+  // http://crbug.com/398914
   if (shouldApplyTouchAdjustment(gestureEvent)) {
     LocalFrame* hitFrame = hitTestResult.innerNodeFrame();
     if (!hitFrame)
       hitFrame = m_frame;
     hitTestResult = EventHandlingUtil::hitTestResultInFrame(
         hitFrame,
         hitFrame->view()->rootFrameToContents(adjustedEvent.position()),
         (hitType | HitTestRequest::ReadOnly) & ~HitTestRequest::ListBased);
   }
 
-  // If we did a rect-based hit test it must be resolved to the best single node by now to
-  // ensure consumers don't accidentally use one of the other candidates.
+  // If we did a rect-based hit test it must be resolved to the best single node
+  // by now to ensure consumers don't accidentally use one of the other
+  // candidates.
   ASSERT(!hitTestResult.isRectBasedTest());
 
   return GestureEventWithHitTestResults(adjustedEvent, hitTestResult);
 }
 
 void EventHandler::applyTouchAdjustment(PlatformGestureEvent* gestureEvent,
                                         HitTestResult* hitTestResult) {
   if (!shouldApplyTouchAdjustment(*gestureEvent))
     return;
 
@@ skipping 11 matching lines @@
     case PlatformEvent::GestureLongPress:
     case PlatformEvent::GestureLongTap:
     case PlatformEvent::GestureTwoFingerTap:
       adjusted = bestContextMenuNodeForHitTestResult(
           *hitTestResult, adjustedPoint, adjustedNode);
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
-  // Update the hit-test result to be a point-based result instead of a rect-based result.
-  // FIXME: We should do this even when no candidate matches the node filter. crbug.com/398914
+  // Update the hit-test result to be a point-based result instead of a
+  // rect-based result.
+  // FIXME: We should do this even when no candidate matches the node filter.
+  // crbug.com/398914
   if (adjusted) {
     hitTestResult->resolveRectBasedTest(
         adjustedNode, m_frame->view()->rootFrameToContents(adjustedPoint));
     gestureEvent->applyTouchAdjustment(adjustedPoint);
   }
 }
 
 WebInputEventResult EventHandler::sendContextMenuEvent(
     const PlatformMouseEvent& event,
     Node* overrideTargetNode) {
   FrameView* v = m_frame->view();
   if (!v)
     return WebInputEventResult::NotHandled;
 
-  // Clear mouse press state to avoid initiating a drag while context menu is up.
+  // Clear mouse press state to avoid initiating a drag while context menu is
+  // up.
   m_mouseEventManager->setMousePressed(false);
   LayoutPoint positionInContents = v->rootFrameToContents(event.position());
   HitTestRequest request(HitTestRequest::Active);
   MouseEventWithHitTestResults mev =
       m_frame->document()->performMouseEventHitTest(request, positionInContents,
                                                     event);
-  // Since |Document::performMouseEventHitTest()| modifies layout tree for setting
-  // hover element, we need to update layout tree for requirement of
+  // Since |Document::performMouseEventHitTest()| modifies layout tree for
+  // setting hover element, we need to update layout tree for requirement of
   // |SelectionController::sendContextMenuEvent()|.
   m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   selectionController().sendContextMenuEvent(mev, positionInContents);
 
   Node* targetNode = overrideTargetNode ? overrideTargetNode : mev.innerNode();
   return m_mouseEventManager->dispatchMouseEvent(
       updateMouseEventTargetNode(targetNode), EventTypeNames::contextmenu,
       event, 0);
 }
@@ skipping 26 matching lines @@
   if (!overrideTargetElement && start.anchorNode() &&
       (selection.rootEditableElement() || selection.isRange())) {
     // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
     // needs to be audited.  See http://crbug.com/590369 for more details.
     doc->updateStyleAndLayoutIgnorePendingStylesheets();
 
     IntRect firstRect = m_frame->editor().firstRectForRange(
         selection.selection().toNormalizedEphemeralRange());
 
     int x = rightAligned ? firstRect.maxX() : firstRect.x();
-    // In a multiline edit, firstRect.maxY() would endup on the next line, so -1.
+    // In a multiline edit, firstRect.maxY() would end up on the next line, so
+    // -1.
     int y = firstRect.maxY() ? firstRect.maxY() - 1 : 0;
     locationInRootFrame = view->contentsToRootFrame(IntPoint(x, y));
   } else if (focusedElement) {
     IntRect clippedRect = focusedElement->boundsInViewport();
     locationInRootFrame =
         visualViewport.viewportToRootFrame(clippedRect.center());
   } else {
     locationInRootFrame = IntPoint(
         rightAligned ? visualViewport.visibleRect().maxX() - kContextMenuMargin
                      : visualViewport.location().x() + kContextMenuMargin,
@@ skipping 13 matching lines @@
       overrideTargetElement ? overrideTargetElement : doc->focusedElement();
   if (!targetNode)
     targetNode = doc;
 
   // Use the focused node as the target for hover and active.
   HitTestRequest request(HitTestRequest::Active);
   HitTestResult result(request, locationInRootFrame);
   result.setInnerNode(targetNode);
   doc->updateHoverActiveState(request, result.innerElement());
 
-  // The contextmenu event is a mouse event even when invoked using the keyboard.
-  // This is required for web compatibility.
+  // The contextmenu event is a mouse event even when invoked using the
+  // keyboard.  This is required for web compatibility.
   PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
   if (m_frame->settings() && m_frame->settings()->showContextMenuOnMouseUp())
     eventType = PlatformEvent::MouseReleased;
 
   PlatformMouseEvent mouseEvent(
       locationInRootFrame, globalPosition,
       WebPointerProperties::Button::NoButton, eventType, /* clickCount */ 0,
       PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable,
       WTF::monotonicallyIncreasingTime(),
       WebPointerProperties::PointerType::Mouse);
 
   return sendContextMenuEvent(mouseEvent, overrideTargetElement);
 }
 
 void EventHandler::scheduleHoverStateUpdate() {
   if (!m_hoverTimer.isActive())
     m_hoverTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void EventHandler::scheduleCursorUpdate() {
-  // We only want one timer for the page, rather than each frame having it's own timer
-  // competing which eachother (since there's only one mouse cursor).
+  // We only want one timer for the page, rather than each frame having it's own
+  // timer competing which eachother (since there's only one mouse cursor).
   ASSERT(m_frame == m_frame->localFrameRoot());
 
   if (!m_cursorUpdateTimer.isActive())
     m_cursorUpdateTimer.startOneShot(cursorUpdateInterval, BLINK_FROM_HERE);
 }
 
 bool EventHandler::cursorUpdatePending() {
   return m_cursorUpdateTimer.isActive();
 }
 
@@ skipping 42 matching lines @@
     // m_lastDeferredTapElement.get() == m_frame->document()->activeElement()
     HitTestRequest request(HitTestRequest::TouchEvent |
                            HitTestRequest::Release);
     m_frame->document()->updateHoverActiveState(request,
                                                 m_lastDeferredTapElement.get());
   }
   m_lastDeferredTapElement = nullptr;
 }
 
 void EventHandler::notifyElementActivated() {
-  // Since another element has been set to active, stop current timer and clear reference.
+  // Since another element has been set to active, stop current timer and clear
+  // reference.
   if (m_activeIntervalTimer.isActive())
     m_activeIntervalTimer.stop();
   m_lastDeferredTapElement = nullptr;
 }
 
 bool EventHandler::handleAccessKey(const WebKeyboardEvent& evt) {
   return m_keyboardEventManager->handleAccessKey(evt);
 }
 
 WebInputEventResult EventHandler::keyEvent(
     const WebKeyboardEvent& initialKeyEvent) {
   return m_keyboardEventManager->keyEvent(initialKeyEvent);
 }
 
 void EventHandler::defaultKeyboardEventHandler(KeyboardEvent* event) {
   m_keyboardEventManager->defaultKeyboardEventHandler(
       event, m_mouseEventManager->mousePressNode());
 }
 
 void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event,
                                      DragOperation operation) {
   m_mouseEventManager->dragSourceEndedAt(event, operation);
 }
 
 void EventHandler::updateDragStateAfterEditDragIfNeeded(
     Element* rootEditableElement) {
-  // If inserting the dragged contents removed the drag source, we still want to fire dragend at the root editble element.
+  // If inserting the dragged contents removed the drag source, we still want to
+  // fire dragend at the root editble element.
   if (m_mouseEventManager->dragState().m_dragSrc &&
       !m_mouseEventManager->dragState().m_dragSrc->isConnected())
     m_mouseEventManager->dragState().m_dragSrc = rootEditableElement;
 }
 
 bool EventHandler::handleTextInputEvent(const String& text,
                                         Event* underlyingEvent,
                                         TextEventInputType inputType) {
-  // Platforms should differentiate real commands like selectAll from text input in disguise (like insertNewline),
-  // and avoid dispatching text input events from keydown default handlers.
+  // Platforms should differentiate real commands like selectAll from text input
+  // in disguise (like insertNewline), and avoid dispatching text input events
+  // from keydown default handlers.
   ASSERT(!underlyingEvent || !underlyingEvent->isKeyboardEvent() ||
          toKeyboardEvent(underlyingEvent)->type() == EventTypeNames::keypress);
 
   if (!m_frame)
     return false;
 
   EventTarget* target;
   if (underlyingEvent)
     target = underlyingEvent->target();
   else
@@ skipping 80 matching lines @@
 WebInputEventResult EventHandler::passMouseReleaseEventToSubframe(
     MouseEventWithHitTestResults& mev,
     LocalFrame* subframe) {
   WebInputEventResult result =
       subframe->eventHandler().handleMouseReleaseEvent(mev.event());
   if (result != WebInputEventResult::NotHandled)
     return result;
   return WebInputEventResult::HandledSystem;
 }
 
-
 FrameHost* EventHandler::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 }  // namespace blink