Implement compositor thread VSync aligned event queue

ui/events/blink/input_handler_proxy_unittest.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 <memory>
 
+#include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/scoped_feature_list.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/public/platform/WebFloatSize.h"
 #include "third_party/WebKit/public/platform/WebGestureCurve.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
+#include "ui/events/blink/compositor_thread_event_queue.h"
+#include "ui/events/blink/did_overscroll_params.h"
+#include "ui/events/blink/event_with_callback.h"
 #include "ui/events/blink/input_handler_proxy_client.h"
+#include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/geometry/size_f.h"
 
 using blink::WebActiveWheelFlingParameters;
 using blink::WebFloatPoint;
 using blink::WebFloatSize;
 using blink::WebGestureDevice;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebPoint;
 using blink::WebSize;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using testing::Field;
 
 namespace ui {
 namespace test {
 
 namespace {
 
+const char* kCoalescedCountHistogram =
+    "Event.CompositorThreadEventQueue.CoalescedCount";
+const char* kContinuousHeadQueueingTimeHistogram =
+    "Event.CompositorThreadEventQueue.Continuous.HeadQueueingTime";
+const char* kContinuousTailQueueingTimeHistogram =
+    "Event.CompositorThreadEventQueue.Continuous.TailQueueingTime";
+const char* kNonContinuousQueueingTimeHistogram =
+    "Event.CompositorThreadEventQueue.NonContinuous.QueueingTime";
+
 enum InputHandlerProxyTestType {
   ROOT_SCROLL_NORMAL_HANDLER,
   ROOT_SCROLL_SYNCHRONOUS_HANDLER,
   CHILD_SCROLL_NORMAL_HANDLER,
   CHILD_SCROLL_SYNCHRONOUS_HANDLER,
 };
 static const InputHandlerProxyTestType test_types[] = {
     ROOT_SCROLL_NORMAL_HANDLER, ROOT_SCROLL_SYNCHRONOUS_HANDLER,
     CHILD_SCROLL_NORMAL_HANDLER, CHILD_SCROLL_SYNCHRONOUS_HANDLER};
 
@@ skipping 42 matching lines @@
                             WebPoint global_point,
                             int modifiers) {
   return CreateFling(base::TimeTicks(),
                      source_device,
                      velocity,
                      point,
                      global_point,
                      modifiers);
 }
 
+ScopedWebInputEvent CreateGestureScrollOrPinch(WebInputEvent::Type type,
+                                               float deltaYOrScale = 0,
+                                               int x = 0,
+                                               int y = 0) {
+  WebGestureEvent gesture;
+  gesture.sourceDevice = blink::WebGestureDeviceTouchpad;
+  gesture.type = type;
+  if (type == WebInputEvent::GestureScrollUpdate) {
+    gesture.data.scrollUpdate.deltaY = deltaYOrScale;
+  } else if (type == WebInputEvent::GesturePinchUpdate) {
+    gesture.data.pinchUpdate.scale = deltaYOrScale;
+    gesture.x = x;
+    gesture.y = y;
+  }
+  return WebInputEventTraits::Clone(gesture);
+}
+
 class MockInputHandler : public cc::InputHandler {
  public:
   MockInputHandler() {}
   ~MockInputHandler() override {}
 
   MOCK_METHOD0(PinchGestureBegin, void());
   MOCK_METHOD2(PinchGestureUpdate,
                void(float magnify_delta, const gfx::Point& anchor));
   MOCK_METHOD0(PinchGestureEnd, void());
 
@@ skipping 314 matching lines @@
       mock_synchronous_input_handler_;
   std::unique_ptr<TestInputHandlerProxy> input_handler_;
   testing::StrictMock<MockInputHandlerProxyClient> mock_client_;
   WebGestureEvent gesture_;
   InputHandlerProxy::EventDisposition expected_disposition_;
   base::HistogramTester histogram_tester_;
   cc::InputHandlerScrollResult scroll_result_did_scroll_;
   cc::InputHandlerScrollResult scroll_result_did_not_scroll_;
 };
 
+class InputHandlerProxyEventQueueTest
+    : public testing::Test,
+      public testing::WithParamInterface<bool> {
+ public:
+  InputHandlerProxyEventQueueTest()
+      : enable_compositor_event_queue_(GetParam()), weak_ptr_factory_(this) {
+    if (enable_compositor_event_queue_)
+      feature_list_.InitAndEnableFeature(features::kVsyncAlignedInputEvents);
+  }
+
+  ~InputHandlerProxyEventQueueTest() { input_handler_proxy_.reset(); }
+
+  void SetUp() override {
+    event_disposition_recorder_.clear();
+    input_handler_proxy_ = base::MakeUnique<TestInputHandlerProxy>(
+        &mock_input_handler_, &mock_client_);
+    if (input_handler_proxy_->event_queue_)
+      input_handler_proxy_->event_queue_ =
+          base::MakeUnique<CompositorThreadEventQueue>();
+  }
+
+  void HandleGestureEvent(WebInputEvent::Type type,
+                          float deltaYOrScale = 0,
+                          int x = 0,
+                          int y = 0) {
+    LatencyInfo latency;
+    input_handler_proxy_->HandleInputEventWithLatencyInfo(
+        CreateGestureScrollOrPinch(type, deltaYOrScale, x, y), latency,
+        base::Bind(
+            &InputHandlerProxyEventQueueTest::DidHandleInputEventAndOverscroll,
+            weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  void DidHandleInputEventAndOverscroll(
+      InputHandlerProxy::EventDisposition event_disposition,
+      ui::ScopedWebInputEvent input_event,
+      const ui::LatencyInfo& latency_info,
+      std::unique_ptr<ui::DidOverscrollParams> overscroll_params) {
+    event_disposition_recorder_.push_back(event_disposition);
+  }
+
+  std::deque<std::unique_ptr<EventWithCallback>>& event_queue() {
+    return input_handler_proxy_->event_queue_->queue_;
+  }
+
+  void SetEventWithCallbackTestingTimestamp(
+      std::unique_ptr<base::TimeTicks> mock_timestamp_now) {
+    EventWithCallback::testing_timestamp_now_ = std::move(mock_timestamp_now);
+  }
+
+  void SetInputHandlerProxyTestingTimestamp(
+      std::unique_ptr<base::TimeTicks> mock_timestamp_now) {
+    InputHandlerProxy::testing_timestamp_now_ = std::move(mock_timestamp_now);
+  }
+
+ protected:
+  base::test::ScopedFeatureList feature_list_;
+  bool enable_compositor_event_queue_;
+  testing::StrictMock<MockInputHandler> mock_input_handler_;
+  std::unique_ptr<TestInputHandlerProxy> input_handler_proxy_;
+  testing::StrictMock<MockInputHandlerProxyClient> mock_client_;
+  std::vector<InputHandlerProxy::EventDisposition> event_disposition_recorder_;
+
+  base::WeakPtrFactory<InputHandlerProxyEventQueueTest> weak_ptr_factory_;
+};
+
 TEST_P(InputHandlerProxyTest, MouseWheelNoListener) {
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
 
   WebMouseWheelEvent wheel;
   wheel.type = WebInputEvent::MouseWheel;
   wheel.modifiers = WebInputEvent::ControlKey;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel));
@@ skipping 2358 matching lines @@
   input_handler_->RecordMainThreadScrollingReasonsForTest(
       blink::WebGestureDeviceTouchpad,
       cc::MainThreadScrollingReason::kHandlingScrollFromMainThread);
 
   EXPECT_THAT(
       histogram_tester().GetAllSamples("Renderer4.MainThreadWheelScrollReason"),
       testing::ElementsAre(base::Bucket(1, 1), base::Bucket(3, 1),
                            base::Bucket(5, 1), base::Bucket(14, 1)));
 }
 
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedGestureScroll) {
+  // Don't run the test if we aren't supporting VSync aligned input.
+  if (!enable_compositor_event_queue_)
+    return;
+
+  base::HistogramTester histogram_tester;
+
+  // Handle scroll on compositor.
+  cc::InputHandlerScrollResult scroll_result_did_scroll_;
+  scroll_result_did_scroll_.did_scroll = true;
+
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(1);
+
+  HandleGestureEvent(WebInputEvent::GestureScrollBegin);
+
+  // GestureScrollBegin will be processed immediately.
+  EXPECT_EQ(0ul, event_queue().size());
+  EXPECT_EQ(1ul, event_disposition_recorder_.size());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[0]);
+
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -20);
+
+  // GestureScrollUpdate will be queued.
+  EXPECT_EQ(1ul, event_queue().size());
+  EXPECT_EQ(-20, static_cast<const blink::WebGestureEvent&>(
+                     event_queue().front()->event())
+                     .data.scrollUpdate.deltaY);
+  EXPECT_EQ(1ul, event_queue().front()->coalescedCount());
+  EXPECT_EQ(1ul, event_disposition_recorder_.size());
+
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -40);
+
+  // GestureScrollUpdate will be coalesced.
+  EXPECT_EQ(1ul, event_queue().size());
+  EXPECT_EQ(-60, static_cast<const blink::WebGestureEvent&>(
+                     event_queue().front()->event())
+                     .data.scrollUpdate.deltaY);
+  EXPECT_EQ(2ul, event_queue().front()->coalescedCount());
+  EXPECT_EQ(1ul, event_disposition_recorder_.size());
+
+  HandleGestureEvent(WebInputEvent::GestureScrollEnd);
+
+  // GestureScrollEnd will be queued.
+  EXPECT_EQ(2ul, event_queue().size());
+  EXPECT_EQ(1ul, event_disposition_recorder_.size());
+  testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
+
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+
+  // Dispatch all queued events.
+  input_handler_proxy_->DeliverInputForBeginFrame();
+  EXPECT_EQ(0ul, event_queue().size());
+  // Should run callbacks for every original events.
+  EXPECT_EQ(4ul, event_disposition_recorder_.size());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[1]);
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[2]);
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[3]);
+  testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
+  histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 2, 1);
+}
+
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedGestureScrollPinchScroll) {
+  // Don't run the test if we aren't supporting VSync aligned input.
+  if (!enable_compositor_event_queue_)
+    return;
+
+  base::HistogramTester histogram_tester;
+
+  // Handle scroll on compositor.
+  cc::InputHandlerScrollResult scroll_result_did_scroll_;
+  scroll_result_did_scroll_.did_scroll = true;
+
+  // Start scroll in the first frame.
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(1);
+
+  HandleGestureEvent(WebInputEvent::GestureScrollBegin);
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -20);
+
+  EXPECT_EQ(1ul, event_queue().size());
+  EXPECT_EQ(1ul, event_disposition_recorder_.size());
+
+  input_handler_proxy_->DeliverInputForBeginFrame();
+
+  EXPECT_EQ(0ul, event_queue().size());
+  EXPECT_EQ(2ul, event_disposition_recorder_.size());
+  testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
+
+  // Continue scroll in the second frame, pinch, then start another scroll.
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
+      .WillRepeatedly(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(2);
+  EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(1);
+  EXPECT_CALL(mock_input_handler_,
+              GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
+      .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
+  EXPECT_CALL(mock_input_handler_, PinchGestureBegin());
+  // Two |GesturePinchUpdate| will be coalesced.
+  EXPECT_CALL(mock_input_handler_,
+              PinchGestureUpdate(0.7f, gfx::Point(13, 17)));
+  EXPECT_CALL(mock_input_handler_, PinchGestureEnd());
+
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -30);
+  HandleGestureEvent(WebInputEvent::GestureScrollEnd);
+  HandleGestureEvent(WebInputEvent::GesturePinchBegin);
+  HandleGestureEvent(WebInputEvent::GesturePinchUpdate, 1.4f, 13, 17);
+  HandleGestureEvent(WebInputEvent::GesturePinchUpdate, 0.5f, 13, 17);
+  HandleGestureEvent(WebInputEvent::GesturePinchEnd);
+  HandleGestureEvent(WebInputEvent::GestureScrollBegin);
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -70);
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -5);
+  HandleGestureEvent(WebInputEvent::GestureScrollEnd);
+
+  EXPECT_EQ(8ul, event_queue().size());
+  EXPECT_EQ(2ul, event_disposition_recorder_.size());
+
+  input_handler_proxy_->DeliverInputForBeginFrame();
+
+  EXPECT_EQ(0ul, event_queue().size());
+  EXPECT_EQ(12ul, event_disposition_recorder_.size());
+  testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
+  histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 1, 2);
+  histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 2, 2);
+}
+
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedQueueingTime) {
+  // Don't run the test if we aren't supporting VSync aligned input.
+  if (!enable_compositor_event_queue_)
+    return;
+
+  base::HistogramTester histogram_tester;
+
+  // Handle scroll on compositor.
+  cc::InputHandlerScrollResult scroll_result_did_scroll_;
+  scroll_result_did_scroll_.did_scroll = true;
+
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(1);
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+
+  base::TimeTicks timestamp = base::TimeTicks::Now();
+
+  SetEventWithCallbackTestingTimestamp(
+      base::MakeUnique<base::TimeTicks>(timestamp));
+  SetInputHandlerProxyTestingTimestamp(
+      base::MakeUnique<base::TimeTicks>(timestamp));
+  HandleGestureEvent(WebInputEvent::GestureScrollBegin);
+  SetEventWithCallbackTestingTimestamp(base::MakeUnique<base::TimeTicks>(
+      timestamp + base::TimeDelta::FromMicroseconds(10)));
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -20);
+  SetEventWithCallbackTestingTimestamp(base::MakeUnique<base::TimeTicks>(
+      timestamp + base::TimeDelta::FromMicroseconds(50)));
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -40);
+  SetEventWithCallbackTestingTimestamp(base::MakeUnique<base::TimeTicks>(
+      timestamp + base::TimeDelta::FromMicroseconds(70)));
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -10);
+  SetEventWithCallbackTestingTimestamp(base::MakeUnique<base::TimeTicks>(
+      timestamp + base::TimeDelta::FromMicroseconds(80)));
+  HandleGestureEvent(WebInputEvent::GestureScrollEnd);
+
+  // Dispatch all queued events.
+  SetInputHandlerProxyTestingTimestamp(base::MakeUnique<base::TimeTicks>(
+      timestamp + base::TimeDelta::FromMicroseconds(150)));
+  input_handler_proxy_->DeliverInputForBeginFrame();
+  EXPECT_EQ(0ul, event_queue().size());
+  EXPECT_EQ(5ul, event_disposition_recorder_.size());
+  testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
+  histogram_tester.ExpectUniqueSample(kContinuousHeadQueueingTimeHistogram, 140,
+                                      1);
+  histogram_tester.ExpectUniqueSample(kContinuousTailQueueingTimeHistogram, 80,
+                                      1);
+  histogram_tester.ExpectBucketCount(kNonContinuousQueueingTimeHistogram, 0, 1);
+  histogram_tester.ExpectBucketCount(kNonContinuousQueueingTimeHistogram, 70,
+                                     1);
+}
 
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
+
+INSTANTIATE_TEST_CASE_P(InputHandlerProxyEventQueueTests,
+                        InputHandlerProxyEventQueueTest,
+                        testing::Bool());
 }  // namespace test
 }  // namespace ui