Add touch drag UMA latency metric.

content/browser/renderer_host/input/render_widget_host_latency_tracker_unittest.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 "base/test/histogram_tester.h"
 #include "content/browser/renderer_host/input/render_widget_host_latency_tracker.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::Bucket;
 using blink::WebInputEvent;
+using testing::ElementsAre;
 
 namespace content {
 namespace {
 
 void AddFakeComponents(const RenderWidgetHostLatencyTracker& tracker,
                        ui::LatencyInfo* latency) {
   latency->AddLatencyNumberWithTimestamp(
       ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0, base::TimeTicks::Now(), 1);
   latency->AddLatencyNumberWithTimestamp(
       ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0,
@@ skipping 45 matching lines @@
                                            << size << " entries, but had "
                                            << histogram_size;
     }
   }
 
   RenderWidgetHostLatencyTracker* tracker() { return &tracker_; }
   void ResetHistograms() {
     histogram_tester_.reset(new base::HistogramTester());
   }
 
+  const base::HistogramTester& histogram_tester() {
+    return *histogram_tester_;
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostLatencyTrackerTest);
   const int kTestRoutingId = 3;
   const int kTestProcessId = 1;
   std::unique_ptr<base::HistogramTester> histogram_tester_;
   RenderWidgetHostLatencyTracker tracker_;
 };
 
 TEST_F(RenderWidgetHostLatencyTrackerTest, TestHistograms) {
   for (bool rendering_on_main : { false, true }) {
     ResetHistograms();
     {
       auto scroll = SyntheticWebGestureEventBuilder::BuildScrollUpdate(
           5.f, -5.f, 0, blink::WebGestureDeviceTouchscreen);
       scroll.timeStampSeconds =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       ui::LatencyInfo scroll_latency;
       AddFakeComponents(*tracker(), &scroll_latency);
       AddRenderingScheduledComponent(&scroll_latency, rendering_on_main);
       tracker()->OnInputEvent(scroll, &scroll_latency);
       EXPECT_TRUE(scroll_latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
           tracker()->latency_component_id(), nullptr));
       EXPECT_TRUE(scroll_latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, nullptr));
       EXPECT_EQ(1U, scroll_latency.input_coordinates_size());
-      tracker()->OnInputEventAck(scroll, &scroll_latency);
+      tracker()->OnInputEventAck(scroll, &scroll_latency,
+                                 INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     }
 
     {
       auto wheel = SyntheticWebMouseWheelEventBuilder::Build(
           blink::WebMouseWheelEvent::PhaseChanged);
       wheel.timeStampSeconds =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       ui::LatencyInfo wheel_latency;
       AddFakeComponents(*tracker(), &wheel_latency);
       AddRenderingScheduledComponent(&wheel_latency, rendering_on_main);
       tracker()->OnInputEvent(wheel, &wheel_latency);
       EXPECT_TRUE(wheel_latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
           tracker()->latency_component_id(), nullptr));
       EXPECT_TRUE(wheel_latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, nullptr));
       EXPECT_EQ(1U, wheel_latency.input_coordinates_size());
-      tracker()->OnInputEventAck(wheel, &wheel_latency);
+      tracker()->OnInputEventAck(wheel, &wheel_latency,
+                                 INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     }
 
     {
       SyntheticWebTouchEvent touch;
       touch.PressPoint(0, 0);
       touch.PressPoint(1, 1);
       ui::LatencyInfo touch_latency;
       AddFakeComponents(*tracker(), &touch_latency);
       AddRenderingScheduledComponent(&touch_latency, rendering_on_main);
       tracker()->OnInputEvent(touch, &touch_latency);
       EXPECT_TRUE(touch_latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
           tracker()->latency_component_id(), nullptr));
       EXPECT_TRUE(touch_latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, nullptr));
       EXPECT_EQ(2U, touch_latency.input_coordinates_size());
