Add scrollDelta units to GestureScrollEnd.

content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc

 // Copyright 2016 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/mouse_wheel_event_queue.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/location.h"
@@ skipping 33 matching lines @@
   ~MouseWheelEventQueueTest() override {}
 
   // MouseWheelEventQueueClient
   void SendMouseWheelEventImmediately(
       const MouseWheelEventWithLatencyInfo& event) override {
     sent_events_.push_back(event.event);
   }
 
   void SendGestureEvent(const GestureEventWithLatencyInfo& event) override {
     sent_events_.push_back(event.event);
+    sent_gesture_events_.push_back(event.event);
   }
 
   void OnMouseWheelEventAck(const MouseWheelEventWithLatencyInfo& event,
                             InputEventAckState ack_result) override {
     ++acked_event_count_;
     last_acked_event_ = event.event;
     last_acked_event_state_ = ack_result;
   }
 
  protected:
   void SetUpForGestureTesting(bool send_gestures) {
     queue_.reset(
         new MouseWheelEventQueue(this, send_gestures, kScrollEndTimeoutMs));
   }
 
   size_t queued_event_count() const { return queue_->queued_size(); }
 
   bool event_in_flight() const { return queue_->event_in_flight(); }
 
   std::vector<WebInputEvent>& all_sent_events() { return sent_events_; }
 
+  std::vector<WebGestureEvent>& sent_gesture_events() {
+    return sent_gesture_events_;
+  }
+
   const WebMouseWheelEvent& acked_event() const { return last_acked_event_; }
 
   size_t GetAndResetSentEventCount() {
     size_t count = sent_events_.size();
     sent_events_.clear();
+    sent_gesture_events_.clear();
     return count;
   }
 
   size_t GetAndResetAckedEventCount() {
     size_t count = acked_event_count_;
     acked_event_count_ = 0;
     return count;
   }
 
   void SendMouseWheelEventAck(InputEventAckState ack_result) {
@@ skipping 15 matching lines @@
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay);
     base::MessageLoop::current()->Run();
   }
 
   scoped_ptr<MouseWheelEventQueue> queue_;
   std::vector<WebInputEvent> sent_events_;
+  std::vector<WebGestureEvent> sent_gesture_events_;
   size_t acked_event_count_;
   InputEventAckState last_acked_event_state_;
   base::MessageLoopForUI message_loop_;
   WebMouseWheelEvent last_acked_event_;
 };
 
 // Tests that mouse wheel events are queued properly.
 TEST_F(MouseWheelEventQueueTest, Basic) {
   SendMouseWheel(10, 10, 1, 1, 0);
   EXPECT_EQ(0U, queued_event_count());
@@ skipping 38 matching lines @@
 
   // Receive an ACK for the mouse wheel event and release the next
   // mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(3U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
+  EXPECT_EQ(WebGestureEvent::Pixels,

[tdresser, 2016/02/18 16:00:46]

Should we have a test which expects PrecisePixels?

[dtapuska, 2016/02/18 16:16:44]

I knew you would ask.. :-)

+            sent_gesture_events()[0].data.scrollBegin.deltaHintUnits);
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
+  EXPECT_EQ(WebGestureEvent::Pixels,
+            sent_gesture_events()[1].data.scrollUpdate.deltaUnits);
   EXPECT_EQ(WebInputEvent::MouseWheel, all_sent_events()[2].type);
   EXPECT_EQ(3U, GetAndResetSentEventCount());
 
   RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2);
   EXPECT_EQ(1U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type);
+  EXPECT_EQ(WebGestureEvent::Pixels,
+            sent_gesture_events()[0].data.scrollEnd.deltaUnits);
 }
 
 TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   SetUpForGestureTesting(true);
   SendMouseWheel(10, 10, 1, 1, 0);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
@@ skipping 41 matching lines @@
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 }
 
 }  // namespace content