Move GestureEvent to NewEventDispatcher

sky/engine/core/frame/NewEventHandler.cpp

 // Copyright 2015 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 "sky/engine/config.h"
 #include "sky/engine/core/frame/NewEventHandler.h"
 
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/NodeRenderingTraversal.h"
 #include "sky/engine/core/editing/Editor.h"
 #include "sky/engine/core/editing/FrameSelection.h"
 #include "sky/engine/core/editing/htmlediting.h"
+#include "sky/engine/core/events/GestureEvent.h"
 #include "sky/engine/core/events/PointerEvent.h"
 #include "sky/engine/core/frame/LocalFrame.h"
 #include "sky/engine/core/frame/FrameView.h"
 #include "sky/engine/core/page/EventWithHitTestResults.h"
 #include "sky/engine/core/rendering/RenderObject.h"
 #include "sky/engine/core/rendering/RenderView.h"
 #include "sky/engine/platform/geometry/FloatPoint.h"
 #include "sky/engine/public/platform/WebInputEvent.h"
 
 namespace blink {
 
 static VisiblePosition visiblePositionForHitTestResult(const HitTestResult& hitTestResult)
 {
     Node* innerNode = hitTestResult.innerNode();
     VisiblePosition position(innerNode->renderer()->positionForPoint(hitTestResult.localPoint()));
     if (!position.isNull())
         return position;
     return VisiblePosition(firstPositionInOrBeforeNode(innerNode), DOWNSTREAM);
 }
 
-static LayoutPoint positionForEvent(const WebPointerEvent& event)
+template<typename EventType>
+static LayoutPoint positionForEvent(const EventType& event)
 {
     return roundedLayoutPoint(FloatPoint(event.x, event.y));
 }
 
 NewEventHandler::NewEventHandler(LocalFrame& frame)
     : m_frame(frame)
 {
 }
 
 NewEventHandler::~NewEventHandler()
@@ skipping 20 matching lines @@
 }
 
 bool NewEventHandler::dispatchPointerEvent(Node& target, const WebPointerEvent& event)
 {
     RefPtr<PointerEvent> pointerEvent = PointerEvent::create(event);
     // TODO(abarth): Keep track of how many pointers are targeting the same node
     // and only mark the first one as primary.
     return target.dispatchEvent(pointerEvent.release());
 }
 
+bool NewEventHandler::dispatchGestureEvent(Node& target, const WebGestureEvent& event)
+{
+    RefPtr<GestureEvent> gestureEvent = GestureEvent::create(event);
+    return target.dispatchEvent(gestureEvent.release());
+}
+
 bool NewEventHandler::dispatchClickEvent(Node& capturingTarget, const WebPointerEvent& event)
 {
     ASSERT(event.type == WebInputEvent::PointerUp);
     HitTestResult hitTestResult = performHitTest(positionForEvent(event));
     Node* releaseTarget = targetForHitTestResult(hitTestResult);
     Node* clickTarget = NodeRenderingTraversal::commonAncestor(*releaseTarget, capturingTarget);
     if (!clickTarget)
         return true;
     // TODO(abarth): Make a proper gesture event that includes information from the event.
     return clickTarget->dispatchEvent(Event::createCancelableBubble(EventTypeNames::click));
@@ skipping 18 matching lines @@
     if (event.type == WebInputEvent::PointerDown)
         return handlePointerDownEvent(event);
     if (event.type == WebInputEvent::PointerUp)
         return handlePointerUpEvent(event);
     if (event.type == WebInputEvent::PointerMove)
         return handlePointerMoveEvent(event);
     ASSERT(event.type == WebInputEvent::PointerCancel);
     return handlePointerCancelEvent(event);
 }
 
+bool NewEventHandler::handleGestureEvent(const WebGestureEvent& event)
+{
+    HitTestResult hitTestResult = performHitTest(positionForEvent(event));
+    RefPtr<Node> target = targetForHitTestResult(hitTestResult);
+    return !dispatchGestureEvent(*target, event);
+}
+
 bool NewEventHandler::handlePointerDownEvent(const WebPointerEvent& event)
 {
     ASSERT(m_targetForPointer.find(event.pointer) == m_targetForPointer.end());
     HitTestResult hitTestResult = performHitTest(positionForEvent(event));
     RefPtr<Node> target = targetForHitTestResult(hitTestResult);
     m_targetForPointer[event.pointer] = target;
     bool eventSwallowed = !dispatchPointerEvent(*target, event);
     // TODO(abarth): Set the target for the pointer to something determined when
     // dispatching the event.
     updateSelectionForPointerDown(hitTestResult, event);
@@ skipping 21 matching lines @@
     return target && dispatchPointerEvent(*target.get(), event);
 }
 
 bool NewEventHandler::handlePointerCancelEvent(const WebPointerEvent& event)
 {
     RefPtr<Node> target = m_targetForPointer[event.pointer];
     return target && dispatchPointerEvent(*target, event);
 }
 
 }