Remove coordinates from LatencyInfo objects.

ui/latency/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/latency/latency_info.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 115 matching lines @@
 static base::LazyInstance<LatencyInfoEnabledInitializer>::Leaky
   g_latency_info_enabled = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace ui {
 
 LatencyInfo::LatencyInfo() : LatencyInfo(SourceEventType::UNKNOWN) {}
 
 LatencyInfo::LatencyInfo(SourceEventType type)
-    : input_coordinates_size_(0),
-      trace_id_(-1),
+    : trace_id_(-1),
       coalesced_(false),
       terminated_(false),
       source_event_type_(type) {}
 
 LatencyInfo::LatencyInfo(const LatencyInfo& other) = default;
 
 LatencyInfo::~LatencyInfo() {}
 
 LatencyInfo::LatencyInfo(int64_t trace_id, bool terminated)
-    : input_coordinates_size_(0),
-      trace_id_(trace_id),
+    : trace_id_(trace_id),
       terminated_(terminated),
       source_event_type_(SourceEventType::UNKNOWN) {}
 
 bool LatencyInfo::Verify(const std::vector<LatencyInfo>& latency_info,
                          const char* referring_msg) {
   if (latency_info.size() > kMaxLatencyInfoNumber) {
     LOG(ERROR) << referring_msg << ", LatencyInfo vector size "
                << latency_info.size() << " is too big.";
     TRACE_EVENT_INSTANT1("input,benchmark", "LatencyInfo::Verify Fails",
                          TRACE_EVENT_SCOPE_GLOBAL,
@@ skipping 129 matching lines @@
       it->second.last_event_time = std::max(it->second.last_event_time, time);
     }
   }
 
   if (IsTerminalComponent(component) && trace_id_ != -1) {
     // Should only ever add terminal component once.
     CHECK(!terminated_);
     terminated_ = true;
 
     if (*latency_info_enabled) {
-      TRACE_EVENT_COPY_ASYNC_END2(kTraceCategoriesForAsyncEvents,
-                                  trace_name_.c_str(),
-                                  TRACE_ID_DONT_MANGLE(trace_id_),
-                                  "data", AsTraceableData(),
-                                  "coordinates", CoordinatesAsTraceableData());
+      TRACE_EVENT_COPY_ASYNC_END1(
+          kTraceCategoriesForAsyncEvents, trace_name_.c_str(),
+          TRACE_ID_DONT_MANGLE(trace_id_), "data", AsTraceableData());
     }
 
     TRACE_EVENT_WITH_FLOW0("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(trace_id_),
                            TRACE_EVENT_FLAG_FLOW_IN);
   }
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
@@ skipping 10 matching lines @@
     component_info->SetDouble("count", lc.second.event_count);
     component_info->SetDouble("sequence_number",
                               lc.second.sequence_number);
     record_data->Set(GetComponentName(lc.first.first),
                      std::move(component_info));
   }
   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());
-    coordinates->Append(std::move(coordinate_pair));
-  }
-  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));
   if (it == latency_components_.end())
     return false;
   if (output)
     *output = it->second;
   return true;
 }
 
 void LatencyInfo::RemoveLatency(LatencyComponentType type) {
   LatencyMap::iterator it = latency_components_.begin();
   while (it != latency_components_.end()) {
     if (it->first.first == type)
       it = latency_components_.erase(it);
     else
       it++;
   }
 }
 
-bool LatencyInfo::AddInputCoordinate(const gfx::PointF& input_coordinate) {
-  if (input_coordinates_size_ >= kMaxInputCoordinates)
-    return false;
-  input_coordinates_[input_coordinates_size_++] = input_coordinate;
-  return true;
-}
-
 }  // namespace ui