Pass the physical scroll delta through the scroll customization path.

third_party/WebKit/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 2362 matching lines @@
     if (unusedDelta != FloatSize()) {
         m_accumulatedRootOverscroll += unusedDelta;
         m_frame->chromeClient().didOverscroll(unusedDelta, m_accumulatedRootOverscroll, position, velocity);
     }
 }
 
 WebInputEventResult EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
-    // TODO(bokan): This delta is specific to the event which is positive up and
-    // to the left. Since we're passing it into a bunch of scrolling code below,
-    // it should probably be inverted here.
-    FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
+    // Negate the deltas since the gesture event stores finger movement and
+    // scrolling occurs in the direction opposite the finger's movement
+    // direction. e.g. Finger moving up has negative event delta but causes the
+    // page to scroll down causing positive scroll delta.
+    FloatSize delta(-gestureEvent.deltaX(), -gestureEvent.deltaY());
+    FloatSize velocity(-gestureEvent.velocityX(), -gestureEvent.velocityY());
     if (delta.isZero())
         return WebInputEventResult::NotHandled;
 
     ScrollGranularity granularity = gestureEvent.deltaUnits();
     Node* node = m_scrollGestureHandlingNode.get();
 
     // Scroll customization is only available for touch.
     bool handleScrollCustomization = RuntimeEnabledFeatures::scrollCustomizationEnabled() && gestureEvent.source() == PlatformGestureSourceTouchscreen;
     if (node) {
         LayoutObject* layoutObject = node->layoutObject();
@@ skipping 13 matching lines @@
             }
             // FIXME: we should allow simultaneous scrolling of nested
             // iframes along perpendicular axes. See crbug.com/466991.
             m_deltaConsumedForScrollSequence = true;
             return result;
         }
 
         bool scrolled = false;
         if (handleScrollCustomization) {
             OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
-            scrollStateData->delta_x = gestureEvent.deltaX();
-            scrollStateData->delta_y = gestureEvent.deltaY();
-            scrollStateData->velocity_x = gestureEvent.velocityX();
-            scrollStateData->velocity_y = gestureEvent.velocityY();
+            scrollStateData->delta_x = delta.width();
+            scrollStateData->delta_y = delta.height();
+            scrollStateData->velocity_x = velocity.width();
+            scrollStateData->velocity_y = velocity.height();
             scrollStateData->should_propagate = !gestureEvent.preventPropagation();
             scrollStateData->is_in_inertial_phase = gestureEvent.inertial();
             scrollStateData->from_user_input = true;
             scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
             RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
             if (m_previousGestureScrolledNode) {
                 // The ScrollState needs to know what the current
                 // native scrolling element is, so that for an
                 // inertial scroll that shouldn't propagate, only the
                 // currently scrolling element responds.
                 ASSERT(m_previousGestureScrolledNode->isElementNode());
                 scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
             }
             customizedScroll(*node, *scrollState);
             m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
             m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
-            scrolled = scrollState->deltaX() != gestureEvent.deltaX()
-                || scrollState->deltaY() != gestureEvent.deltaY();
+            scrolled = scrollState->deltaX() != delta.width()
+                || scrollState->deltaY() != delta.height();
         } else {
             Node* stopNode = nullptr;
             if (gestureEvent.preventPropagation())
                 stopNode = m_previousGestureScrolledNode.get();
 
-            // Scale by -1 because the delta is the GestureEvent delta (see TODO at top of function).
-            ScrollResult result = physicalScroll(granularity, delta.scaledBy(-1), node, &stopNode);
+            ScrollResult result = physicalScroll(granularity, delta, node, &stopNode);
 
             scrolled = result.didScroll();
 
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = stopNode;
 
             resetOverscroll(result.didScrollX, result.didScrollY);
         }
         if (scrolled) {
             setFrameWasScrolledByUser();
             return WebInputEventResult::HandledSystem;
         }
     }
 
     if (handleScrollCustomization)
         return WebInputEventResult::NotHandled;
 
     // Try to scroll the frame view.
     ScrollResult scrollResult = m_frame->applyScrollDelta(granularity, delta, false);
     if (m_frame->isMainFrame()) {
         FloatPoint position = FloatPoint(gestureEvent.position().x(), gestureEvent.position().y());
-        FloatSize velocity = FloatSize(gestureEvent.velocityX(), gestureEvent.velocityY());
         handleOverscroll(scrollResult, position, velocity);
     }
     if (scrollResult.didScroll()) {
         setFrameWasScrolledByUser();
         return WebInputEventResult::HandledSystem;
     }
 
     return WebInputEventResult::NotHandled;
 }
 
@@ skipping 1513 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink