Add UMA metrics to determine the usefulness of passive event listeners.

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/render_widget.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 223 matching lines @@
                              const ui::LatencyInfo& latency_info) {
   LogInputEventLatencyUmaImpl(event.type, event.timeStampSeconds, now);
   for (size_t i = 0; i < latency_info.coalesced_events_size(); i++) {
     LogInputEventLatencyUmaImpl(
         event.type,
         latency_info.timestamps_of_coalesced_events()[i],
         now);
   }
 }
 
+void LogPassiveLatency(int64 latency) {
+  UMA_HISTOGRAM_CUSTOM_COUNTS("Event.PassiveListeners.Latency", latency, 1,
+                              10000000, 100);
+}
+
+void LogPassiveEventListenersUma(WebInputEventResult result,
+                                 bool passive,
+                                 bool cancelable,
+                                 double event_timestamp,
+                                 base::TimeTicks now,
+                                 const ui::LatencyInfo& latency_info) {
+  enum {
+    PASSIVE_LISTENER_UMA_ENUM_PASSIVE,
+    PASSIVE_LISTENER_UMA_ENUM_UNCANCELABLE,
+    PASSIVE_LISTENER_UMA_ENUM_CANCELABLE,
+    PASSIVE_LISTENER_UMA_ENUM_CANCELABLE_AND_CANCELED,
+    PASSIVE_LISTENER_UMA_ENUM_COUNT
+  };
+
+  int enum_value;
+  if (passive)
+    enum_value = PASSIVE_LISTENER_UMA_ENUM_PASSIVE;
+  else if (!cancelable)
+    enum_value = PASSIVE_LISTENER_UMA_ENUM_UNCANCELABLE;
+  else if (result == WebInputEventResult::HandledScript)
+    enum_value = PASSIVE_LISTENER_UMA_ENUM_CANCELABLE_AND_CANCELED;
+  else
+    enum_value = PASSIVE_LISTENER_UMA_ENUM_CANCELABLE;
+
+  UMA_HISTOGRAM_ENUMERATION("Event.PassiveListeners", enum_value,
+                            PASSIVE_LISTENER_UMA_ENUM_COUNT);
+
+  if (enum_value == PASSIVE_LISTENER_UMA_ENUM_CANCELABLE && !now.is_null()) {
+    LogPassiveLatency(GetEventLatencyMicros(event_timestamp, now));
+    for (size_t i = 0; i < latency_info.coalesced_events_size(); i++)
+      LogPassiveLatency(GetEventLatencyMicros(
+          latency_info.timestamps_of_coalesced_events()[i], now));
+  }
+}
+
 }  // namespace
 
 namespace content {
 
 // RenderWidget::ScreenMetricsEmulator ----------------------------------------
 
 class RenderWidget::ScreenMetricsEmulator {
  public:
   ScreenMetricsEmulator(
       RenderWidget* widget,
@@ skipping 832 matching lines @@
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
 
   // Notify subclasses that composited rendering was flushed to the screen.
   DidFlushPaint();
 }
 
 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info) {
   if (!input_event)
     return;
+  bool passive = false;

[tdresser, 2015/11/23 21:14:34]

Add a comment linking to the bug indicating that this is not yet implemented.

[dtapuska, 2015/11/27 20:05:25]

Done.

   base::AutoReset<bool> handling_input_event_resetter(&handling_input_event_,
                                                       true);
   base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
       &handling_event_type_, input_event->type);
 
   // Calls into |didOverscroll()| while handling this event will populate
   // |event_overscroll|, which in turn will be bundled with the event ack.
   scoped_ptr<DidOverscrollParams> event_overscroll;
   base::AutoReset<scoped_ptr<DidOverscrollParams>*>
       handling_event_overscroll_resetter(&handling_event_overscroll_,
@@ skipping 65 matching lines @@
 #endif
   }
 
   if (WebInputEvent::isGestureEventType(input_event->type)) {
     const WebGestureEvent& gesture_event =
         *static_cast<const WebGestureEvent*>(input_event);
     context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
     prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
   }
 
-  bool processed = prevent_default;
+  WebInputEventResult processed =
+      prevent_default ? WebInputEventResult::HandledDefaultHandler
+                      : WebInputEventResult::NotHandled;
   if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
     suppress_next_char_events_ = false;
-    if (!processed && webwidget_)
-      processed = webwidget_->handleInputEvent(*input_event) !=
-                  WebInputEventResult::NotHandled;
+    if (processed == WebInputEventResult::NotHandled && webwidget_)
+      processed = webwidget_->handleInputEvent(*input_event);
+  }
+
+  if (input_event->type == WebInputEvent::TouchStart ||
+      input_event->type == WebInputEvent::TouchMove ||
+      input_event->type == WebInputEvent::TouchEnd) {

[tdresser, 2015/11/23 21:14:34]

Does isTouchEventType work for you?
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[dtapuska, 2015/11/23 21:33:57]

I didn't necessarily want to capture TouchCancel since that isn't an event we'd
wait for anyways.

+    LogPassiveEventListenersUma(
+        processed, passive,
+        static_cast<const WebTouchEvent*>(input_event)->cancelable,
+        input_event->timeStampSeconds, start_time, latency_info);
+  } else if (input_event->type == WebInputEvent::MouseWheel) {
+    LogPassiveEventListenersUma(processed, passive, !passive,

[tdresser, 2015/11/23 21:14:34]

Does this make it more difficult to draw conclusions from the cancelable vs
non-cancelable entries in the histogram? 

I'm tempted to say we should actually split up touch vs mousewheel here, but
maybe that's overkill.

Your call, but I'm a bit worried that the way in which |cancellable| is defined
differently for wheel will cause confusion.

[dtapuska, 2015/11/23 21:33:57]

UMA would only record a non-cancelable event for touch; its not possible for it
to log one for mouse wheel..  And those aren't really useful. The real useful
ones are cancelable and not canceled metric.  But then again we can't possibly
draw too much conclusions as to those other than the portion of events that are
processed that way because the results can be dependent on scripts choosing
behavior certain ways.

+                                input_event->timeStampSeconds, start_time,
+                                latency_info);
   }
 
   // If this RawKeyDown event corresponds to a browser keyboard shortcut and
   // it's not processed by webkit, then we need to suppress the upcoming Char
   // events.
   bool is_keyboard_shortcut =
       input_event->type == WebInputEvent::RawKeyDown &&
       static_cast<const WebKeyboardEvent*>(input_event)->isBrowserShortcut;
-  if (!processed && is_keyboard_shortcut)
+  if (processed == WebInputEventResult::NotHandled && is_keyboard_shortcut)
     suppress_next_char_events_ = true;
 
-  InputEventAckState ack_result = processed ?
-      INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
-  if (!processed &&  input_event->type == WebInputEvent::TouchStart) {
+  InputEventAckState ack_result = processed == WebInputEventResult::NotHandled
+                                      ? INPUT_EVENT_ACK_STATE_NOT_CONSUMED
+                                      : INPUT_EVENT_ACK_STATE_CONSUMED;
+  if (processed == WebInputEventResult::NotHandled &&
+      input_event->type == WebInputEvent::TouchStart) {
     const WebTouchEvent& touch_event =
         *static_cast<const WebTouchEvent*>(input_event);
     // Hit-test for all the pressed touch points. If there is a touch-handler
     // for any of the touch points, then the renderer should continue to receive
     // touch events.
     ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
     for (size_t i = 0; i < touch_event.touchesLength; ++i) {
       if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
           HasTouchEventHandlersAt(
               gfx::ToFlooredPoint(touch_event.touches[i].position))) {
         ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
         break;
       }
     }
   }
 
   // Send mouse wheel events and their disposition to the compositor thread, so
   // that they can be used to produce the elastic overscroll effect on Mac.
   if (input_event->type == WebInputEvent::MouseWheel) {
     ObserveWheelEventAndResult(
         static_cast<const WebMouseWheelEvent&>(*input_event),
         event_overscroll ? event_overscroll->latest_overscroll_delta
                          : gfx::Vector2dF(),
-        processed);
+        processed != WebInputEventResult::NotHandled);
   }
 
   bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
 
   // If we don't have a fast and accurate Now(), we assume the input handlers
   // are heavy and rate limit them.
   bool rate_limiting_wanted =
       input_event->type == WebInputEvent::MouseMove ||
       input_event->type == WebInputEvent::MouseWheel;
   if (rate_limiting_wanted && !start_time.is_null()) {
@@ skipping 46 matching lines @@
     RenderThreadImpl::current()
         ->GetRendererScheduler()
         ->DidHandleInputEventOnMainThread(*input_event);
   }
   if (input_event->type == WebInputEvent::MouseMove)
     ignore_ack_for_mouse_move_from_debugger_ = false;
 
 #if defined(OS_ANDROID)
   // Allow the IME to be shown when the focus changes as a consequence
   // of a processed touch end event.
-  if (input_event->type == WebInputEvent::TouchEnd && processed)
+  if (input_event->type == WebInputEvent::TouchEnd &&
+      processed != WebInputEventResult::NotHandled)

[tdresser, 2015/11/23 21:14:34]

I'm a fan of braces when the condition is multi-line, and I think that's
consistent with the style around here.

[dtapuska, 2015/11/23 21:33:57]

woops; that is me not checking git cl format.

[dtapuska, 2015/11/27 20:05:25]

Done.

     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
 #elif defined(USE_AURA)
   // Show the virtual keyboard if enabled and a user gesture triggers a focus
   // change.
-  if (processed && (input_event->type == WebInputEvent::TouchEnd ||
-                    input_event->type == WebInputEvent::MouseUp)) {
+  if (processed != WebInputEventResult::NotHandled &&
+      (input_event->type == WebInputEvent::TouchEnd ||
+       input_event->type == WebInputEvent::MouseUp)) {
     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
   }
 #endif
 
   if (!prevent_default) {
     if (WebInputEvent::isKeyboardEventType(input_event->type))
       DidHandleKeyEvent();
   }
 
 // TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
 // virtual keyboard.
 #if !defined(OS_ANDROID)
   // Virtual keyboard is not supported, so react to focus change immediately.
-  if (processed && (input_event->type == WebInputEvent::TouchEnd ||
-                    input_event->type == WebInputEvent::MouseUp)) {
+  if (processed != WebInputEventResult::NotHandled &&
+      (input_event->type == WebInputEvent::TouchEnd ||
+       input_event->type == WebInputEvent::MouseUp)) {
     FocusChangeComplete();
   }
 #endif
 }
 
 void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
   if (webwidget_)
     webwidget_->setCursorVisibilityState(is_visible);
 }
 
@@ skipping 1130 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content