Remove special wheel handling path from ScrollableArea

Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * 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.
@@ skipping 1698 matching lines @@
         Element* next = page->focusController().findFocusableElement(WebFocusTypeForward, *element.authorShadowRoot());
         if (next && element.containsIncludingShadowDOM(next)) {
             // Use WebFocusTypeForward instead of WebFocusTypeMouse here to mean the focus has slided.
             next->focus(false, WebFocusTypeForward);
             return true;
         }
     }
     return false;
 }
 
+namespace {
+
+ScrollResult scrollAreaWithWheelEvent(const PlatformWheelEvent& event, ScrollableArea& scrollableArea)
+{
+    float deltaX = event.railsMode() != PlatformEvent::RailsModeVertical ? event.deltaX() : 0;
+    float deltaY = event.railsMode() != PlatformEvent::RailsModeHorizontal ? event.deltaY() : 0;
+
+    ScrollGranularity granularity =
+        event.granularity() == ScrollByPixelWheelEvent ? ScrollByPixel : ScrollByPage;
+
+    // TODO(bokan): This should be moved out into Chromium or removed if possible.

[Rick Byers, 2015/08/19 19:42:09]

In particular, I can't imagine why CrOS and Mac should be different here.  Maybe
this code is fine but just shouldn't have an #if?

[bokan, 2015/08/25 17:53:22]

Ok, I've removed the #ifdef and it seems not to be breaking any tests.

+#if !OS(MACOSX)
+    if (event.hasPreciseScrollingDeltas() && granularity == ScrollByPixel)
+        granularity = ScrollByPrecisePixel;
+#endif
+
+    // If the event is a "PageWheelEvent" we should disregard the delta and
+    // scroll by *one* page length per event.
+    if (event.granularity() == ScrollByPageWheelEvent) {
+        if (deltaX)
+            deltaX = deltaX > 0 ? 1 : -1;
+        if (deltaY)
+            deltaY = deltaY > 0 ? 1 : -1;
+    }
+
+    // Positive delta is up and left.
+    ScrollResultOneDimensional resultY = scrollableArea.userScroll(ScrollUp, granularity, deltaY);
+    ScrollResultOneDimensional resultX = scrollableArea.userScroll(ScrollLeft, granularity, deltaX);
+
+    ScrollResult result;
+    result.didScrollY = resultY.didScroll;
+    result.didScrollX = resultX.didScroll;
+    result.unusedScrollDeltaY = resultY.unusedScrollDelta;
+    result.unusedScrollDeltaX = resultX.unusedScrollDelta;
+    return result;
+}
+
+} // namespace
+
 bool EventHandler::handleWheelEvent(const PlatformWheelEvent& event)
 {
 #define RETURN_WHEEL_EVENT_HANDLED() \
     { \
         setFrameWasScrolledByUser(); \
         return true; \
     }
 
     Document* doc = m_frame->document();
 
@@ skipping 37 matching lines @@
         if (node && !node->dispatchWheelEvent(event))
             RETURN_WHEEL_EVENT_HANDLED();
     }
 
     // We do another check on the frame view because the event handler can run
     // JS which results in the frame getting destroyed.
     view = m_frame->view();
     if (!view)
         return false;
 
-    ScrollResult scrollResult = view->scrollableArea()->handleWheel(event);
+    // Wheel events which do not scroll are used to trigger zooming.
+    if (!event.canScroll())
+        return false;
+
+    ScrollResult scrollResult = scrollAreaWithWheelEvent(event, *view->scrollableArea());
     if (m_frame->settings() && m_frame->settings()->reportWheelOverscroll())
         handleOverscroll(scrollResult);
     if (scrollResult.didScroll())
         RETURN_WHEEL_EVENT_HANDLED();
 
     return false;
 #undef RETURN_WHEEL_EVENT_HANDLED
 }
 
 void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEvent)
@@ skipping 2209 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink