Remove PlatformGestureEvent in favour of using WebGestureEvent

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 26 matching lines @@
 #include "core/page/DragActions.h"
 #include "core/page/EventWithHitTestResults.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/Cursor.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformTouchPoint.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollTypes.h"
+#include "public/platform/WebGestureEvent.h"
 #include "public/platform/WebInputEvent.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 ContainerNode;
 class DataTransfer;
 class PaintLayer;
 class Element;
 class Event;
 class EventTarget;
 template <typename EventType>
 class EventWithHitTestResults;
 class FloatQuad;
 class FrameHost;
 class HTMLFrameSetElement;
 class HitTestRequest;
 class HitTestResult;
 class LayoutObject;
 class LocalFrame;
 class Node;
 class OptionalCursor;
-class PlatformGestureEvent;
 class PlatformTouchEvent;
 class PlatformWheelEvent;
 class ScrollableArea;
 class Scrollbar;
 class SelectionController;
 class TextEvent;
 class WheelEvent;
 
 class CORE_EXPORT EventHandler final
     : public GarbageCollectedFinalized<EventHandler> {
@@ skipping 60 matching lines @@
   WebInputEventResult handleMouseMoveEvent(
       const PlatformMouseEvent&,
       const Vector<PlatformMouseEvent>& coalescedEvents);
   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 WebGestureEvent&);
   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&,
+  GestureEventWithHitTestResults targetGestureEvent(const WebGestureEvent&,
                                                     bool readOnly = false);
   GestureEventWithHitTestResults hitTestResultForGestureEvent(
-      const PlatformGestureEvent&,
+      const WebGestureEvent&,
       HitTestRequest::HitTestRequestType);
   // 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.
-  WebInputEventResult handleGestureScrollEvent(const PlatformGestureEvent&);
-  WebInputEventResult handleGestureScrollEnd(const PlatformGestureEvent&);
+  WebInputEventResult handleGestureScrollEvent(const WebGestureEvent&);
+  WebInputEventResult handleGestureScrollEnd(const WebGestureEvent&);
   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?
@@ skipping 70 matching lines @@
  private:
   WebInputEventResult handleMouseMoveOrLeaveEvent(
       const PlatformMouseEvent&,
       const Vector<PlatformMouseEvent>&,
       HitTestResult* hoveredNode = nullptr,
       bool onlyUpdateScrollbars = false,
       bool forceLeave = false);
 
   HitTestRequest::HitTestRequestType getHitTypeForGestureType(
       PlatformEvent::EventType);
-  void applyTouchAdjustment(PlatformGestureEvent*, HitTestResult*);
+  void applyTouchAdjustment(WebGestureEvent*, HitTestResult*);
   WebInputEventResult handleGestureTapDown(
       const GestureEventWithHitTestResults&);
   WebInputEventResult handleGestureTap(const GestureEventWithHitTestResults&);
   WebInputEventResult handleGestureLongPress(
       const GestureEventWithHitTestResults&);
   WebInputEventResult handleGestureLongTap(
       const GestureEventWithHitTestResults&);
 
   void updateGestureTargetNodeForMouseEvent(
       const GestureEventWithHitTestResults&);
 
-  bool shouldApplyTouchAdjustment(const PlatformGestureEvent&) const;
+  bool shouldApplyTouchAdjustment(const WebGestureEvent&) const;
 
   OptionalCursor selectCursor(const HitTestResult&);
   OptionalCursor selectAutoCursor(const HitTestResult&,
                                   Node*,
                                   const Cursor& iBeam);
 
   void hoverTimerFired(TimerBase*);
   void cursorUpdateTimerFired(TimerBase*);
   void activeIntervalTimerFired(TimerBase*);
 
@@ skipping 93 matching lines @@
 
   // 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