Return a enumeration of the state of handling of InputEvents.

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 24 matching lines @@
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/Cursor.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformTouchPoint.h"
 #include "platform/Timer.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "public/platform/WebFocusType.h"
+#include "public/platform/WebInputEventResult.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashTraits.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 class AutoscrollController;
 class DataTransfer;
 class PaintLayer;
@@ skipping 52 matching lines @@
     void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
 
     HitTestResult hitTestResultAtPoint(const LayoutPoint&,
         HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active,
         const LayoutSize& padding = LayoutSize());
 
     bool mousePressed() const { return m_mousePressed; }
 
     void setCapturingMouseEventsNode(PassRefPtrWillBeRawPtr<Node>); // A caller is responsible for resetting capturing node to 0.
 
-    bool updateDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
+    WebInputEventResult updateDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
     void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
-    bool performDragAndDrop(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.
     bool cursorUpdatePending();
 
     void setResizingFrameSet(HTMLFrameSetElement*);
 
     void resizeScrollableAreaDestroyed();
 
     IntPoint lastKnownMousePosition() const;
 
     // Attempts to scroll the DOM tree. If that fails, scrolls the view.
     // If the view can't be scrolled either, recursively bubble to the parent frame.
     bool bubblingScroll(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
 
-    bool handleMouseMoveEvent(const PlatformMouseEvent&);
+    WebInputEventResult handleMouseMoveEvent(const PlatformMouseEvent&);
     void handleMouseLeaveEvent(const PlatformMouseEvent&);
 
-    bool handleMousePressEvent(const PlatformMouseEvent&);
-    bool handleMouseReleaseEvent(const PlatformMouseEvent&);
-    bool handleWheelEvent(const PlatformWheelEvent&);
+    WebInputEventResult handleMousePressEvent(const PlatformMouseEvent&);
+    WebInputEventResult handleMouseReleaseEvent(const PlatformMouseEvent&);
+    WebInputEventResult handleWheelEvent(const PlatformWheelEvent&);
     void defaultWheelEventHandler(Node*, WheelEvent*);
 
     // Called on the local root frame exactly once per gesture event.
-    bool handleGestureEvent(const PlatformGestureEvent&);
-    bool handleGestureEvent(const GestureEventWithHitTestResults&);
+    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
     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.
     // 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.
-    bool handleGestureEventInFrame(const GestureEventWithHitTestResults&);
+    WebInputEventResult handleGestureEventInFrame(const GestureEventWithHitTestResults&);
 
     // Handle the provided scroll gesture event, propagating down to child frames as necessary.
-    bool handleGestureScrollEvent(const PlatformGestureEvent&);
-    bool handleGestureScrollEnd(const PlatformGestureEvent&);
+    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?
     bool bestZoomableAreaForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntRect& targetArea, Node*& targetNode);
 
-    bool sendContextMenuEvent(const PlatformMouseEvent&, Node* overrideTargetNode = nullptr);
-    bool sendContextMenuEventForKey(Element* overrideTargetElement = nullptr);
-    bool sendContextMenuEventForGesture(const GestureEventWithHitTestResults&);
+    WebInputEventResult sendContextMenuEvent(const PlatformMouseEvent&, Node* overrideTargetNode = nullptr);
+    WebInputEventResult sendContextMenuEventForKey(Element* overrideTargetElement = nullptr);
+    WebInputEventResult sendContextMenuEventForGesture(const GestureEventWithHitTestResults&);
 
     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
 
     static PlatformEvent::Modifiers accessKeyModifiers();
     bool handleAccessKey(const PlatformKeyboardEvent&);
-    bool keyEvent(const PlatformKeyboardEvent&);
+    WebInputEventResult keyEvent(const PlatformKeyboardEvent&);
     void defaultKeyboardEventHandler(KeyboardEvent*);
 
     bool handleTextInputEvent(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard);
     void defaultTextInputEventHandler(TextEvent*);
 
     void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
 
     void focusDocumentView();
 
     void capsLockStateMayHaveChanged(); // Only called by FrameSelection
 
-    bool handleTouchEvent(const PlatformTouchEvent&);
+    WebInputEventResult handleTouchEvent(const PlatformTouchEvent&);
 
     bool useHandCursor(Node*, bool isOverLink);
 
     void notifyElementActivated();
 
     PassRefPtr<UserGestureToken> takeLastMouseDownGestureToken() { return m_lastMouseDownUserGestureToken.release(); }
 
     int clickCount() { return m_clickCount; }
 
     SelectionController& selectionController() const { return *m_selectionController; }
@@ skipping 14 matching lines @@
         FloatSize adjustedRadius;
         bool knownTarget;
         bool consumed;
     };
 
 private:
     static DragState& dragState();
 
     DataTransfer* createDraggingDataTransfer() const;
 
-    bool handleMouseMoveOrLeaveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false, bool forceLeave = false);
-    bool handleMousePressEvent(const MouseEventWithHitTestResults&);
-    bool handleMouseFocus(const MouseEventWithHitTestResults&, InputDeviceCapabilities* sourceCapabilities);
-    bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
-    bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
+    WebInputEventResult handleMouseMoveOrLeaveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false, bool forceLeave = false);
+    WebInputEventResult handleMousePressEvent(const MouseEventWithHitTestResults&);
+    WebInputEventResult handleMouseFocus(const MouseEventWithHitTestResults&, InputDeviceCapabilities* sourceCapabilities);
+    WebInputEventResult handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
+    WebInputEventResult handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
 
     HitTestRequest::HitTestRequestType getHitTypeForGestureType(PlatformEvent::Type);
     void applyTouchAdjustment(PlatformGestureEvent*, HitTestResult*);
-    bool handleGestureTap(const GestureEventWithHitTestResults&);
-    bool handleGestureLongPress(const GestureEventWithHitTestResults&);
-    bool handleGestureLongTap(const GestureEventWithHitTestResults&);
-    bool handleGestureScrollUpdate(const PlatformGestureEvent&);
-    bool handleGestureScrollBegin(const PlatformGestureEvent&);
+    WebInputEventResult handleGestureTap(const GestureEventWithHitTestResults&);
+    WebInputEventResult handleGestureLongPress(const GestureEventWithHitTestResults&);
+    WebInputEventResult handleGestureLongTap(const GestureEventWithHitTestResults&);
+    WebInputEventResult handleGestureScrollUpdate(const PlatformGestureEvent&);
+    WebInputEventResult handleGestureScrollBegin(const PlatformGestureEvent&);
     void clearGestureScrollState();
 
     void updateGestureTargetNodeForMouseEvent(const GestureEventWithHitTestResults&);
 
     bool shouldApplyTouchAdjustment(const PlatformGestureEvent&) const;
 
     OptionalCursor selectCursor(const HitTestResult&);
     OptionalCursor selectAutoCursor(const HitTestResult&, Node*, const Cursor& iBeam);
 
     void hoverTimerFired(Timer<EventHandler>*);
@@ skipping 25 matching lines @@
 
     void customizedScroll(const Node& startNode, ScrollState&);
 
     HitTestResult hitTestResultInFrame(LocalFrame*, const LayoutPoint&, HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active);
 
     void invalidateClick();
 
     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&);
 
     // Returns true when the sent PE has defaultPrevented or defaultHandled set.
-    bool dispatchPointerEvent(Node* target, const AtomicString& eventType, const PlatformMouseEvent&, Node* relatedTarget = nullptr);
+    WebInputEventResult dispatchPointerEvent(Node* target, const AtomicString& eventType, const PlatformMouseEvent&, Node* relatedTarget = nullptr);
 
     // Dispatches mouseover, mouseout, mouseenter and mouseleave events to appropriate nodes when the mouse pointer moves from one node to another.
     void sendMouseEventsForNodeTransition(Node*, Node*, const PlatformMouseEvent&);
 
     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
 