-      tracker()->OnInputEventAck(touch, &touch_latency);
+      tracker()->OnInputEventAck(touch, &touch_latency,
+                                 INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       tracker()->OnFrameSwapped(touch_latency);
     }
 
     EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.WheelUI", 1));
     EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.TouchUI", 1));
     EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.WheelAcked", 1));
     EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.TouchAcked", 1));
     EXPECT_TRUE(
         HistogramSizeEq("Event.Latency.TouchToFirstScrollUpdateSwapBegin", 1));
     EXPECT_TRUE(
@@ skipping 21 matching lines @@
 TEST_F(RenderWidgetHostLatencyTrackerTest,
        LatencyTerminatedOnAckIfRenderingNotScheduled) {
   {
     auto scroll = SyntheticWebGestureEventBuilder::BuildScrollBegin(
         5.f, -5.f, blink::WebGestureDeviceTouchscreen);
     ui::LatencyInfo scroll_latency;
     AddFakeComponents(*tracker(), &scroll_latency);
     // Don't include the rendering schedule component, since we're testing the
     // case where rendering isn't scheduled.
     tracker()->OnInputEvent(scroll, &scroll_latency);
-    tracker()->OnInputEventAck(scroll, &scroll_latency);
+    tracker()->OnInputEventAck(scroll, &scroll_latency,
+                               INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_TRUE(scroll_latency.FindLatency(
         ui::INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT, 0, nullptr));
     EXPECT_TRUE(scroll_latency.terminated());
   }
 
   {
     auto wheel = SyntheticWebMouseWheelEventBuilder::Build(
         blink::WebMouseWheelEvent::PhaseChanged);
     ui::LatencyInfo wheel_latency;
     AddFakeComponents(*tracker(), &wheel_latency);
     tracker()->OnInputEvent(wheel, &wheel_latency);
-    tracker()->OnInputEventAck(wheel, &wheel_latency);
+    tracker()->OnInputEventAck(wheel, &wheel_latency,
+                               INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_TRUE(wheel_latency.FindLatency(
         ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_WHEEL_COMPONENT, 0, nullptr));
     EXPECT_TRUE(wheel_latency.terminated());
   }
 
   {
     SyntheticWebTouchEvent touch;
     touch.PressPoint(0, 0);
     ui::LatencyInfo touch_latency;
     AddFakeComponents(*tracker(), &touch_latency);
     tracker()->OnInputEvent(touch, &touch_latency);
-    tracker()->OnInputEventAck(touch, &touch_latency);
+    tracker()->OnInputEventAck(touch, &touch_latency,
+                               INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_TRUE(touch_latency.FindLatency(
         ui::INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT, 0, nullptr));
     EXPECT_TRUE(touch_latency.terminated());
     tracker()->OnFrameSwapped(touch_latency);
   }
 
   {
     auto mouse_move = SyntheticWebMouseEventBuilder::Build(
         blink::WebMouseEvent::MouseMove);
     ui::LatencyInfo mouse_latency;
     AddFakeComponents(*tracker(), &mouse_latency);
     tracker()->OnInputEvent(mouse_move, &mouse_latency);
-    tracker()->OnInputEventAck(mouse_move, &mouse_latency);
+    tracker()->OnInputEventAck(mouse_move, &mouse_latency,
+                               INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_TRUE(mouse_latency.FindLatency(
         ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT, 0, nullptr));
     EXPECT_TRUE(mouse_latency.terminated());
   }
 
   {
     auto key_event = SyntheticWebKeyboardEventBuilder::Build(
         blink::WebKeyboardEvent::Char);
     ui::LatencyInfo key_latency;
     AddFakeComponents(*tracker(), &key_latency);
     tracker()->OnInputEvent(key_event, &key_latency);
-    tracker()->OnInputEventAck(key_event, &key_latency);
+    tracker()->OnInputEventAck(key_event, &key_latency,
+                               INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_TRUE(key_latency.FindLatency(
         ui::INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT, 0, nullptr));
     EXPECT_TRUE(key_latency.terminated());
   }
 
   EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.WheelUI", 1));
   EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.TouchUI", 1));
   EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.WheelAcked", 1));
   EXPECT_TRUE(HistogramSizeEq("Event.Latency.Browser.TouchAcked", 1));
   EXPECT_TRUE(
@@ skipping 117 matching lines @@
                                  tracker()->latency_component_id(), nullptr));
   EXPECT_FALSE(scroll_latency.FindLatency(
       ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT,
       tracker()->latency_component_id(), nullptr));
   EXPECT_TRUE(scroll_latency.FindLatency(
       ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
       tracker()->latency_component_id(), nullptr));
   EXPECT_EQ(3U, scroll_latency.latency_components().size());
 }
 
+TEST_F(RenderWidgetHostLatencyTrackerTest, TouchBlockingAndQueueingTime) {
+  for (InputEventAckState blocking :
+       {INPUT_EVENT_ACK_STATE_NOT_CONSUMED, INPUT_EVENT_ACK_STATE_CONSUMED}) {
+    SyntheticWebTouchEvent event;
+    event.PressPoint(1, 1);
+
+    ui::LatencyInfo latency_start;
+    tracker()->OnInputEvent(event, &latency_start);
+    tracker()->OnInputEventAck(event, &latency_start,
+                               INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+    ui::LatencyInfo latency_move;
+    event.MovePoint(0, 20, 20);
+    tracker()->OnInputEvent(event, &latency_move);
+
+    EXPECT_TRUE(latency_move.FindLatency(
+        ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, nullptr));
+    EXPECT_TRUE(
+        latency_move.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
+                                 tracker()->latency_component_id(), nullptr));
+
+    EXPECT_EQ(2U, latency_move.latency_components().size());
+
+    ui::LatencyInfo fake_latency_move;
+    fake_latency_move.AddLatencyNumberWithTimestamp(
+        ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
+        tracker()->latency_component_id(), 0,
+        base::TimeTicks() + base::TimeDelta::FromMilliseconds(1), 1);
+
+    fake_latency_move.AddLatencyNumberWithTimestamp(
+        ui::INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT, 0, 0,
+        base::TimeTicks() + base::TimeDelta::FromMilliseconds(5), 1);
+
+    fake_latency_move.AddLatencyNumberWithTimestamp(
+        ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0,
+        base::TimeTicks() + base::TimeDelta::FromMilliseconds(12), 1);
+
+    // Call ComputeInputLatencyHistograms directly to avoid OnInputEventAck
+    // overwriting components.
+    tracker()->ComputeInputLatencyHistograms(event.type,
+                                             tracker()->latency_component_id(),
+                                             fake_latency_move, blocking);
+  }
+
+  EXPECT_THAT(histogram_tester().GetAllSamples(
+                  "Event.Latency.QueueingTime.TouchMoveDefaultPrevented"),
+              ElementsAre(Bucket(4, 1)));
+  EXPECT_THAT(histogram_tester().GetAllSamples(
+                  "Event.Latency.QueueingTime.TouchMoveDefaultAllowed"),
+              ElementsAre(Bucket(4, 1)));
+  EXPECT_THAT(histogram_tester().GetAllSamples(
+                  "Event.Latency.BlockingTime.TouchMoveDefaultPrevented"),
+              ElementsAre(Bucket(7, 1)));
+  EXPECT_THAT(histogram_tester().GetAllSamples(
+                  "Event.Latency.BlockingTime.TouchMoveDefaultAllowed"),
+              ElementsAre(Bucket(7, 1)));
+}
+
 }  // namespace content