Fix RenderWidgetHostLatencyTracker handling of multi-finger touch.

content/browser/renderer_host/input/render_widget_host_latency_tracker.cc

 // Copyright 2014 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/browser/renderer_host/input/render_widget_host_latency_tracker.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_functions.h"
@@ skipping 321 matching lines @@
   }
 }
 
 }  // namespace
 
 RenderWidgetHostLatencyTracker::RenderWidgetHostLatencyTracker()
     : last_event_id_(0),
       latency_component_id_(0),
       device_scale_factor_(1),
       has_seen_first_gesture_scroll_update_(false),
-      multi_finger_gesture_(false),
+      active_multi_finger_gesture_(false),
       touch_start_default_prevented_(false),
       render_widget_host_delegate_(nullptr) {}
 
 RenderWidgetHostLatencyTracker::~RenderWidgetHostLatencyTracker() {}
 
 void RenderWidgetHostLatencyTracker::Initialize(int routing_id,
                                                 int process_id) {
   DCHECK_EQ(0, last_event_id_);
   DCHECK_EQ(0, latency_component_id_);
   last_event_id_ = static_cast<int64_t>(process_id) << 32;
@@ skipping 15 matching lines @@
     return;
   }
 
   LatencyInfo::LatencyComponent rwh_component;
   if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
                            latency_component_id, &rwh_component)) {
     return;
   }
   DCHECK_EQ(rwh_component.event_count, 1u);
 
+  bool multi_finger_touch_gesture =
+      WebInputEvent::isTouchEventType(type) && active_multi_finger_gesture_;
+
   LatencyInfo::LatencyComponent ui_component;
   if (latency.FindLatency(ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0,
                           &ui_component)) {
     DCHECK_EQ(ui_component.event_count, 1u);
     base::TimeDelta ui_delta =
         rwh_component.last_event_time - ui_component.first_event_time;
 
     if (type == blink::WebInputEvent::MouseWheel) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Browser.WheelUI",
                                   ui_delta.InMicroseconds(), 1, 20000, 100);
@@ skipping 12 matching lines @@
 
   std::string event_name = WebInputEvent::GetName(type);
 
   std::string default_action_status =
       action_prevented ? "DefaultPrevented" : "DefaultAllowed";
 
   LatencyInfo::LatencyComponent main_component;
   if (latency.FindLatency(ui::INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT, 0,
                           &main_component)) {
     DCHECK_EQ(main_component.event_count, 1u);
-    if (!multi_finger_gesture_) {
+    if (!multi_finger_touch_gesture) {
       UMA_HISTOGRAM_INPUT_LATENCY_MILLISECONDS(
           "Event.Latency.QueueingTime." + event_name + default_action_status,
           rwh_component, main_component);
     }
   }
 
   LatencyInfo::LatencyComponent acked_component;
   if (latency.FindLatency(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0,
                           &acked_component)) {
     DCHECK_EQ(acked_component.event_count, 1u);
-    if (!multi_finger_gesture_ &&
+    if (!multi_finger_touch_gesture &&
         main_component.event_time != base::TimeTicks()) {
       UMA_HISTOGRAM_INPUT_LATENCY_MILLISECONDS(
           "Event.Latency.BlockingTime." + event_name + default_action_status,
           main_component, acked_component);
     }
 
     std::string input_modality = WebInputEventTypeToInputModalityString(type);
     if (input_modality != "") {
       UMA_HISTOGRAM_INPUT_LATENCY_HIGH_RESOLUTION_MICROSECONDS(
           "Event.Latency.Browser." + input_modality + "Acked", rwh_component,
           acked_component);
     }
   }
 }
 
 void RenderWidgetHostLatencyTracker::OnInputEvent(
     const blink::WebInputEvent& event,
     LatencyInfo* latency) {
   DCHECK(latency);
+
+  if (event.type() == WebInputEvent::TouchStart) {
+    const WebTouchEvent& touch_event =
+        *static_cast<const WebTouchEvent*>(&event);
+    DCHECK(touch_event.touchesLength >= 1);
+    active_multi_finger_gesture_ = touch_event.touchesLength != 1;
+  }
+
   if (latency->FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
                            latency_component_id_, NULL)) {
     return;
   }
 
   if (event.timeStampSeconds() &&
       !latency->FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0,
                             NULL)) {
     base::TimeTicks timestamp_now = base::TimeTicks::Now();
     base::TimeTicks timestamp_original =
@@ skipping 50 matching lines @@
   // Latency ends if an event is acked but does not cause render scheduling.
   bool rendering_scheduled = latency->FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT, 0, nullptr);
   rendering_scheduled |= latency->FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT, 0, nullptr);
 
   if (WebInputEvent::isTouchEventType(event.type())) {
     const WebTouchEvent& touch_event =
         *static_cast<const WebTouchEvent*>(&event);
     if (event.type() == WebInputEvent::TouchStart) {
-      DCHECK(touch_event.touchesLength >= 1);
-      multi_finger_gesture_ = touch_event.touchesLength != 1;
       touch_start_default_prevented_ =
           ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
+    } else if (event.type() == WebInputEvent::TouchEnd ||
+               event.type() == WebInputEvent::TouchCancel) {
+      active_multi_finger_gesture_ = touch_event.touchesLength > 2;
     }
   }
 
   latency->AddLatencyNumber(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0);
   // If this event couldn't have caused a gesture event, and it didn't trigger
   // rendering, we're done processing it.
   if (!rendering_scheduled) {
     latency->AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_TERMINATED_NO_SWAP_COMPONENT, 0, 0);
   }
@@ skipping 62 matching lines @@
                                    latency_component_id_, latency);
   }
 }
 
 void RenderWidgetHostLatencyTracker::SetDelegate(
     RenderWidgetHostDelegate* delegate) {
   render_widget_host_delegate_ = delegate;
 }
 
 }  // namespace content