-    bool dispatchMouseEvent(const AtomicString& eventType, Node* target, int clickCount, const PlatformMouseEvent&);
+    WebInputEventResult dispatchMouseEvent(const AtomicString& eventType, Node* target, int clickCount, const PlatformMouseEvent&);
 
     // 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?
     //     Same applied to dispatchMouseEvent() above.
-    bool updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* target,
+    WebInputEventResult updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* target,
         int clickCount, const PlatformMouseEvent&);
 
-    bool dispatchDragEvent(const AtomicString& eventType, Node* target, const PlatformMouseEvent&, DataTransfer*);
+    WebInputEventResult dispatchDragEvent(const AtomicString& eventType, Node* target, const PlatformMouseEvent&, DataTransfer*);
 
     void clearDragDataTransfer();
 
     bool handleDrag(const MouseEventWithHitTestResults&, DragInitiator);
     bool tryStartDrag(const MouseEventWithHitTestResults&);
     void clearDragState();
 
-    bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
+    WebInputEventResult dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
 
     bool dragHysteresisExceeded(const IntPoint&) const;
 
     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, LocalFrame* subframe);
     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, LocalFrame* subframe, HitTestResult* hoveredNode = nullptr);
     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, LocalFrame* subframe);
 
     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&);
 
-    bool passWheelEventToWidget(const PlatformWheelEvent&, Widget&);
+    WebInputEventResult passWheelEventToWidget(const PlatformWheelEvent&, Widget&);
     void defaultSpaceEventHandler(KeyboardEvent*);
     void defaultBackspaceEventHandler(KeyboardEvent*);
     void defaultTabEventHandler(KeyboardEvent*);
     void defaultEscapeEventHandler(KeyboardEvent*);
     void defaultArrowEventHandler(WebFocusType, KeyboardEvent*);
 
     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
 
     void setFrameWasScrolledByUser();
 
     bool capturesDragging() const { return m_capturesDragging; }
 
-    bool handleGestureShowPress();
+    WebInputEventResult handleGestureShowPress();
 
     bool handleScrollGestureOnResizer(Node*, const PlatformGestureEvent&);
 
-    bool passScrollGestureEventToWidget(const PlatformGestureEvent&, LayoutObject*);
+    WebInputEventResult passScrollGestureEventToWidget(const PlatformGestureEvent&, LayoutObject*);
 
     AutoscrollController* autoscrollController() const;
     bool panScrollInProgress() const;
     void setLastKnownMousePosition(const PlatformMouseEvent&);
 
     void conditionallyEnableMouseEventForPointerTypeMouse(const PlatformMouseEvent&);
 
     bool shouldTopControlsConsumeScroll(FloatSize) const;
 
     // If the given element is a shadow host and its root has delegatesFocus=false flag,
     // slide focus to its inner element. Returns true if the resulting focus is different from
     // the given element.
     bool slideFocusOnShadowHostIfNecessary(const Element&);
 
     void dispatchPointerEvents(const PlatformTouchEvent&, WillBeHeapVector<TouchInfo>&);
     void sendPointerCancels(WillBeHeapVector<TouchInfo>&);
 
-    bool dispatchTouchEvents(const PlatformTouchEvent&, WillBeHeapVector<TouchInfo>&, bool, bool);
+    WebInputEventResult dispatchTouchEvents(const PlatformTouchEvent&, WillBeHeapVector<TouchInfo>&, bool, bool);
 
     // NOTE: If adding a new field to this class please ensure that it is
     // cleared in |EventHandler::clear()|.
 
     const RawPtrWillBeMember<LocalFrame> m_frame;
 
     bool m_mousePressed;
     bool m_capturesDragging;
     RefPtrWillBeMember<Node> m_mousePressNode;
 
@@ skipping 93 matching lines @@
     // scroll which shouldn't propagate can't cause any element to
     // scroll other than the |m_previousGestureScrolledNode|.
     bool m_deltaConsumedForScrollSequence;
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::EventHandler::TouchInfo);
 
 #endif // EventHandler_h