UMA metrics for fractions of wheel and touch scrolls blocked on the main thread.

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 214 matching lines @@
   }
 }
 
 cc::InputHandler::ScrollInputType GestureScrollInputType(
     blink::WebGestureDevice device) {
   return device == blink::WebGestureDeviceTouchpad
              ? cc::InputHandler::WHEEL
              : cc::InputHandler::TOUCHSCREEN;
 }
 
+enum ScrollingThreadStatus {
+  SCROLLING_ON_COMPOSITOR,
+  SCROLLING_ON_COMPOSITOR_BLOCKED_ON_MAIN,
+  SCROLLING_ON_MAIN,
+  LAST_SCROLLING_THREAD_STATUS_VALUE = SCROLLING_ON_MAIN,
+};
+
 }  // namespace
 
 namespace ui {
 
 InputHandlerProxy::InputHandlerProxy(cc::InputHandler* input_handler,
                                      InputHandlerProxyClient* client)
     : client_(client),
       input_handler_(input_handler),
       deferred_fling_cancel_time_seconds_(0),
       synchronous_input_handler_(nullptr),
       allow_root_animate_(true),
 #ifndef NDEBUG
       expect_scroll_update_end_(false),
 #endif
       gesture_scroll_on_impl_thread_(false),
       gesture_pinch_on_impl_thread_(false),
       fling_may_be_active_on_main_thread_(false),
       disallow_horizontal_fling_scroll_(false),
       disallow_vertical_fling_scroll_(false),
       has_fling_animation_started_(false),
       smooth_scroll_enabled_(false),
       uma_latency_reporting_enabled_(base::TimeTicks::IsHighResolution()),
       touchpad_and_wheel_scroll_latching_enabled_(false),
       touch_start_result_(kEventDispositionUndefined),
+      mouse_wheel_result_(kEventDispositionUndefined),
       current_overscroll_params_(nullptr),
       has_ongoing_compositor_scroll_pinch_(false),
       tick_clock_(base::MakeUnique<base::DefaultTickClock>()) {
   DCHECK(client);
   input_handler_->BindToClient(this);
   cc::ScrollElasticityHelper* scroll_elasticity_helper =
       input_handler_->CreateScrollElasticityHelper();
   if (scroll_elasticity_helper) {
     scroll_elasticity_controller_.reset(
         new InputScrollElasticityController(scroll_elasticity_helper));
@@ skipping 309 matching lines @@
         UMA_HISTOGRAM_ENUMERATION(kGestureHistogramName, i + 1,
                                   mainThreadScrollingReasonEnumMax);
       } else {
         UMA_HISTOGRAM_ENUMERATION(kWheelHistogramName, i + 1,
                                   mainThreadScrollingReasonEnumMax);
       }
     }
   }
 }
 
