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

ui/events/blink/compositor_thread_event_queue.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/compositor_thread_event_queue.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/web_input_event_traits.h"
 
 namespace ui {
 
 CompositorThreadEventQueue::CompositorThreadEventQueue() {}
 
 CompositorThreadEventQueue::~CompositorThreadEventQueue() {}
 
 void CompositorThreadEventQueue::Queue(
     std::unique_ptr<EventWithCallback> new_event,
     base::TimeTicks timestamp_now) {
   if (queue_.empty() || !IsContinuousGestureEvent(new_event->event().type()) ||
       !IsCompatibleScrollorPinch(ToWebGestureEvent(new_event->event()),
                                  ToWebGestureEvent(queue_.back()->event()))) {
+    if (new_event->first_original_event()) {
+      // Trace could be nested as there might be multiple events in queue.
+      // e.g. |ScrollUpdate|, |ScrollEnd|, and another scroll sequence.
+      TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("input",
+                                        "CompositorThreadEventQueue::Queue",
+                                        new_event->first_original_event());
+    }
     queue_.emplace_back(std::move(new_event));
     return;
   }
 
   if (queue_.back()->CanCoalesceWith(*new_event)) {
     queue_.back()->CoalesceWith(new_event.get(), timestamp_now);
     return;
   }
 
   // Extract the last event in queue.
@@ skipping 48 matching lines @@
   queue_.emplace_back(std::move(scroll_event));
   queue_.emplace_back(std::move(pinch_event));
 }
 
 std::unique_ptr<EventWithCallback> CompositorThreadEventQueue::Pop() {
   std::unique_ptr<EventWithCallback> result;
   if (!queue_.empty()) {
     result = std::move(queue_.front());
     queue_.pop_front();
   }
+
+  if (result->first_original_event()) {
+    TRACE_EVENT_NESTABLE_ASYNC_END2(
+        "input", "CompositorThreadEventQueue::Queue",
+        result->first_original_event(), "type", result->event().type(),
+        "coalesced_count", result->coalesced_count());
+  }
   return result;
 }
 
 }  // namespace ui