Revert of Replace ui::LatencyInfo::InputCoordinate with gfx::PointF

content/browser/renderer_host/input/render_widget_host_latency_tracker.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/input/render_widget_host_latency_tracker.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
 void UpdateLatencyCoordinatesImpl(const blink::WebTouchEvent& touch,
                                   LatencyInfo* latency,
                                   float device_scale_factor) {
   for (uint32_t i = 0; i < touch.touchesLength; ++i) {
-    gfx::PointF coordinate(touch.touches[i].position.x * device_scale_factor,
-                           touch.touches[i].position.y * device_scale_factor);
+    LatencyInfo::InputCoordinate coordinate(
+        touch.touches[i].position.x * device_scale_factor,
+        touch.touches[i].position.y * device_scale_factor);
     if (!latency->AddInputCoordinate(coordinate))
       break;
   }
 }
 
 void UpdateLatencyCoordinatesImpl(const WebGestureEvent& gesture,
                                   LatencyInfo* latency,
                                   float device_scale_factor) {
-  latency->AddInputCoordinate(gfx::PointF(gesture.x * device_scale_factor,
-                                          gesture.y * device_scale_factor));
+  latency->AddInputCoordinate(
+      LatencyInfo::InputCoordinate(gesture.x * device_scale_factor,
+                                   gesture.y * device_scale_factor));
 }
 
 void UpdateLatencyCoordinatesImpl(const WebMouseEvent& mouse,
                                   LatencyInfo* latency,
                                   float device_scale_factor) {
-  latency->AddInputCoordinate(gfx::PointF(mouse.x * device_scale_factor,
-                                          mouse.y * device_scale_factor));
+  latency->AddInputCoordinate(
+      LatencyInfo::InputCoordinate(mouse.x * device_scale_factor,
+                                   mouse.y * device_scale_factor));
 }
 
 void UpdateLatencyCoordinatesImpl(const WebMouseWheelEvent& wheel,
                                   LatencyInfo* latency,
                                   float device_scale_factor) {
-  latency->AddInputCoordinate(gfx::PointF(wheel.x * device_scale_factor,
-                                          wheel.y * device_scale_factor));
+  latency->AddInputCoordinate(
+      LatencyInfo::InputCoordinate(wheel.x * device_scale_factor,
+                                   wheel.y * device_scale_factor));
 }
 
 void UpdateLatencyCoordinates(const WebInputEvent& event,
                               float device_scale_factor,
                               LatencyInfo* latency) {
   if (WebInputEvent::isMouseEventType(event.type)) {
     UpdateLatencyCoordinatesImpl(static_cast<const WebMouseEvent&>(event),
                                  latency, device_scale_factor);
   } else if (WebInputEvent::isGestureEventType(event.type)) {
     UpdateLatencyCoordinatesImpl(static_cast<const WebGestureEvent&>(event),
@@ skipping 435 matching lines @@
                            latency_component_id_, nullptr)) {
     return;
   }
 
   ComputeScrollLatencyHistograms(gpu_swap_begin_component,
                                  gpu_swap_end_component, latency_component_id_,
                                  latency);
 }
 
 }  // namespace content