+void InputHandlerProxy::RecordScrollingThreadStatus(
+    blink::WebGestureDevice device,
+    uint32_t reasons) {
+  static const char* kGestureHistogramName =
+      "Renderer4.GestureScrollingThreadStatus";
+  static const char* kWheelHistogramName =
+      "Renderer4.WheelScrollingThreadStatus";
+
+  DCHECK(device == blink::WebGestureDeviceTouchpad ||
+         device == blink::WebGestureDeviceTouchscreen);
+
+  if (device != blink::WebGestureDeviceTouchpad &&
+      device != blink::WebGestureDeviceTouchscreen) {
+    return;
+  }
+
+  ScrollingThreadStatus scrolling_thread_status = SCROLLING_ON_MAIN;
+  if (reasons == cc::MainThreadScrollingReason::kNotScrollingOnMain) {
+    int32_t event_disposition_result =
+        (device == blink::WebGestureDeviceTouchpad ? mouse_wheel_result_
+                                                   : touch_start_result_);
+    switch (event_disposition_result) {
+      case kEventDispositionUndefined:
+      case DID_NOT_HANDLE_NON_BLOCKING_DUE_TO_FLING:
+      case DID_HANDLE_NON_BLOCKING:
+      case DROP_EVENT:
+        scrolling_thread_status = SCROLLING_ON_COMPOSITOR;
+        break;
+      case DID_NOT_HANDLE:
+        scrolling_thread_status = SCROLLING_ON_COMPOSITOR_BLOCKED_ON_MAIN;
+        break;
+      default:
+        NOTREACHED();
+        scrolling_thread_status = SCROLLING_ON_COMPOSITOR;
+    }
+  }
+
+  // UMA_HISTOGRAM_ENUMERATION requires that the enum_max must be strictly
+  // greater than the sample value.
+  const uint32_t kScrolingThreadStatusEnumMax =
+      ScrollingThreadStatus::LAST_SCROLLING_THREAD_STATUS_VALUE + 1;
+
+  if (device == blink::WebGestureDeviceTouchscreen) {
+    UMA_HISTOGRAM_ENUMERATION(kGestureHistogramName, scrolling_thread_status,

[tdresser, 2017/01/17 20:27:43]

I'd probably just put the literal string in here, instead of using a constant.

This is fine - it's just a bit more difficult to grep for where the histogram is
recorded.

[sahel, 2017/01/19 15:26:32]

Done.

+                              kScrolingThreadStatusEnumMax);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(kWheelHistogramName, scrolling_thread_status,
+                              kScrolingThreadStatusEnumMax);
+  }
+}
+
 bool InputHandlerProxy::ShouldAnimate(bool has_precise_scroll_deltas) const {
 #if defined(OS_MACOSX)
   // Mac does not smooth scroll wheel events (crbug.com/574283).
   return false;
 #else
   return smooth_scroll_enabled_ && !has_precise_scroll_deltas;
 #endif
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleMouseWheel(
     const WebMouseWheelEvent& wheel_event) {
   // Only call |CancelCurrentFling()| if a fling was active, as it will
   // otherwise disrupt an in-progress touch scroll.
   if (!wheel_event.hasPreciseScrollingDeltas && fling_curve_)
     CancelCurrentFling();
 
+  InputHandlerProxy::EventDisposition result = DROP_EVENT;
   cc::EventListenerProperties properties =
       input_handler_->GetEventListenerProperties(
           cc::EventListenerClass::kMouseWheel);
   switch (properties) {
     case cc::EventListenerProperties::kPassive:
-      return DID_HANDLE_NON_BLOCKING;
+      result = DID_HANDLE_NON_BLOCKING;
+      break;
     case cc::EventListenerProperties::kBlockingAndPassive:
     case cc::EventListenerProperties::kBlocking:
-      return DID_NOT_HANDLE;
+      result = DID_NOT_HANDLE;
+      break;
     case cc::EventListenerProperties::kNone:
-      return DROP_EVENT;
+      result = DROP_EVENT;
+      break;
     default:
       NOTREACHED();
-      return DROP_EVENT;
+      result = DROP_EVENT;
   }
+
+  mouse_wheel_result_ = result;
+  return result;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::FlingScrollByMouseWheel(
     const WebMouseWheelEvent& wheel_event,
     cc::EventListenerProperties listener_properties) {
   DCHECK(listener_properties == cc::EventListenerProperties::kPassive ||
          listener_properties == cc::EventListenerProperties::kNone);
 
   DCHECK(!wheel_event.railsMode);
   gfx::Vector2dF scroll_delta(-wheel_event.deltaX, -wheel_event.deltaY);
@@ skipping 34 matching lines @@
     scroll_state_begin_data.position_y = wheel_event.y;
     scroll_state_begin_data.is_beginning = true;
     cc::ScrollState scroll_state_begin(scroll_state_begin_data);
     cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
         &scroll_state_begin, cc::InputHandler::WHEEL);
 
     RecordMainThreadScrollingReasons(
         blink::WebGestureDeviceTouchpad,
         scroll_status.main_thread_scrolling_reasons);
 
+    mouse_wheel_result_ =
+        (listener_properties == cc::EventListenerProperties::kPassive)
+            ? DID_HANDLE_NON_BLOCKING
+            : DROP_EVENT;
+    RecordScrollingThreadStatus(blink::WebGestureDeviceTouchpad,
+                                scroll_status.main_thread_scrolling_reasons);
+
     switch (scroll_status.thread) {
       case cc::InputHandler::SCROLL_ON_IMPL_THREAD: {
         TRACE_EVENT_INSTANT2("input",
                              "InputHandlerProxy::handle_input wheel scroll",
                              TRACE_EVENT_SCOPE_THREAD, "deltaX",
                              scroll_delta.x(), "deltaY", scroll_delta.y());
 
         cc::ScrollStateData scroll_state_update_data;
         scroll_state_update_data.delta_x = scroll_delta.x();
         scroll_state_update_data.delta_y = scroll_delta.y();
@@ skipping 61 matching lines @@
   } else {
     scroll_status = input_handler_->ScrollBegin(
         &scroll_state, GestureScrollInputType(gesture_event.sourceDevice));
   }
   UMA_HISTOGRAM_ENUMERATION("Renderer4.CompositorScrollHitTestResult",
                             scroll_status.thread,
                             cc::InputHandler::LAST_SCROLL_STATUS + 1);
 
   RecordMainThreadScrollingReasons(gesture_event.sourceDevice,
                                    scroll_status.main_thread_scrolling_reasons);
+  RecordScrollingThreadStatus(gesture_event.sourceDevice,
+                              scroll_status.main_thread_scrolling_reasons);
 
   InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
   switch (scroll_status.thread) {
     case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
       TRACE_EVENT_INSTANT0("input",
                            "InputHandlerProxy::handle_input gesture scroll",
                            TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = true;
       result = DID_HANDLE;
       break;
@@ skipping 776 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