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

ui/events/latency_info.cc

 // Copyright 2013 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 "ui/events/latency_info.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 119 matching lines @@
   const unsigned char* latency_info_enabled;
 };
 
 static base::LazyInstance<LatencyInfoEnabledInitializer>::Leaky
   g_latency_info_enabled = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace ui {
 
+LatencyInfo::InputCoordinate::InputCoordinate() : x(0), y(0) {
+}
+
+LatencyInfo::InputCoordinate::InputCoordinate(float x, float y) : x(x), y(y) {
+}
+
 LatencyInfo::LatencyInfo()
     : input_coordinates_size_(0),
       trace_id_(-1),
       coalesced_(false),
       terminated_(false) {}
 
 LatencyInfo::LatencyInfo(const LatencyInfo& other) = default;
 
 LatencyInfo::~LatencyInfo() {}
 
@@ skipping 180 matching lines @@
   record_data->SetDouble("trace_id", static_cast<double>(trace_id_));
   return LatencyInfoTracedValue::FromValue(std::move(record_data));
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 LatencyInfo::CoordinatesAsTraceableData() {
   std::unique_ptr<base::ListValue> coordinates(new base::ListValue());
   for (size_t i = 0; i < input_coordinates_size_; i++) {
     std::unique_ptr<base::DictionaryValue> coordinate_pair(
         new base::DictionaryValue());
-    coordinate_pair->SetDouble("x", input_coordinates_[i].x());
-    coordinate_pair->SetDouble("y", input_coordinates_[i].y());
+    coordinate_pair->SetDouble("x", input_coordinates_[i].x);
+    coordinate_pair->SetDouble("y", input_coordinates_[i].y);
     coordinates->Append(coordinate_pair.release());
   }
   return LatencyInfoTracedValue::FromValue(std::move(coordinates));
 }
 
 bool LatencyInfo::FindLatency(LatencyComponentType type,
                               int64_t id,
                               LatencyComponent* output) const {
   LatencyMap::const_iterator it = latency_components_.find(
       std::make_pair(type, id));
@@ skipping 10 matching lines @@
     if (it->first.first == type) {
       LatencyMap::iterator tmp = it;
       ++it;
       latency_components_.erase(tmp);
     } else {
       it++;
     }
   }
 }
 
-bool LatencyInfo::AddInputCoordinate(const gfx::PointF& input_coordinate) {
+bool LatencyInfo::AddInputCoordinate(const InputCoordinate& input_coordinate) {
   if (input_coordinates_size_ >= kMaxInputCoordinates)
     return false;
   input_coordinates_[input_coordinates_size_++] = input_coordinate;
   return true;
 }
 
 }  // namespace ui