Add metric to determine the benefit of forcing an event listener to be passive.

content/renderer/input/render_widget_input_handler.cc

 // Copyright 2015 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/renderer/input/render_widget_input_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 99 matching lines @@
     default:
       // Must include default to let blink::WebInputEvent add new event types
       // before they're added here.
       DLOG(WARNING) << "Unhandled WebInputEvent type: " << event_type;
       break;
   }
 
 #undef CASE_TYPE
 }
 
-void LogPassiveLatency(int64_t latency) {
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Event.PassiveListeners.Latency", latency, 1,
-                              10000000, 100);
-}
-
 void LogPassiveEventListenersUma(WebInputEventResult result,
                                  WebInputEvent::DispatchType dispatch_type,
                                  double event_timestamp,
                                  const ui::LatencyInfo& latency_info) {
   enum {
     PASSIVE_LISTENER_UMA_ENUM_PASSIVE,
     PASSIVE_LISTENER_UMA_ENUM_UNCANCELABLE,
     PASSIVE_LISTENER_UMA_ENUM_SUPPRESSED,
     PASSIVE_LISTENER_UMA_ENUM_CANCELABLE,
     PASSIVE_LISTENER_UMA_ENUM_CANCELABLE_AND_CANCELED,
@@ skipping 24 matching lines @@
       NOTREACHED();
       return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Event.PassiveListeners", enum_value,
                             PASSIVE_LISTENER_UMA_ENUM_COUNT);
 
   if (enum_value == PASSIVE_LISTENER_UMA_ENUM_CANCELABLE &&
       base::TimeTicks::IsHighResolution()) {
     base::TimeTicks now = base::TimeTicks::Now();
-    LogPassiveLatency(GetEventLatencyMicros(event_timestamp, now));
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Event.PassiveListeners.Latency",
+                                GetEventLatencyMicros(event_timestamp, now), 1,
+                                10000000, 100);
+  }
+
+  if (dispatch_type == WebInputEvent::ListenersForcedNonBlockingPassive) {
+    base::TimeTicks now = base::TimeTicks::Now();

[tdresser, 2016/04/21 13:36:42]

Are you intentionally only recording the first one if it's high resolution, but
always recording this metric?

Also, we can't have both Event.PassiveListeners.Latency and
Event.PassiveListeners.ForcedNonBlockingLatency, can we?

Maybe move this to an else if, or add a DCHECK or something?

[dtapuska, 2016/04/21 13:38:34]

Err no; I meant to move this into a if(highRes) {
...
}

[dtapuska, 2016/04/21 20:46:38]

Done.

+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Event.PassiveListeners.ForcedNonBlockingLatency",
+        GetEventLatencyMicros(event_timestamp, now), 1, 10000000, 100);
   }
 }
 
 }  // namespace
 
 RenderWidgetInputHandler::RenderWidgetInputHandler(
     RenderWidgetInputHandlerDelegate* delegate,
     RenderWidget* widget)
     : delegate_(delegate),
       widget_(widget),
@@ skipping 362 matching lines @@
   if (pending_input_event_ack_) {
     TRACE_EVENT_ASYNC_END0("input",
                            "RenderWidgetInputHandler::ThrottledInputEventAck",
                            pending_input_event_ack_.get());
     delegate_->OnInputEventAck(std::move(pending_input_event_ack_));
   }
   total_input_handling_time_this_frame_ = base::TimeDelta();
 }
 
 }  // namespace content