Make first TouchStart and first TouchMove events on a flinging layer non-blocking

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 109 matching lines @@
 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,
-    PASSIVE_LISTENER_UMA_ENUM_FORCED_NON_BLOCKING,
+    PASSIVE_LISTENER_UMA_ENUM_FORCED_NON_BLOCKING_DUE_TO_FLING,
     PASSIVE_LISTENER_UMA_ENUM_COUNT
   };
 
   int enum_value;
   switch (dispatch_type) {
-    case WebInputEvent::ListenersForcedNonBlockingPassive:
-      enum_value = PASSIVE_LISTENER_UMA_ENUM_FORCED_NON_BLOCKING;
+    case WebInputEvent::ListenersForcedNonBlockingPassiveDueToFling:
+      enum_value = PASSIVE_LISTENER_UMA_ENUM_FORCED_NON_BLOCKING_DUE_TO_FLING;
       break;
     case WebInputEvent::ListenersNonBlockingPassive:
       enum_value = PASSIVE_LISTENER_UMA_ENUM_PASSIVE;
       break;
     case WebInputEvent::EventNonBlocking:
       enum_value = PASSIVE_LISTENER_UMA_ENUM_UNCANCELABLE;
       break;
     case WebInputEvent::Blocking:
       if (result == WebInputEventResult::HandledApplication)
         enum_value = PASSIVE_LISTENER_UMA_ENUM_CANCELABLE_AND_CANCELED;
       else if (result == WebInputEventResult::HandledSuppressed)
         enum_value = PASSIVE_LISTENER_UMA_ENUM_SUPPRESSED;
       else
         enum_value = PASSIVE_LISTENER_UMA_ENUM_CANCELABLE;
       break;
     default:
       NOTREACHED();
       return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Event.PassiveListeners", enum_value,
                             PASSIVE_LISTENER_UMA_ENUM_COUNT);
 
   if (base::TimeTicks::IsHighResolution()) {
     if (enum_value == PASSIVE_LISTENER_UMA_ENUM_CANCELABLE) {
       base::TimeTicks now = base::TimeTicks::Now();
       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) {
+    } else if (enum_value ==
+               PASSIVE_LISTENER_UMA_ENUM_FORCED_NON_BLOCKING_DUE_TO_FLING) {
       base::TimeTicks now = base::TimeTicks::Now();
       UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "Event.PassiveListeners.ForcedNonBlockingLatency",
+          "Event.PassiveListeners.ForcedNonBlockingLatencyDueToFling",
           GetEventLatencyMicros(event_timestamp, now), 1, 10000000, 100);
     }
   }
 }
 
 }  // namespace
 
 RenderWidgetInputHandler::RenderWidgetInputHandler(
     RenderWidgetInputHandlerDelegate* delegate,
     RenderWidget* widget)
     : delegate_(delegate),
       widget_(widget),
       handling_input_event_(false),
       handling_event_overscroll_(nullptr),
       handling_event_type_(WebInputEvent::Undefined),
       context_menu_source_type_(ui::MENU_SOURCE_MOUSE),
       suppress_next_char_events_(false),
-      ignore_ack_for_mouse_move_from_debugger_(false) {
+      ignore_ack_for_mouse_move_from_debugger_(false),
+      waiting_for_first_touch_move_(false) {
   DCHECK(delegate);
   DCHECK(widget);
   delegate->SetInputHandler(this);
 }
 
 RenderWidgetInputHandler::~RenderWidgetInputHandler() {}
 
 void RenderWidgetInputHandler::HandleInputEvent(
     const WebInputEvent& input_event,
     const ui::LatencyInfo& latency_info,
@@ skipping 128 matching lines @@
   // ideally this should be when the event was sent by the compositor to the
   // renderer. crbug.com/565348
   if (input_event.type == WebInputEvent::TouchStart ||
       input_event.type == WebInputEvent::TouchMove ||
       input_event.type == WebInputEvent::TouchEnd) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
 
     LogPassiveEventListenersUma(processed, touch.dispatchType,
                                 input_event.timeStampSeconds, latency_info);
 
-    if (input_event.type == WebInputEvent::TouchStart &&
-        touch.dispatchType == WebInputEvent::Blocking &&
+    // TODO(lanwei): May remove it when we no longer need any metric for event
+    // latency outside fling.
+    if (touch.dispatchType == WebInputEvent::Blocking &&
         base::TimeTicks::IsHighResolution()) {
-      base::TimeTicks now = base::TimeTicks::Now();
-      if (touch.dispatchedDuringFling) {
+      bool touch_start_or_first_touch_move = false;
+      if (touch.type == WebInputEvent::TouchStart) {
+        waiting_for_first_touch_move_ = true;
+        touch_start_or_first_touch_move = true;
+      } else if (touch.type == WebInputEvent::TouchMove) {
+        touch_start_or_first_touch_move = waiting_for_first_touch_move_;
+        waiting_for_first_touch_move_ = false;
+      }
+      if (touch_start_or_first_touch_move) {
+        base::TimeTicks now = base::TimeTicks::Now();
         UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Event.Touch.TouchStartLatencyDuringFling",
-            GetEventLatencyMicros(input_event.timeStampSeconds, now), 1,
-            100000000, 50);
-      } else {
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Event.Touch.TouchStartLatencyOutsideFling",
+            "Event.Touch.TouchLatencyOutsideFling",
             GetEventLatencyMicros(input_event.timeStampSeconds, now), 1,
             100000000, 50);
       }
     }
   } else if (input_event.type == WebInputEvent::MouseWheel) {
     LogPassiveEventListenersUma(
         processed,
         static_cast<const WebMouseWheelEvent&>(input_event).dispatchType,
         input_event.timeStampSeconds, latency_info);
   }
@@ skipping 195 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