Remove PlatformTouchEvent/Point and use WebTouchEvent/Point instead

third_party/WebKit/Source/core/inspector/InspectorInputAgent.cpp

 /*
  * Copyright (C) 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 18 matching lines @@
  */
 
 #include "core/inspector/InspectorInputAgent.h"
 
 #include "core/frame/FrameView.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/PlatformEvent.h"
-#include "platform/PlatformTouchEvent.h"
-#include "platform/PlatformTouchPoint.h"
 #include "platform/geometry/FloatSize.h"
 #include "platform/geometry/IntPoint.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/IntSize.h"
+#include "public/platform/WebTouchEvent.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/Time.h"
 
 namespace {
 
 enum Modifiers {
   AltKey = 1 << 0,
   CtrlKey = 1 << 1,
   MetaKey = 1 << 2,
   ShiftKey = 1 << 3
@@ skipping 22 matching lines @@
   // for the duration of the application.
   static double epochToMonotonicTimeDelta =
       currentTime() - monotonicallyIncreasingTime();
   if (timestamp.isJust()) {
     double ticksInSeconds = timestamp.fromJust() - epochToMonotonicTimeDelta;
     return TimeTicks::FromSeconds(ticksInSeconds);
   }
   return TimeTicks::Now();
 }
 
-class SyntheticInspectorTouchPoint : public blink::PlatformTouchPoint {
+class SyntheticInspectorTouchPoint : public blink::WebTouchPoint {
  public:
-  SyntheticInspectorTouchPoint(int id,
-                               TouchState state,
+  SyntheticInspectorTouchPoint(int idParam,
+                               State stateParam,
                                const blink::IntPoint& screenPos,
                                const blink::IntPoint& pos,
-                               int radiusX,
-                               int radiusY,
-                               double rotationAngle,
-                               double force) {
-    m_pointerProperties.id = id;
-    m_screenPos = screenPos;
-    m_pos = pos;
-    m_state = state;
-    m_radius = blink::FloatSize(radiusX, radiusY);
-    m_rotationAngle = rotationAngle;
-    m_pointerProperties.force = force;
+                               int radiusXParam,
+                               int radiusYParam,
+                               double rotationAngleParam,
+                               double forceParam) {
+    id = idParam;
+    screenPosition = screenPos;
+    position = pos;
+    state = stateParam;
+    radiusX = radiusXParam;
+    radiusY = radiusYParam;
+    rotationAngle = rotationAngleParam;
+    force = forceParam;
   }
 };
 
-class SyntheticInspectorTouchEvent : public blink::PlatformTouchEvent {
+class SyntheticInspectorTouchEvent : public blink::WebTouchEvent {
  public:
-  SyntheticInspectorTouchEvent(const blink::PlatformEvent::EventType type,
+  SyntheticInspectorTouchEvent(const blink::WebInputEvent::Type type,
                                unsigned modifiers,
                                TimeTicks timestamp) {
     m_type = type;
     m_modifiers = modifiers;
-    m_timestamp = timestamp;
+    m_timeStampSeconds = timestamp.InSeconds();
   }
 
-  void append(const blink::PlatformTouchPoint& point) {
-    m_touchPoints.push_back(point);
+  void append(const blink::WebTouchPoint& point) {
+    if (touchesLength < kTouchesLengthCap) {
+      touches[touchesLength] = point;
+      touchesLength++;
+    }
   }
 };
 
 void ConvertInspectorPoint(blink::LocalFrame* frame,
                            const blink::IntPoint& pointInFrame,
                            blink::IntPoint* convertedPoint,
                            blink::IntPoint* globalPoint) {
   *convertedPoint = frame->view()->convertToRootFrame(pointInFrame);
   *globalPoint =
       frame->page()
@@ skipping 10 matching lines @@
 InspectorInputAgent::InspectorInputAgent(InspectedFrames* inspectedFrames)
     : m_inspectedFrames(inspectedFrames) {}
 
 InspectorInputAgent::~InspectorInputAgent() {}
 
 Response InspectorInputAgent::dispatchTouchEvent(
     const String& type,
     std::unique_ptr<protocol::Array<protocol::Input::TouchPoint>> touchPoints,
     protocol::Maybe<int> modifiers,
     protocol::Maybe<double> timestamp) {
-  PlatformEvent::EventType convertedType;
+  WebInputEvent::Type convertedType;
   if (type == "touchStart")
-    convertedType = PlatformEvent::TouchStart;
+    convertedType = WebInputEvent::TouchStart;
   else if (type == "touchEnd")
-    convertedType = PlatformEvent::TouchEnd;
+    convertedType = WebInputEvent::TouchEnd;
   else if (type == "touchMove")
-    convertedType = PlatformEvent::TouchMove;
+    convertedType = WebInputEvent::TouchMove;
   else
     return Response::Error(String("Unrecognized type: " + type));
 
   unsigned convertedModifiers = GetEventModifiers(modifiers.fromMaybe(0));
 
   SyntheticInspectorTouchEvent event(convertedType, convertedModifiers,
                                      GetEventTimeStamp(timestamp));
 
   int autoId = 0;
   for (size_t i = 0; i < touchPoints->length(); ++i) {
@@ skipping 11 matching lines @@
       autoId = -1;
     } else {
       id = autoId++;
     }
     if (id < 0) {
       return Response::Error(
           "All or none of the provided TouchPoints must supply positive "
           "integer ids.");
     }
 
-    PlatformTouchPoint::TouchState convertedState;
+    WebTouchPoint::State convertedState;
     String state = point->getState();
     if (state == "touchPressed")
-      convertedState = PlatformTouchPoint::TouchPressed;
+      convertedState = WebTouchPoint::StatePressed;
     else if (state == "touchReleased")
-      convertedState = PlatformTouchPoint::TouchReleased;
+      convertedState = WebTouchPoint::StateReleased;
     else if (state == "touchMoved")
-      convertedState = PlatformTouchPoint::TouchMoved;
+      convertedState = WebTouchPoint::StateMoved;
     else if (state == "touchStationary")
-      convertedState = PlatformTouchPoint::TouchStationary;
+      convertedState = WebTouchPoint::StateStationary;
     else if (state == "touchCancelled")
-      convertedState = PlatformTouchPoint::TouchCancelled;
+      convertedState = WebTouchPoint::StateCancelled;
     else
       return Response::Error(String("Unrecognized state: " + state));
 
     // Some platforms may have flipped coordinate systems, but the given
     // coordinates assume the origin is in the top-left of the window. Convert.
     IntPoint convertedPoint, globalPoint;
     ConvertInspectorPoint(m_inspectedFrames->root(),
                           IntPoint(point->getX(), point->getY()),
                           &convertedPoint, &globalPoint);
 
     SyntheticInspectorTouchPoint touchPoint(id++, convertedState, globalPoint,
                                             convertedPoint, radiusX, radiusY,
                                             rotationAngle, force);
     event.append(touchPoint);
   }
 
+  event.setFrameScale(
+      m_inspectedFrames->root()->view()->inputEventsScaleFactor());
+

[mustaq, 2017/01/24 16:59:41]

I guess we need to call event.setFrameTranslate() here too?

[dtapuska, 2017/01/25 02:43:34]

Done.

   // TODO: We need to add the support for generating coalesced events in
   // the devtools.
-  Vector<PlatformTouchEvent> coalescedEvents;
+  Vector<WebTouchEvent> coalescedEvents;
 
   m_inspectedFrames->root()->eventHandler().handleTouchEvent(event,
                                                              coalescedEvents);
   return Response::OK();
 }
 
 DEFINE_TRACE(InspectorInputAgent) {
   visitor->trace(m_inspectedFrames);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink