Fix missing fields in GestureScrollBegin/Update/End event conversions.

third_party/WebKit/Source/web/WebInputEventConversion.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 #include "core/frame/VisualViewport.h"
 #include "core/layout/LayoutObject.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/KeyboardCodes.h"
 #include "platform/Widget.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
-static float scaleDeltaToWindow(const Widget* widget, float delta)
+namespace {
+float scaleDeltaToWindow(const Widget* widget, float delta)
 {
     float scale = 1;
     if (widget) {
         FrameView* rootView = toFrameView(widget->root());
         if (rootView)
             scale = rootView->inputEventsScaleFactor();
     }
     return delta / scale;
 }
 
-static FloatSize scaleSizeToWindow(const Widget* widget, FloatSize size)
+FloatSize scaleSizeToWindow(const Widget* widget, FloatSize size)
 {
     return FloatSize(scaleDeltaToWindow(widget, size.width()), scaleDeltaToWindow(widget, size.height()));
 }
 
 // This method converts from the renderer's coordinate space into Blink's root frame coordinate space.
 // It's somewhat unique in that it takes into account DevTools emulation, which applies a scale and offset
 // in the root layer (see updateRootLayerTransform in WebViewImpl) as well as the overscroll effect on OSX.
 // This is in addition to the visual viewport "pinch-zoom" transformation and is one of the few cases where
 // the visual viewport is not equal to the renderer's coordinate-space.
-static FloatPoint convertHitPointToRootFrame(const Widget* widget, FloatPoint pointInRendererViewport)
+FloatPoint convertHitPointToRootFrame(const Widget* widget, FloatPoint pointInRendererViewport)
 {
     float scale = 1;
     IntSize offset;
     IntPoint visualViewport;
     FloatSize overscrollOffset;
     if (widget) {
         FrameView* rootView = toFrameView(widget->root());
         if (rootView) {
             scale = rootView->inputEventsScaleFactor();
             offset = rootView->inputEventsOffsetForEmulation();
             visualViewport = flooredIntPoint(rootView->page()->frameHost().visualViewport().visibleRect().location());
             overscrollOffset = rootView->page()->frameHost().chromeClient().elasticOverscroll();
         }
     }
     return FloatPoint(
         (pointInRendererViewport.x() - offset.width()) / scale + visualViewport.x() + overscrollOffset.width(),
         (pointInRendererViewport.y() - offset.height()) / scale + visualViewport.y() + overscrollOffset.height());
 }
 
-static unsigned toPlatformModifierFrom(WebMouseEvent::Button button)
+unsigned toPlatformModifierFrom(WebMouseEvent::Button button)
 {
     if (button == WebMouseEvent::ButtonNone)
         return 0;
 
     unsigned webMouseButtonToPlatformModifier[] = {
         PlatformEvent::LeftButtonDown,
         PlatformEvent::MiddleButtonDown,
         PlatformEvent::RightButtonDown
     };
 
     return webMouseButtonToPlatformModifier[button];
 }
 
+ScrollGranularity toPlatformScrollGranularity(WebGestureEvent::ScrollUnits units)
+{
+    switch (units) {
+    case WebGestureEvent::ScrollUnits::PrecisePixels:
+        return ScrollGranularity::ScrollByPrecisePixel;
+    case WebGestureEvent::ScrollUnits::Pixels:
+        return ScrollGranularity::ScrollByPixel;
+    case WebGestureEvent::ScrollUnits::Page:
+        return ScrollGranularity::ScrollByPage;
+    default:
+        ASSERT_NOT_REACHED();
+        return ScrollGranularity::ScrollByPrecisePixel;
+    }
+}
+
+WebGestureEvent::ScrollUnits toWebGestureScrollUnits(ScrollGranularity granularity)
+{
+    switch (granularity) {
+    case ScrollGranularity::ScrollByPrecisePixel:
+        return WebGestureEvent::ScrollUnits::PrecisePixels;
+    case ScrollGranularity::ScrollByPixel:
+        return WebGestureEvent::ScrollUnits::Pixels;
+    case ScrollGranularity::ScrollByPage:
+        return WebGestureEvent::ScrollUnits::Page;
+    default:
+        ASSERT_NOT_REACHED();
+        return WebGestureEvent::ScrollUnits::PrecisePixels;
+    }
+}
+
+} // namespace
+
 // MakePlatformMouseEvent -----------------------------------------------------
 
 // TODO(mustaq): Add tests for this.
 PlatformMouseEventBuilder::PlatformMouseEventBuilder(Widget* widget, const WebMouseEvent& e)
 {
     // FIXME: Widget is always toplevel, unless it's a popup. We may be able
     // to get rid of this once we abstract popups into a WebKit API.
     m_position = widget->convertFromRootFrame(flooredIntPoint(convertHitPointToRootFrame(widget, IntPoint(e.x, e.y))));
     m_globalPosition = IntPoint(e.globalX, e.globalY);
     m_movementDelta = IntPoint(scaleDeltaToWindow(widget, e.movementX), scaleDeltaToWindow(widget, e.movementY));
@@ skipping 61 matching lines @@
 }
 
 // PlatformGestureEventBuilder --------------------------------------------------
 
 PlatformGestureEventBuilder::PlatformGestureEventBuilder(Widget* widget, const WebGestureEvent& e)
 {
     switch (e.type) {
     case WebInputEvent::GestureScrollBegin:
         m_type = PlatformEvent::GestureScrollBegin;
         m_data.m_scroll.m_resendingPluginId = e.resendingPluginId;
+        m_data.m_scroll.m_deltaX = e.data.scrollBegin.deltaXHint;
+        m_data.m_scroll.m_deltaY = e.data.scrollBegin.deltaYHint;
+        m_data.m_scroll.m_deltaUnits = toPlatformScrollGranularity(e.data.scrollBegin.deltaHintUnits);
+        m_data.m_scroll.m_inertial = e.data.scrollBegin.inertial;
+        m_data.m_scroll.m_synthetic = e.data.scrollBegin.synthetic;
         break;
     case WebInputEvent::GestureScrollEnd:
         m_type = PlatformEvent::GestureScrollEnd;
         m_data.m_scroll.m_resendingPluginId = e.resendingPluginId;
+        m_data.m_scroll.m_deltaUnits = toPlatformScrollGranularity(e.data.scrollEnd.deltaUnits);
+        m_data.m_scroll.m_inertial = e.data.scrollEnd.inertial;
+        m_data.m_scroll.m_synthetic = e.data.scrollEnd.synthetic;
         break;
     case WebInputEvent::GestureFlingStart:
         m_type = PlatformEvent::GestureFlingStart;
         m_data.m_scroll.m_velocityX = e.data.flingStart.velocityX;
         m_data.m_scroll.m_velocityY = e.data.flingStart.velocityY;
         break;
     case WebInputEvent::GestureScrollUpdate:
         m_type = PlatformEvent::GestureScrollUpdate;
         m_data.m_scroll.m_resendingPluginId = e.resendingPluginId;
         m_data.m_scroll.m_deltaX = scaleDeltaToWindow(widget, e.data.scrollUpdate.deltaX);
         m_data.m_scroll.m_deltaY = scaleDeltaToWindow(widget, e.data.scrollUpdate.deltaY);
         m_data.m_scroll.m_velocityX = e.data.scrollUpdate.velocityX;
         m_data.m_scroll.m_velocityY = e.data.scrollUpdate.velocityY;
         m_data.m_scroll.m_preventPropagation = e.data.scrollUpdate.preventPropagation;
         m_data.m_scroll.m_inertial = e.data.scrollUpdate.inertial;
-        switch (e.data.scrollUpdate.deltaUnits) {
-        case WebGestureEvent::ScrollUnits::PrecisePixels:
-            m_data.m_scroll.m_deltaUnits = ScrollGranularity::ScrollByPrecisePixel;
-            break;
-        case WebGestureEvent::ScrollUnits::Pixels:
-            m_data.m_scroll.m_deltaUnits = ScrollGranularity::ScrollByPixel;
-            break;
-        case WebGestureEvent::ScrollUnits::Page:
-            m_data.m_scroll.m_deltaUnits = ScrollGranularity::ScrollByPage;
-            break;
-        default:
-            ASSERT_NOT_REACHED();
-        }
+        m_data.m_scroll.m_deltaUnits = toPlatformScrollGranularity(e.data.scrollUpdate.deltaUnits);
         break;
     case WebInputEvent::GestureTap:
         m_type = PlatformEvent::GestureTap;
         m_area = expandedIntSize(scaleSizeToWindow(widget, FloatSize(e.data.tap.width, e.data.tap.height)));
         m_data.m_tap.m_tapCount = e.data.tap.tapCount;
         break;
     case WebInputEvent::GestureTapUnconfirmed:
         m_type = PlatformEvent::GestureTapUnconfirmed;
         m_area = expandedIntSize(scaleSizeToWindow(widget, FloatSize(e.data.tap.width, e.data.tap.height)));
         break;
@@ skipping 475 matching lines @@
 {
     if (event.type() == EventTypeNames::gestureshowpress) {
         type = GestureShowPress;
     } else if (event.type() == EventTypeNames::gesturelongpress) {
         type = GestureLongPress;
     } else if (event.type() == EventTypeNames::gesturetapdown) {
         type = GestureTapDown;
     } else if (event.type() == EventTypeNames::gesturescrollstart) {
         type = GestureScrollBegin;
         resendingPluginId = event.resendingPluginId();
+        data.scrollBegin.deltaXHint = event.deltaX();
+        data.scrollBegin.deltaYHint = event.deltaY();
+        data.scrollBegin.deltaHintUnits = toWebGestureScrollUnits(event.deltaUnits());
+        data.scrollBegin.inertial = event.inertial();
+        data.scrollBegin.synthetic = event.synthetic();
     } else if (event.type() == EventTypeNames::gesturescrollend) {
         type = GestureScrollEnd;
         resendingPluginId = event.resendingPluginId();
+        data.scrollEnd.deltaUnits = toWebGestureScrollUnits(event.deltaUnits());
+        data.scrollEnd.inertial = event.inertial();
+        data.scrollEnd.synthetic = event.synthetic();
     } else if (event.type() == EventTypeNames::gesturescrollupdate) {
         type = GestureScrollUpdate;
+        data.scrollUpdate.deltaUnits = toWebGestureScrollUnits(event.deltaUnits());
         data.scrollUpdate.deltaX = event.deltaX();
         data.scrollUpdate.deltaY = event.deltaY();
         data.scrollUpdate.inertial = event.inertial();
         resendingPluginId = event.resendingPluginId();
     } else if (event.type() == EventTypeNames::gestureflingstart) {
         type = GestureFlingStart;
         data.flingStart.velocityX = event.velocityX();
         data.flingStart.velocityY = event.velocityY();
     } else if (event.type() == EventTypeNames::gesturetap) {
         type = GestureTap;
@@ skipping 15 matching lines @@
         break;
     case GestureSourceTouchscreen:
         sourceDevice = WebGestureDeviceTouchscreen;
         break;
     case GestureSourceUninitialized:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace blink