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 21 matching lines @@
         enum_value = PASSIVE_LISTENER_UMA_ENUM_CANCELABLE;
       break;
     default:
       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));
+  if (base::TimeTicks::IsHighResolution()) {
+    if (enum_value == PASSIVE_LISTENER_UMA_ENUM_CANCELABLE) {
+      base::TimeTicks now = base::TimeTicks::Now();

[tdresser, 2016/04/21 20:54:52]

Move computation of now outside of conditional.

[dtapuska, 2016/04/21 21:02:41]

this is an if, else if.. since it avoids a costly call getting the current time;
I prefer calling it in each block separately so we avoid it most of the time
(the else case).

[tdresser, 2016/04/21 21:03:27]

Sorry, I was thinking this was an "if/else" not "if / else if".
You're right.

+      UMA_HISTOGRAM_CUSTOM_COUNTS("Event.PassiveListeners.Latency",
+                                  GetEventLatencyMicros(event_timestamp, now),
+                                  1, 10000000, 100);
+    } else if (enum_value == PASSIVE_LISTENER_UMA_ENUM_FORCED_NON_BLOCKING) {
+      base::TimeTicks now = base::TimeTicks::Now();
+      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