reflow comments in core/input

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

 /*
  * Copyright (C) 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * 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 108 matching lines @@
   WebInputEventResult updateDragAndDrop(const PlatformMouseEvent&,
                                         DataTransfer*);
   void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
   WebInputEventResult performDragAndDrop(const PlatformMouseEvent&,
                                          DataTransfer*);
   void updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement);
 
   void scheduleHoverStateUpdate();
   void scheduleCursorUpdate();
 
-  // Return whether a mouse cursor update is currently pending.  Used for testing.
+  // Return whether a mouse cursor update is currently pending.  Used for
+  // testing.
   bool cursorUpdatePending();
 
   void setResizingFrameSet(HTMLFrameSetElement*);
 
   void resizeScrollableAreaDestroyed();
 
   IntPoint lastKnownMousePosition() const;
 
   IntPoint dragDataTransferLocationForTesting();
 
   // Performs a logical scroll that chains, crossing frames, starting from
   // the given node or a reasonable default (focus/last clicked).
   bool bubblingScroll(ScrollDirection,
                       ScrollGranularity,
                       Node* startingNode = nullptr);
 
   WebInputEventResult handleMouseMoveEvent(const PlatformMouseEvent&);
   void handleMouseLeaveEvent(const PlatformMouseEvent&);
 
   WebInputEventResult handleMousePressEvent(const PlatformMouseEvent&);
   WebInputEventResult handleMouseReleaseEvent(const PlatformMouseEvent&);
   WebInputEventResult handleWheelEvent(const PlatformWheelEvent&);
 
   // Called on the local root frame exactly once per gesture event.
   WebInputEventResult handleGestureEvent(const PlatformGestureEvent&);
   WebInputEventResult handleGestureEvent(const GestureEventWithHitTestResults&);
 
-  // Clear the old hover/active state within frames before moving the hover state to the another frame
+  // Clear the old hover/active state within frames before moving the hover
+  // state to the another frame
   void updateGestureHoverActiveState(const HitTestRequest&, Element*);
 
-  // Hit-test the provided (non-scroll) gesture event, applying touch-adjustment and updating
-  // hover/active state across all frames if necessary. This should be called at most once
-  // per gesture event, and called on the local root frame.
+  // Hit-test the provided (non-scroll) gesture event, applying touch-adjustment
+  // and updating hover/active state across all frames if necessary. This should
+  // be called at most once per gesture event, and called on the local root
+  // frame.
   // Note: This is similar to (the less clearly named) prepareMouseEvent.
   // FIXME: Remove readOnly param when there is only ever a single call to this.
   GestureEventWithHitTestResults targetGestureEvent(const PlatformGestureEvent&,
                                                     bool readOnly = false);
   GestureEventWithHitTestResults hitTestResultForGestureEvent(
       const PlatformGestureEvent&,
       HitTestRequest::HitTestRequestType);
-  // Handle the provided non-scroll gesture event. Should be called only on the inner frame.
+  // Handle the provided non-scroll gesture event. Should be called only on the
+  // inner frame.
   WebInputEventResult handleGestureEventInFrame(
       const GestureEventWithHitTestResults&);
 
-  // Handle the provided scroll gesture event, propagating down to child frames as necessary.
+  // Handle the provided scroll gesture event, propagating down to child frames
+  // as necessary.
   WebInputEventResult handleGestureScrollEvent(const PlatformGestureEvent&);
   WebInputEventResult handleGestureScrollEnd(const PlatformGestureEvent&);
   bool isScrollbarHandlingGestures() const;
 
   bool bestClickableNodeForHitTestResult(const HitTestResult&,
                                          IntPoint& targetPoint,
                                          Node*& targetNode);
   bool bestContextMenuNodeForHitTestResult(const HitTestResult&,
                                            IntPoint& targetPoint,
                                            Node*& targetNode);
-  // FIXME: This doesn't appear to be used outside tests anymore, what path are we using now and is it tested?
+  // FIXME: This doesn't appear to be used outside tests anymore, what path are
+  // we using now and is it tested?
   bool bestZoomableAreaForTouchPoint(const IntPoint& touchCenter,
                                      const IntSize& touchRadius,
                                      IntRect& targetArea,
                                      Node*& targetNode);
 
   WebInputEventResult sendContextMenuEvent(const PlatformMouseEvent&,
                                            Node* overrideTargetNode = nullptr);
   WebInputEventResult sendContextMenuEventForKey(
       Element* overrideTargetElement = nullptr);
 
@@ skipping 47 matching lines @@
   //             a physical direction for each LayoutBox we try to scroll
   //             based on that box's writing mode.
   // granularity - The units that the  scroll delta parameter is in.
   // startNode - Optional. If provided, start chaining from the given node.
   //             If not, use the current focus or last clicked node.
   bool logicalScroll(ScrollDirection,
                      ScrollGranularity,
                      Node* startNode = nullptr);
 
  private:
-
   WebInputEventResult handleMouseMoveOrLeaveEvent(
       const PlatformMouseEvent&,
       HitTestResult* hoveredNode = nullptr,
       bool onlyUpdateScrollbars = false,
       bool forceLeave = false);
 
   HitTestRequest::HitTestRequestType getHitTypeForGestureType(
       PlatformEvent::EventType);
   void applyTouchAdjustment(PlatformGestureEvent*, HitTestResult*);
   WebInputEventResult handleGestureTapDown(
@@ skipping 17 matching lines @@
   void hoverTimerFired(TimerBase*);
   void cursorUpdateTimerFired(TimerBase*);
   void activeIntervalTimerFired(TimerBase*);
 
   void updateCursor();
 
   ScrollableArea* associatedScrollableArea(const PaintLayer*) const;
 
   Node* updateMouseEventTargetNode(Node*);
 
-  // Dispatches ME after corresponding PE provided the PE has not been canceled. The eventType arg
-  // must be a mouse event that can be gated though a preventDefaulted pointerdown (i.e., one of
+  // Dispatches ME after corresponding PE provided the PE has not been canceled.
+  // The eventType arg must be a mouse event that can be gated though a
+  // preventDefaulted pointerdown (i.e., one of
   // {mousedown, mousemove, mouseup}).
-  // TODO(mustaq): Can we avoid the clickCount param, instead use PlatformMouseEvent's count?
+  // TODO(mustaq): Can we avoid the clickCount param, instead use
+  // PlatformMouseEvent's count?
   //     Same applied to dispatchMouseEvent() above.
   WebInputEventResult updatePointerTargetAndDispatchEvents(
       const AtomicString& mouseEventType,
       Node* target,
       const PlatformMouseEvent&);
 
-  // Clears drag target and related states. It is called when drag is done or canceled.
+  // Clears drag target and related states. It is called when drag is done or
+  // canceled.
   void clearDragState();
 
   WebInputEventResult passMousePressEventToSubframe(
       MouseEventWithHitTestResults&,
       LocalFrame* subframe);
   WebInputEventResult passMouseMoveEventToSubframe(
       MouseEventWithHitTestResults&,
       LocalFrame* subframe,
       HitTestResult* hoveredNode = nullptr);
   WebInputEventResult passMouseReleaseEventToSubframe(
@@ skipping 18 matching lines @@
 
   // NOTE: If adding a new field to this class please ensure that it is
   // cleared in |EventHandler::clear()|.
 
   const Member<LocalFrame> m_frame;
 
   const Member<SelectionController> m_selectionController;
 
   Timer<EventHandler> m_hoverTimer;
 
-  // TODO(rbyers): Mouse cursor update is page-wide, not per-frame.  Page-wide state
-  // should move out of EventHandler to a new PageEventHandler class. crbug.com/449649
+  // TODO(rbyers): Mouse cursor update is page-wide, not per-frame.  Page-wide
+  // state should move out of EventHandler to a new PageEventHandler class.
+  // crbug.com/449649
   Timer<EventHandler> m_cursorUpdateTimer;
 
   Member<Node> m_capturingMouseEventsNode;
   bool m_eventHandlerWillResetCapturingMouseEventsNode;
 
   Member<LocalFrame> m_lastMouseMoveEventSubframe;
   Member<Scrollbar> m_lastScrollbarUnderMouse;
 
   Member<Node> m_dragTarget;
   bool m_shouldOnlyFireDragOverEvent;
@@ skipping 13 matching lines @@
   bool m_longTapShouldInvokeContextMenu;
 
   Timer<EventHandler> m_activeIntervalTimer;
   double m_lastShowPressTimestamp;
   Member<Element> m_lastDeferredTapElement;
 
   // Set on GestureTapDown if the |pointerdown| event corresponding to the
   // triggering |touchstart| event was canceled. This suppresses mouse event
   // firing for the current gesture sequence (i.e. until next GestureTapDown).
   bool m_suppressMouseEventsFromGestures;
-
 };
 
 }  // namespace blink
 
 #endif  // EventHandler_h