[VSync Queue] Add tracing for event queuing time and coalesced count

ui/events/blink/event_with_callback.cc

 // Copyright 2016 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/blink/event_with_callback.h"
 
 #include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/blink/did_overscroll_params.h"
 #include "ui/events/blink/web_input_event_traits.h"
 
 using blink::WebInputEvent;
 using blink::WebGestureEvent;
 
 namespace ui {
 
 EventWithCallback::EventWithCallback(
     WebScopedInputEvent event,
     const LatencyInfo& latency,
     base::TimeTicks timestamp_now,
     const InputHandlerProxy::EventDispositionCallback& callback)
     : event_(WebInputEventTraits::Clone(*event)),
       latency_(latency),
       creation_timestamp_(timestamp_now),
       last_coalesced_timestamp_(timestamp_now) {
+  TRACE_EVENT_ASYNC_BEGIN0("input", "InputHandlerProxy::EventWithCallback",
+                           this);
   original_events_.emplace_back(std::move(event), callback);
 }
 
 EventWithCallback::EventWithCallback(
     WebScopedInputEvent event,
     const LatencyInfo& latency,
     base::TimeTicks creation_timestamp,
     base::TimeTicks last_coalesced_timestamp,
     std::unique_ptr<OriginalEventList> original_events)
     : event_(std::move(event)),
       latency_(latency),
       creation_timestamp_(creation_timestamp),
       last_coalesced_timestamp_(last_coalesced_timestamp) {
+  TRACE_EVENT_ASYNC_BEGIN0("input", "InputHandlerProxy::EventWithCallback",
+                           this);
   if (original_events)
     original_events_.splice(original_events_.end(), *original_events);
 }
 
-EventWithCallback::~EventWithCallback() {}
+EventWithCallback::~EventWithCallback() {
+  TRACE_EVENT_ASYNC_END0("input", "InputHandlerProxy::EventWithCallback", this);
+}
 
 bool EventWithCallback::CanCoalesceWith(const EventWithCallback& other) const {
   return CanCoalesce(other.event(), event());
 }
 
 void EventWithCallback::CoalesceWith(EventWithCallback* other,
                                      base::TimeTicks timestamp_now) {
   // |other| should be a newer event than |this|.
   if (other->latency_.trace_id() >= 0 && latency_.trace_id() >= 0)
     DCHECK_GT(other->latency_.trace_id(), latency_.trace_id());
@@ skipping 30 matching lines @@
 }
 
 EventWithCallback::OriginalEventWithCallback::OriginalEventWithCallback(
     WebScopedInputEvent event,
     const InputHandlerProxy::EventDispositionCallback& callback)
     : event_(std::move(event)), callback_(callback) {}
 
 EventWithCallback::OriginalEventWithCallback::~OriginalEventWithCallback() {}
 
 }  // namespace ui