Remove LatencyInfo::sequence_number. (May break metrics).

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_functions.h"
@@ skipping 51 matching lines @@
   }
 
   // Remove the entries with invalid component IDs.
   latency->RemoveLatency(ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT);
 
   // Add newly generated components into the latency info
   for (size_t i = 0; i < new_components_key.size(); i++) {
     latency->AddLatencyNumberWithTimestamp(
         new_components_key[i].first,
         new_components_key[i].second,
-        new_components_value[i].sequence_number,
         new_components_value[i].event_time,
         new_components_value[i].event_count);
   }
 }
 
 void RecordEQTAccuracy(base::TimeDelta queueing_time,
                        base::TimeDelta expected_queueing_time) {
   float expected_queueing_time_ms = expected_queueing_time.InMillisecondsF();
 
   if (expected_queueing_time_ms < 10) {
@@ skipping 50 matching lines @@
         "RendererScheduler."
         "QueueingDurationWhenExpectedQueueingTime_GreaterThan.450ms",
         queueing_time);
   }
 }
 
 }  // namespace
 
 RenderWidgetHostLatencyTracker::RenderWidgetHostLatencyTracker()
     : ukm_source_id_(-1),
-      last_event_id_(0),
       latency_component_id_(0),
       device_scale_factor_(1),
       has_seen_first_gesture_scroll_update_(false),
       active_multi_finger_gesture_(false),
       touch_start_default_prevented_(false),
       render_widget_host_delegate_(nullptr) {}
 
 RenderWidgetHostLatencyTracker::~RenderWidgetHostLatencyTracker() {}
 
 void RenderWidgetHostLatencyTracker::Initialize(int routing_id,
                                                 int process_id) {
-  DCHECK_EQ(0, last_event_id_);
   DCHECK_EQ(0, latency_component_id_);
-  last_event_id_ = static_cast<int64_t>(process_id) << 32;
-  latency_component_id_ = routing_id | last_event_id_;
+  latency_component_id_ = routing_id | static_cast<int64_t>(process_id) << 32;
 }
 
 void RenderWidgetHostLatencyTracker::ComputeInputLatencyHistograms(
     WebInputEvent::Type type,
     int64_t latency_component_id,
     const LatencyInfo& latency,
     InputEventAckState ack_result) {
   // If this event was coalesced into another event, ignore it, as the event it
   // was coalesced into will reflect the full latency.
   if (latency.coalesced())
@@ skipping 123 matching lines @@
     // Timestamp from platform input can wrap, e.g. 32 bits timestamp
     // for Xserver and Window MSG time will wrap about 49.6 days. Do a
     // sanity check here and if wrap does happen, use TimeTicks::Now()
     // as the timestamp instead.
     if ((timestamp_now - timestamp_original).InDays() > 0)
       timestamp_original = timestamp_now;
 
     latency->AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
         0,
-        0,
         timestamp_original,
         1);
   }
 
   latency->AddLatencyNumberWithTraceName(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, latency_component_id_,
-      ++last_event_id_, WebInputEvent::GetName(event.GetType()));
+      WebInputEvent::GetName(event.GetType()));
 
   if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
     has_seen_first_gesture_scroll_update_ = false;
   } else if (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate) {
     // Make a copy of the INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT with a
     // different name INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT.
     // So we can track the latency specifically for scroll update events.
     LatencyInfo::LatencyComponent original_component;
     if (latency->FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0,
                              &original_component)) {
       latency->AddLatencyNumberWithTimestamp(
           has_seen_first_gesture_scroll_update_
               ? ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT
               : ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT,
-          latency_component_id_, original_component.sequence_number,
-          original_component.event_time, original_component.event_count);
+          latency_component_id_, original_component.event_time,
+          original_component.event_count);
     }
 
     has_seen_first_gesture_scroll_update_ = true;
   }
 }
 
 void RenderWidgetHostLatencyTracker::OnInputEventAck(
     const blink::WebInputEvent& event,
     LatencyInfo* latency, InputEventAckState ack_result) {
   DCHECK(latency);
 
   // Latency ends if an event is acked but does not cause render scheduling.
   bool rendering_scheduled = latency->FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT, 0, nullptr);
   rendering_scheduled |= latency->FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT, 0, nullptr);
 
   if (WebInputEvent::IsTouchEventType(event.GetType())) {
     const WebTouchEvent& touch_event =
         *static_cast<const WebTouchEvent*>(&event);
     if (event.GetType() == WebInputEvent::kTouchStart) {
       touch_start_default_prevented_ =
           ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
     } else if (event.GetType() == WebInputEvent::kTouchEnd ||
                event.GetType() == WebInputEvent::kTouchCancel) {
       active_multi_finger_gesture_ = touch_event.touches_length > 2;
     }
   }
 
-  latency->AddLatencyNumber(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0);
+  latency->AddLatencyNumber(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0);
   // If this event couldn't have caused a gesture event, and it didn't trigger
   // rendering, we're done processing it.
   if (!rendering_scheduled) {
     latency->AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_TERMINATED_NO_SWAP_COMPONENT, 0, 0);
+        ui::INPUT_EVENT_LATENCY_TERMINATED_NO_SWAP_COMPONENT, 0);
   }
 
   ComputeInputLatencyHistograms(event.GetType(), latency_component_id_,
                                 *latency, ack_result);
 }
 
 void RenderWidgetHostLatencyTracker::OnSwapCompositorFrame(
     std::vector<LatencyInfo>* latencies) {
   DCHECK(latencies);
   for (LatencyInfo& latency : *latencies) {
@@ skipping 49 matching lines @@
   if (ukm_source_id == -1 || !ukm_recorder)
     return;
 
   std::unique_ptr<ukm::UkmEntryBuilder> builder =
       ukm_recorder->GetEntryBuilder(ukm_source_id, event_name.c_str());
   builder->AddMetric(metric_name.c_str(), (end_component.last_event_time -
                                            start_component.first_event_time)
                                               .InMicroseconds());
 }
 }  // namespace content