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

ui/events/blink/input_handler_proxy.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/blink/input_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 277 matching lines @@
   scroll_elasticity_controller_.reset();
   input_handler_ = NULL;
   client_->WillShutdown();
 }
 
 void InputHandlerProxy::HandleInputEventWithLatencyInfo(
     WebScopedInputEvent event,
     const LatencyInfo& latency_info,
     const EventDispositionCallback& callback) {
   DCHECK(input_handler_);
+  TRACE_EVENT0("input", "InputHandlerProxy::HandleInputEventWithLatencyInfo");
 
   if (uma_latency_reporting_enabled_)
     ReportInputEventLatencyUma(*event, latency_info);
 
   TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
                          TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "HandleInputEventImpl");
 
   std::unique_ptr<EventWithCallback> event_with_callback =
@@ skipping 20 matching lines @@
 
   // We have to dispatch the event to know whether the gesture sequence will be
   // handled by the compositor or not.
   DispatchSingleInputEvent(std::move(event_with_callback),
                            tick_clock_->NowTicks());
 }
 
 void InputHandlerProxy::DispatchSingleInputEvent(
     std::unique_ptr<EventWithCallback> event_with_callback,
     const base::TimeTicks now) {
+  TRACE_EVENT0("input", "InputHandlerProxy::DispatchSingleInputEvent");
   if (compositor_event_queue_ &&
       IsGestureScollOrPinch(event_with_callback->event().type())) {
     // Report the coalesced count only for continuous events to avoid the noise
     // from non-continuous events.
     if (IsContinuousGestureEvent(event_with_callback->event().type())) {
+      TRACE_EVENT_INSTANT2(
+          "input", "InputHandlerProxy::CoalescedContinusGestureEvent",

[tdresser, 2017/02/14 16:31:54]

Continuous

+          TRACE_EVENT_SCOPE_THREAD, "type", event_with_callback->event().type(),
+          "coalesced_count", event_with_callback->coalesced_count());
+
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.CompositorThreadEventQueue.Continuous.HeadQueueingTime",
           (now - event_with_callback->creation_timestamp()).InMicroseconds(), 1,
           kTenSeconds, 50);
 
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.CompositorThreadEventQueue.Continuous.TailQueueingTime",
           (now - event_with_callback->last_coalesced_timestamp())
               .InMicroseconds(),
           1, kTenSeconds, 50);
@@ skipping 1261 matching lines @@
                  scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
                  scroll_result));
 }
 
 void InputHandlerProxy::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ui