Add wheel support to sky-scrollable

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/KeyboardEvent.h"
 #include "sky/engine/core/events/PointerEvent.h"
+#include "sky/engine/core/events/WheelEvent.h"
 #include "sky/engine/core/frame/LocalFrame.h"
 #include "sky/engine/core/frame/FrameView.h"
 #include "sky/engine/core/rendering/RenderObject.h"
 #include "sky/engine/core/rendering/RenderView.h"
 #include "sky/engine/platform/KeyboardCodes.h"
 #include "sky/engine/platform/geometry/FloatPoint.h"
 #include "sky/engine/public/platform/WebInputEvent.h"
 
 namespace blink {
 
@@ skipping 62 matching lines @@
     RefPtr<GestureEvent> gestureEvent = GestureEvent::create(event);
     return target.dispatchEvent(gestureEvent.release());
 }
 
 bool NewEventHandler::dispatchKeyboardEvent(Node& target, const WebKeyboardEvent& event)
 {
     RefPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(event);
     return target.dispatchEvent(keyboardEvent.release());
 }
 
+bool NewEventHandler::dispatchWheelEvent(Node& target, const WebWheelEvent& event)
+{
+    RefPtr<WheelEvent> wheelEvent = WheelEvent::create(event);
+    return target.dispatchEvent(wheelEvent.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 52 matching lines @@
     // If the keydown event was handled, we don't want to "generate" a keypress
     // event for that keystroke. However, we'll receive a Char event from the
     // embedder regardless, so we set m_suppressNextCharEvent, will will prevent
     // us from dispatching the keypress event when we receive that Char event.
     if (handled && event.type == WebInputEvent::KeyDown)
         m_suppressNextCharEvent = true;
 
     return handled;
 }
 
+bool NewEventHandler::handleWheelEvent(const WebWheelEvent& event)
+{
+    HitTestResult hitTestResult = performHitTest(positionForEvent(event));
+    RefPtr<Node> target = targetForHitTestResult(hitTestResult);
+    return target && !dispatchWheelEvent(*target, event);
+}
+
 bool NewEventHandler::handlePointerDownEvent(const WebPointerEvent& event)
 {
     // In principle, we shouldn't get another pointer down for the same
     // pointer ID, but for mice, we don't get a pointer cancel when you
     // drag outside the window frame on Linux. For now, send the pointer
     // cancel at this point.
     if (event.kind == WebPointerEvent::Mouse
         && m_targetForPointer.find(event.pointer) != m_targetForPointer.end()) {
         WebPointerEvent fakeCancel = event;
         fakeCancel.type = WebInputEvent::PointerCancel;
@@ skipping 45 matching lines @@
     auto it = m_targetForPointer.find(event.pointer);
     if (it == m_targetForPointer.end())
         return false;
     RefPtr<Node> target = it->second;
     m_targetForPointer.erase(it);
     ASSERT(target);
     return dispatchPointerEvent(*target, event);
 }
 
 }