Remove PlatformGestureEvent in favour of using WebGestureEvent

third_party/WebKit/Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 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 80 matching lines @@
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "modules/credentialmanager/CredentialManagerClient.h"
 #include "modules/encryptedmedia/MediaKeysController.h"
 #include "modules/storage/StorageNamespaceController.h"
 #include "modules/webgl/WebGLRenderingContext.h"
 #include "platform/ContextMenu.h"
 #include "platform/ContextMenuItem.h"
 #include "platform/Cursor.h"
 #include "platform/Histogram.h"
 #include "platform/KeyboardCodes.h"
-#include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/exported/WebActiveGestureAnimation.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/CompositorMutatorClient.h"
 #include "platform/graphics/FirstPaintInvalidationTracking.h"
 #include "platform/graphics/GraphicsContext.h"
@@ skipping 609 matching lines @@
               event.sourceDevice,
               WebFloatPoint(event.data.flingStart.velocityX,
                             event.data.flingStart.velocityY),
               WebSize()));
       DCHECK(flingCurve);
       m_gestureAnimation = WebActiveGestureAnimation::createAtAnimationStart(
           std::move(flingCurve), this);
       mainFrameImpl()->frameWidget()->scheduleAnimation();
       eventResult = WebInputEventResult::HandledSystem;
 
+      WebGestureEvent scaledEvent =
+          ScaleWebGestureEvent(mainFrameImpl()->frameView(), event);

[majidvp, 2016/12/15 17:40:46]

One thing that we are going to miss when we remove PlatformGestureEvent is that
previously any function which received a Platform event knew that the event was
properly scaled. Now it is possible to pass in an unscaled event by mistake.

Can we add that safety back in somehow?
I was thinking to perhaps have a private boolean field in WebGestureEvent that
we set in ScaleWebGestureEvent and 
ASSERT on places where we would have previously take in a
Platform type. This can all be behind a DCHECK to avoid cost.

[dtapuska, 2016/12/15 21:29:39]

I've adjusted the framescale to be zero based which will cause a div0 exception
if someone uses it inappropriately. I've also added a dcheck in event handler.

[majidvp, 2016/12/15 21:45:36]

Neat trick. 

       // Plugins may need to see GestureFlingStart to balance
       // GestureScrollBegin (since the former replaces GestureScrollEnd when
       // transitioning to a fling).
-      PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(),
-                                                event);
       // TODO(dtapuska): Why isn't the response used?
       mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(
-          platformEvent);
+          scaledEvent);
 
       m_client->didHandleGestureEvent(event, eventCancelled);
       return WebInputEventResult::HandledSystem;
     }
     case WebInputEvent::GestureFlingCancel:
       if (endActiveFlingAnimation())
         eventResult = WebInputEventResult::HandledSuppressed;
 
       m_client->didHandleGestureEvent(event, eventCancelled);
       return eventResult;
     default:
       break;
   }
 
-  PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(),
-                                            event);
+  WebGestureEvent scaledEvent =
+      ScaleWebGestureEvent(mainFrameImpl()->frameView(), event);
 
   // Special handling for double tap and scroll events as we don't want to
   // hit test for them.
   switch (event.type) {
     case WebInputEvent::GestureDoubleTap:
       if (m_webSettings->doubleTapToZoomEnabled() &&
           minimumPageScaleFactor() != maximumPageScaleFactor()) {
         m_client->cancelScheduledContentIntents();
-        animateDoubleTapZoom(platformEvent.position());
+        animateDoubleTapZoom(
+            flooredIntPoint(scaledEvent.positionInRootFrame()));
       }
       // GestureDoubleTap is currently only used by Android for zooming. For
       // WebCore, GestureTap with tap count = 2 is used instead. So we drop
       // GestureDoubleTap here.
       eventResult = WebInputEventResult::HandledSystem;
       m_client->didHandleGestureEvent(event, eventCancelled);
       return eventResult;
     case WebInputEvent::GestureScrollBegin:
       m_client->cancelScheduledContentIntents();
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureScrollUpdate:
     case WebInputEvent::GestureFlingStart:
       // Scrolling-related gesture events invoke EventHandler recursively for
       // each frame down the chain, doing a single-frame hit-test per frame.
       // This matches handleWheelEvent.  Perhaps we could simplify things by
       // rewriting scroll handling to work inner frame out, and then unify with
       // other gesture events.
       eventResult =
           mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(
-              platformEvent);
+              scaledEvent);
       m_client->didHandleGestureEvent(event, eventCancelled);
       return eventResult;
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::GesturePinchUpdate:
       return WebInputEventResult::NotHandled;
     default:
       break;
   }
 
   // Hit test across all frames and do touch adjustment as necessary for the
   // event type.
   GestureEventWithHitTestResults targetedEvent =
       m_page->deprecatedLocalMainFrame()->eventHandler().targetGestureEvent(
-          platformEvent);
+          scaledEvent);
 
   // Handle link highlighting outside the main switch to avoid getting lost in
   // the complicated set of cases handled below.
   switch (event.type) {
     case WebInputEvent::GestureShowPress:
       // Queue a highlight animation, then hand off to regular handler.
       enableTapHighlightAtPoint(targetedEvent);
       break;
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTap:
@@ skipping 1141 matching lines @@
 
   // Create synthetic wheel events as necessary for fling.
   if (m_gestureAnimation) {
     if (m_gestureAnimation->animate(lastFrameTimeMonotonic))
       mainFrameImpl()->frameWidget()->scheduleAnimation();
     else {
       DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
       WebGestureDevice lastFlingSourceDevice = m_flingSourceDevice;
       endActiveFlingAnimation();
 
-      PlatformGestureEvent endScrollEvent(
-          PlatformEvent::GestureScrollEnd, m_positionOnFlingStart,
-          m_globalPositionOnFlingStart, IntSize(), TimeTicks(),
-          PlatformEvent::NoModifiers,
-          lastFlingSourceDevice == WebGestureDeviceTouchpad
-              ? PlatformGestureSourceTouchpad
-              : PlatformGestureSourceTouchscreen);
-      endScrollEvent.setScrollGestureData(0, 0, ScrollByPrecisePixel, 0, 0,
-                                          ScrollInertialPhaseMomentum, false,
-                                          -1 /* null plugin id */);
-
+      WebGestureEvent endScrollEvent = createGestureScrollEventFromFling(
+          WebInputEvent::GestureScrollEnd, lastFlingSourceDevice);
       mainFrameImpl()->frame()->eventHandler().handleGestureScrollEnd(
           endScrollEvent);
     }
   }
 
   if (!mainFrameImpl())
     return;
 
   m_lastFrameTimeMonotonic = lastFrameTimeMonotonic;
 
@@ skipping 1820 matching lines @@
   WebGestureEvent tapEvent;
   tapEvent.x = tapPointWindowPos.x;
   tapEvent.y = tapPointWindowPos.y;
   tapEvent.type = WebInputEvent::GestureTap;
   // GestureTap is only ever from a touchscreen.
   tapEvent.sourceDevice = WebGestureDeviceTouchscreen;
   tapEvent.data.tap.tapCount = 1;
   tapEvent.data.tap.width = tapArea.width;
   tapEvent.data.tap.height = tapArea.height;
 
-  PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(),
-                                            tapEvent);
+  WebGestureEvent scaledEvent =
+      ScaleWebGestureEvent(mainFrameImpl()->frameView(), tapEvent);
 
   HitTestResult result =
       m_page->deprecatedLocalMainFrame()
           ->eventHandler()
           .hitTestResultForGestureEvent(
-              platformEvent, HitTestRequest::ReadOnly | HitTestRequest::Active)
+              scaledEvent, HitTestRequest::ReadOnly | HitTestRequest::Active)
           .hitTestResult();
 
   result.setToShadowHostIfInUserAgentShadowRoot();
   return result;
 }
 
 void WebViewImpl::setTabsToLinks(bool enable) {
   m_tabsToLinks = enable;
 }
 
@@ skipping 385 matching lines @@
   if (focusedFrame->localFrameRoot() != mainFrameImpl()->frame())
     return nullptr;
   return focusedFrame;
 }
 
 LocalFrame* WebViewImpl::focusedLocalFrameAvailableForIme() const {
   return m_imeAcceptEvents ? focusedLocalFrameInWidget() : nullptr;
 }
 
 }  // namespace blink