OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/renderer_host/input/mouse_wheel_event_queue.h" | 5 #include "content/browser/renderer_host/input/mouse_wheel_event_queue.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/location.h" | 10 #include "base/location.h" |
(...skipping 16 matching lines...) Expand all Loading... |
27 const float kWheelScrollX = 10; | 27 const float kWheelScrollX = 10; |
28 const float kWheelScrollY = 12; | 28 const float kWheelScrollY = 12; |
29 const float kWheelScrollGlobalX = 50; | 29 const float kWheelScrollGlobalX = 50; |
30 const float kWheelScrollGlobalY = 72; | 30 const float kWheelScrollGlobalY = 72; |
31 const int64_t kScrollEndTimeoutMs = 100; | 31 const int64_t kScrollEndTimeoutMs = 100; |
32 | 32 |
33 base::TimeDelta DefaultScrollEndTimeoutDelay() { | 33 base::TimeDelta DefaultScrollEndTimeoutDelay() { |
34 return base::TimeDelta::FromMilliseconds(kScrollEndTimeoutMs); | 34 return base::TimeDelta::FromMilliseconds(kScrollEndTimeoutMs); |
35 } | 35 } |
36 | 36 |
| 37 #define EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event) \ |
| 38 EXPECT_EQ(WebInputEvent::GestureScrollBegin, event->type); \ |
| 39 EXPECT_EQ(kWheelScrollX, event->x); \ |
| 40 EXPECT_EQ(kWheelScrollY, event->y); \ |
| 41 EXPECT_EQ(kWheelScrollGlobalX, event->globalX); \ |
| 42 EXPECT_EQ(kWheelScrollGlobalY, event->globalY); \ |
| 43 EXPECT_EQ(scroll_units, event->data.scrollBegin.deltaHintUnits); |
| 44 |
| 45 #define EXPECT_GESTURE_SCROLL_BEGIN(event) \ |
| 46 EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ |
| 47 EXPECT_FALSE(event->data.scrollBegin.synthetic); \ |
| 48 EXPECT_FALSE(event->data.scrollBegin.inertial); |
| 49 |
| 50 #define EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(event) \ |
| 51 EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ |
| 52 EXPECT_TRUE(event->data.scrollBegin.synthetic); \ |
| 53 EXPECT_FALSE(event->data.scrollBegin.inertial); |
| 54 |
| 55 #define EXPECT_INERTIAL_GESTURE_SCROLL_BEGIN(event) \ |
| 56 EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ |
| 57 EXPECT_FALSE(event->data.scrollBegin.synthetic); \ |
| 58 EXPECT_TRUE(event->data.scrollBegin.inertial); |
| 59 |
| 60 #define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(event) \ |
| 61 EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ |
| 62 EXPECT_TRUE(event->data.scrollBegin.synthetic); \ |
| 63 EXPECT_TRUE(event->data.scrollBegin.inertial); |
| 64 |
| 65 #define EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event) \ |
| 66 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, event->type); \ |
| 67 EXPECT_EQ(scroll_units, event->data.scrollUpdate.deltaUnits); \ |
| 68 EXPECT_EQ(kWheelScrollX, event->x); \ |
| 69 EXPECT_EQ(kWheelScrollY, event->y); \ |
| 70 EXPECT_EQ(kWheelScrollGlobalX, event->globalX); \ |
| 71 EXPECT_EQ(kWheelScrollGlobalY, event->globalY); |
| 72 |
| 73 #define EXPECT_GESTURE_SCROLL_UPDATE(event) \ |
| 74 EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event); \ |
| 75 EXPECT_FALSE(event->data.scrollUpdate.inertial); |
| 76 |
| 77 #define EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(event) \ |
| 78 EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event); \ |
| 79 EXPECT_TRUE(event->data.scrollUpdate.inertial); |
| 80 |
| 81 #define EXPECT_GESTURE_SCROLL_END_IMPL(event) \ |
| 82 EXPECT_EQ(WebInputEvent::GestureScrollEnd, event->type); \ |
| 83 EXPECT_EQ(scroll_units, event->data.scrollEnd.deltaUnits); \ |
| 84 EXPECT_EQ(kWheelScrollX, event->x); \ |
| 85 EXPECT_EQ(kWheelScrollY, event->y); \ |
| 86 EXPECT_EQ(kWheelScrollGlobalX, event->globalX); \ |
| 87 EXPECT_EQ(kWheelScrollGlobalY, event->globalY); |
| 88 |
| 89 #define EXPECT_GESTURE_SCROLL_END(event) \ |
| 90 EXPECT_GESTURE_SCROLL_END_IMPL(event); \ |
| 91 EXPECT_FALSE(event->data.scrollEnd.synthetic); \ |
| 92 EXPECT_FALSE(event->data.scrollEnd.inertial); |
| 93 |
| 94 #define EXPECT_SYNTHETIC_GESTURE_SCROLL_END(event) \ |
| 95 EXPECT_GESTURE_SCROLL_END_IMPL(event); \ |
| 96 EXPECT_TRUE(event->data.scrollEnd.synthetic); \ |
| 97 EXPECT_FALSE(event->data.scrollEnd.inertial); |
| 98 |
| 99 #define EXPECT_INERTIAL_GESTURE_SCROLL_END(event) \ |
| 100 EXPECT_GESTURE_SCROLL_END_IMPL(event); \ |
| 101 EXPECT_FALSE(event->data.scrollEnd.synthetic); \ |
| 102 EXPECT_TRUE(event->data.scrollEnd.inertial); |
| 103 |
| 104 #define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(event) \ |
| 105 EXPECT_GESTURE_SCROLL_END_IMPL(event); \ |
| 106 EXPECT_TRUE(event->data.scrollEnd.synthetic); \ |
| 107 EXPECT_TRUE(event->data.scrollEnd.inertial); |
| 108 |
| 109 #define EXPECT_MOUSE_WHEEL(event) \ |
| 110 EXPECT_EQ(WebInputEvent::MouseWheel, event->type); |
| 111 |
37 } // namespace | 112 } // namespace |
38 | 113 |
39 class MouseWheelEventQueueTest : public testing::Test, | 114 class MouseWheelEventQueueTest : public testing::Test, |
40 public MouseWheelEventQueueClient { | 115 public MouseWheelEventQueueClient { |
41 public: | 116 public: |
42 MouseWheelEventQueueTest() | 117 MouseWheelEventQueueTest() |
43 : acked_event_count_(0), | 118 : acked_event_count_(0), |
44 last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) { | 119 last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) { |
45 SetUpForGestureTesting(false); | 120 SetUpForGestureTesting(false); |
46 } | 121 } |
47 | 122 |
48 ~MouseWheelEventQueueTest() override {} | 123 ~MouseWheelEventQueueTest() override {} |
49 | 124 |
50 // MouseWheelEventQueueClient | 125 // MouseWheelEventQueueClient |
51 void SendMouseWheelEventImmediately( | 126 void SendMouseWheelEventImmediately( |
52 const MouseWheelEventWithLatencyInfo& event) override { | 127 const MouseWheelEventWithLatencyInfo& event) override { |
53 sent_events_.push_back(event.event); | 128 WebMouseWheelEvent* cloned_event = new WebMouseWheelEvent(); |
| 129 scoped_ptr<WebInputEvent> cloned_event_holder(cloned_event); |
| 130 *cloned_event = event.event; |
| 131 sent_events_.push_back(std::move(cloned_event_holder)); |
54 } | 132 } |
55 | 133 |
56 void SendGestureEvent(const GestureEventWithLatencyInfo& event) override { | 134 void SendGestureEvent(const GestureEventWithLatencyInfo& event) override { |
57 sent_events_.push_back(event.event); | 135 WebGestureEvent* cloned_event = new WebGestureEvent(); |
58 sent_gesture_events_.push_back(event.event); | 136 scoped_ptr<WebInputEvent> cloned_event_holder(cloned_event); |
| 137 *cloned_event = event.event; |
| 138 sent_events_.push_back(std::move(cloned_event_holder)); |
59 } | 139 } |
60 | 140 |
61 void OnMouseWheelEventAck(const MouseWheelEventWithLatencyInfo& event, | 141 void OnMouseWheelEventAck(const MouseWheelEventWithLatencyInfo& event, |
62 InputEventAckState ack_result) override { | 142 InputEventAckState ack_result) override { |
63 ++acked_event_count_; | 143 ++acked_event_count_; |
64 last_acked_event_ = event.event; | 144 last_acked_event_ = event.event; |
65 last_acked_event_state_ = ack_result; | 145 last_acked_event_state_ = ack_result; |
66 } | 146 } |
67 | 147 |
68 protected: | 148 protected: |
69 void SetUpForGestureTesting(bool send_gestures) { | 149 void SetUpForGestureTesting(bool send_gestures) { |
70 queue_.reset( | 150 queue_.reset( |
71 new MouseWheelEventQueue(this, send_gestures, kScrollEndTimeoutMs)); | 151 new MouseWheelEventQueue(this, send_gestures, kScrollEndTimeoutMs)); |
72 } | 152 } |
73 | 153 |
74 size_t queued_event_count() const { return queue_->queued_size(); } | 154 size_t queued_event_count() const { return queue_->queued_size(); } |
75 | 155 |
76 bool event_in_flight() const { return queue_->event_in_flight(); } | 156 bool event_in_flight() const { return queue_->event_in_flight(); } |
77 | 157 |
78 std::vector<WebInputEvent>& all_sent_events() { return sent_events_; } | 158 std::vector<scoped_ptr<WebInputEvent>>& all_sent_events() { |
| 159 return sent_events_; |
| 160 } |
79 | 161 |
80 std::vector<WebGestureEvent>& sent_gesture_events() { | 162 const scoped_ptr<WebInputEvent>& sent_input_event(size_t index) { |
81 return sent_gesture_events_; | 163 return sent_events_[index]; |
| 164 } |
| 165 const WebGestureEvent* sent_gesture_event(size_t index) { |
| 166 return static_cast<WebGestureEvent*>(sent_events_[index].get()); |
82 } | 167 } |
83 | 168 |
84 const WebMouseWheelEvent& acked_event() const { return last_acked_event_; } | 169 const WebMouseWheelEvent& acked_event() const { return last_acked_event_; } |
85 | 170 |
86 size_t GetAndResetSentEventCount() { | 171 size_t GetAndResetSentEventCount() { |
87 size_t count = sent_events_.size(); | 172 size_t count = sent_events_.size(); |
88 sent_events_.clear(); | 173 sent_events_.clear(); |
89 sent_gesture_events_.clear(); | |
90 return count; | 174 return count; |
91 } | 175 } |
92 | 176 |
93 size_t GetAndResetAckedEventCount() { | 177 size_t GetAndResetAckedEventCount() { |
94 size_t count = acked_event_count_; | 178 size_t count = acked_event_count_; |
95 acked_event_count_ = 0; | 179 acked_event_count_ = 0; |
96 return count; | 180 return count; |
97 } | 181 } |
98 | 182 |
99 void SendMouseWheelEventAck(InputEventAckState ack_result) { | 183 void SendMouseWheelEventAck(InputEventAckState ack_result) { |
100 queue_->ProcessMouseWheelAck(ack_result, ui::LatencyInfo()); | 184 queue_->ProcessMouseWheelAck(ack_result, ui::LatencyInfo()); |
101 } | 185 } |
102 | 186 |
103 void SendMouseWheel(float x, | 187 void SendMouseWheel(float x, |
104 float y, | 188 float y, |
105 float global_x, | 189 float global_x, |
106 float global_y, | 190 float global_y, |
107 float dX, | 191 float dX, |
108 float dY, | 192 float dY, |
109 int modifiers, | 193 int modifiers, |
110 bool high_precision) { | 194 bool high_precision) { |
111 queue_->QueueEvent(MouseWheelEventWithLatencyInfo( | 195 queue_->QueueEvent(MouseWheelEventWithLatencyInfo( |
112 SyntheticWebMouseWheelEventBuilder::Build( | 196 SyntheticWebMouseWheelEventBuilder::Build( |
113 x, y, global_x, global_y, dX, dY, modifiers, high_precision))); | 197 x, y, global_x, global_y, dX, dY, modifiers, high_precision))); |
114 } | 198 } |
115 | 199 |
| 200 void SendMouseWheelWithPhase( |
| 201 float x, |
| 202 float y, |
| 203 float global_x, |
| 204 float global_y, |
| 205 float dX, |
| 206 float dY, |
| 207 int modifiers, |
| 208 bool high_precision, |
| 209 blink::WebMouseWheelEvent::Phase phase, |
| 210 blink::WebMouseWheelEvent::Phase momentum_phase) { |
| 211 WebMouseWheelEvent event = SyntheticWebMouseWheelEventBuilder::Build( |
| 212 x, y, global_x, global_y, dX, dY, modifiers, high_precision); |
| 213 event.phase = phase; |
| 214 event.momentumPhase = momentum_phase; |
| 215 queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event)); |
| 216 } |
| 217 |
116 void SendGestureEvent(WebInputEvent::Type type) { | 218 void SendGestureEvent(WebInputEvent::Type type) { |
117 WebGestureEvent event; | 219 WebGestureEvent event; |
118 event.type = type; | 220 event.type = type; |
119 event.sourceDevice = blink::WebGestureDeviceTouchscreen; | 221 event.sourceDevice = blink::WebGestureDeviceTouchscreen; |
120 queue_->OnGestureScrollEvent( | 222 queue_->OnGestureScrollEvent( |
121 GestureEventWithLatencyInfo(event, ui::LatencyInfo())); | 223 GestureEventWithLatencyInfo(event, ui::LatencyInfo())); |
122 } | 224 } |
123 | 225 |
124 static void RunTasksAndWait(base::TimeDelta delay) { | 226 static void RunTasksAndWait(base::TimeDelta delay) { |
125 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | 227 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
126 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay); | 228 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay); |
127 base::MessageLoop::current()->Run(); | 229 base::MessageLoop::current()->Run(); |
128 } | 230 } |
129 | 231 |
130 void GestureSendingTest(bool high_precision) { | 232 void GestureSendingTest(bool high_precision) { |
131 const WebGestureEvent::ScrollUnits scroll_units = | 233 const WebGestureEvent::ScrollUnits scroll_units = |
132 high_precision ? WebGestureEvent::PrecisePixels | 234 high_precision ? WebGestureEvent::PrecisePixels |
133 : WebGestureEvent::Pixels; | 235 : WebGestureEvent::Pixels; |
134 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 236 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
135 kWheelScrollGlobalY, 1, 1, 0, high_precision); | 237 kWheelScrollGlobalY, 1, 1, 0, high_precision); |
136 EXPECT_EQ(0U, queued_event_count()); | 238 EXPECT_EQ(0U, queued_event_count()); |
137 EXPECT_TRUE(event_in_flight()); | 239 EXPECT_TRUE(event_in_flight()); |
138 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 240 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
139 | 241 |
140 // The second mouse wheel should not be sent since one is already in queue. | 242 // The second mouse wheel should not be sent since one is already in |
| 243 // queue. |
141 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 244 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
142 kWheelScrollGlobalY, 5, 5, 0, high_precision); | 245 kWheelScrollGlobalY, 5, 5, 0, high_precision); |
143 EXPECT_EQ(1U, queued_event_count()); | 246 EXPECT_EQ(1U, queued_event_count()); |
144 EXPECT_TRUE(event_in_flight()); | 247 EXPECT_TRUE(event_in_flight()); |
145 EXPECT_EQ(0U, GetAndResetSentEventCount()); | 248 EXPECT_EQ(0U, GetAndResetSentEventCount()); |
146 | 249 |
147 // Receive an ACK for the mouse wheel event and release the next | 250 // Receive an ACK for the mouse wheel event and release the next |
148 // mouse wheel event. | 251 // mouse wheel event. |
149 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 252 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
150 EXPECT_EQ(0U, queued_event_count()); | 253 EXPECT_EQ(0U, queued_event_count()); |
151 EXPECT_TRUE(event_in_flight()); | 254 EXPECT_TRUE(event_in_flight()); |
152 EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); | 255 EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); |
153 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 256 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
154 EXPECT_EQ(3U, all_sent_events().size()); | 257 EXPECT_EQ(3U, all_sent_events().size()); |
155 EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type); | 258 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
156 EXPECT_EQ(scroll_units, | 259 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
157 sent_gesture_events()[0].data.scrollBegin.deltaHintUnits); | 260 EXPECT_MOUSE_WHEEL(sent_input_event(2)); |
158 EXPECT_EQ(kWheelScrollX, sent_gesture_events()[0].x); | |
159 EXPECT_EQ(kWheelScrollY, sent_gesture_events()[0].y); | |
160 EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[0].globalX); | |
161 EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[0].globalY); | |
162 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type); | |
163 EXPECT_EQ(scroll_units, | |
164 sent_gesture_events()[1].data.scrollUpdate.deltaUnits); | |
165 EXPECT_EQ(kWheelScrollX, sent_gesture_events()[1].x); | |
166 EXPECT_EQ(kWheelScrollY, sent_gesture_events()[1].y); | |
167 EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[1].globalX); | |
168 EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[1].globalY); | |
169 EXPECT_EQ(WebInputEvent::MouseWheel, all_sent_events()[2].type); | |
170 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 261 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
171 | 262 |
172 RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2); | 263 RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2); |
173 EXPECT_EQ(1U, all_sent_events().size()); | 264 EXPECT_EQ(1U, all_sent_events().size()); |
174 EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type); | 265 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0)); |
175 EXPECT_EQ(scroll_units, sent_gesture_events()[0].data.scrollEnd.deltaUnits); | 266 } |
176 EXPECT_EQ(kWheelScrollX, sent_gesture_events()[0].x); | 267 |
177 EXPECT_EQ(kWheelScrollY, sent_gesture_events()[0].y); | 268 void PhaseGestureSendingTest(bool high_precision) { |
178 EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[0].globalX); | 269 const WebGestureEvent::ScrollUnits scroll_units = |
179 EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[0].globalY); | 270 high_precision ? WebGestureEvent::PrecisePixels |
| 271 : WebGestureEvent::Pixels; |
| 272 |
| 273 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 274 kWheelScrollGlobalY, 1, 1, 0, high_precision, |
| 275 WebMouseWheelEvent::PhaseBegan, |
| 276 WebMouseWheelEvent::PhaseNone); |
| 277 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 278 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 279 EXPECT_EQ(3U, all_sent_events().size()); |
| 280 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
| 281 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
| 282 EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2)); |
| 283 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
| 284 |
| 285 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 286 kWheelScrollGlobalY, 5, 5, 0, high_precision, |
| 287 WebMouseWheelEvent::PhaseChanged, |
| 288 WebMouseWheelEvent::PhaseNone); |
| 289 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 290 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 291 EXPECT_EQ(3U, all_sent_events().size()); |
| 292 EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
| 293 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
| 294 EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2)); |
| 295 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
| 296 |
| 297 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 298 kWheelScrollGlobalY, 0, 0, 0, high_precision, |
| 299 WebMouseWheelEvent::PhaseEnded, |
| 300 WebMouseWheelEvent::PhaseNone); |
| 301 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 302 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 303 EXPECT_EQ(2U, all_sent_events().size()); |
| 304 EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
| 305 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(1)); |
| 306 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| 307 |
| 308 // Send a double phase end; OSX does it consistently. |
| 309 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 310 kWheelScrollGlobalY, 0, 0, 0, high_precision, |
| 311 WebMouseWheelEvent::PhaseEnded, |
| 312 WebMouseWheelEvent::PhaseNone); |
| 313 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 314 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 315 EXPECT_EQ(0U, all_sent_events().size()); |
| 316 EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| 317 |
| 318 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 319 kWheelScrollGlobalY, 5, 5, 0, high_precision, |
| 320 WebMouseWheelEvent::PhaseNone, |
| 321 WebMouseWheelEvent::PhaseBegan); |
| 322 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 323 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 324 EXPECT_EQ(3U, all_sent_events().size()); |
| 325 EXPECT_INERTIAL_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
| 326 EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
| 327 EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(2)); |
| 328 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
| 329 |
| 330 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 331 kWheelScrollGlobalY, 5, 5, 0, high_precision, |
| 332 WebMouseWheelEvent::PhaseNone, |
| 333 WebMouseWheelEvent::PhaseChanged); |
| 334 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 335 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 336 EXPECT_EQ(3U, all_sent_events().size()); |
| 337 EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
| 338 EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
| 339 EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(2)); |
| 340 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
| 341 |
| 342 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
| 343 kWheelScrollGlobalY, 0, 0, 0, high_precision, |
| 344 WebMouseWheelEvent::PhaseNone, |
| 345 WebMouseWheelEvent::PhaseEnded); |
| 346 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| 347 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 348 EXPECT_EQ(2U, all_sent_events().size()); |
| 349 EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
| 350 EXPECT_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(1)); |
| 351 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
180 } | 352 } |
181 | 353 |
182 scoped_ptr<MouseWheelEventQueue> queue_; | 354 scoped_ptr<MouseWheelEventQueue> queue_; |
183 std::vector<WebInputEvent> sent_events_; | 355 std::vector<scoped_ptr<WebInputEvent>> sent_events_; |
184 std::vector<WebGestureEvent> sent_gesture_events_; | |
185 size_t acked_event_count_; | 356 size_t acked_event_count_; |
186 InputEventAckState last_acked_event_state_; | 357 InputEventAckState last_acked_event_state_; |
187 base::MessageLoopForUI message_loop_; | 358 base::MessageLoopForUI message_loop_; |
188 WebMouseWheelEvent last_acked_event_; | 359 WebMouseWheelEvent last_acked_event_; |
189 }; | 360 }; |
190 | 361 |
191 // Tests that mouse wheel events are queued properly. | 362 // Tests that mouse wheel events are queued properly. |
192 TEST_F(MouseWheelEventQueueTest, Basic) { | 363 TEST_F(MouseWheelEventQueueTest, Basic) { |
193 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 364 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
194 kWheelScrollGlobalY, 1, 1, 0, false); | 365 kWheelScrollGlobalY, 1, 1, 0, false); |
(...skipping 28 matching lines...) Expand all Loading... |
223 TEST_F(MouseWheelEventQueueTest, GestureSending) { | 394 TEST_F(MouseWheelEventQueueTest, GestureSending) { |
224 SetUpForGestureTesting(true); | 395 SetUpForGestureTesting(true); |
225 GestureSendingTest(false); | 396 GestureSendingTest(false); |
226 } | 397 } |
227 | 398 |
228 TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) { | 399 TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) { |
229 SetUpForGestureTesting(true); | 400 SetUpForGestureTesting(true); |
230 GestureSendingTest(false); | 401 GestureSendingTest(false); |
231 } | 402 } |
232 | 403 |
| 404 TEST_F(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) { |
| 405 SetUpForGestureTesting(true); |
| 406 PhaseGestureSendingTest(false); |
| 407 } |
| 408 |
| 409 TEST_F(MouseWheelEventQueueTest, |
| 410 GestureSendingWithPhaseInformationPrecisePixels) { |
| 411 SetUpForGestureTesting(true); |
| 412 PhaseGestureSendingTest(true); |
| 413 } |
| 414 |
233 TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) { | 415 TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) { |
234 SetUpForGestureTesting(true); | 416 SetUpForGestureTesting(true); |
| 417 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::Pixels; |
| 418 |
235 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 419 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
236 kWheelScrollGlobalY, 1, 1, 0, false); | 420 kWheelScrollGlobalY, 1, 1, 0, false); |
237 EXPECT_EQ(0U, queued_event_count()); | 421 EXPECT_EQ(0U, queued_event_count()); |
238 EXPECT_TRUE(event_in_flight()); | 422 EXPECT_TRUE(event_in_flight()); |
239 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 423 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
240 | 424 |
241 // Receive an ACK for the mouse wheel event. | 425 // Receive an ACK for the mouse wheel event. |
242 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 426 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
243 EXPECT_EQ(0U, queued_event_count()); | 427 EXPECT_EQ(0U, queued_event_count()); |
244 EXPECT_FALSE(event_in_flight()); | 428 EXPECT_FALSE(event_in_flight()); |
245 EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); | 429 EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); |
246 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 430 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
247 EXPECT_EQ(2U, all_sent_events().size()); | 431 EXPECT_EQ(2U, all_sent_events().size()); |
248 EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type); | 432 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
249 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type); | 433 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
250 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 434 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
251 | 435 |
252 // Ensure that a gesture scroll begin terminates the current scroll event. | 436 // Ensure that a gesture scroll begin terminates the current scroll event. |
253 SendGestureEvent(WebInputEvent::GestureScrollBegin); | 437 SendGestureEvent(WebInputEvent::GestureScrollBegin); |
254 EXPECT_EQ(1U, all_sent_events().size()); | 438 EXPECT_EQ(1U, all_sent_events().size()); |
255 EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type); | 439 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0)); |
256 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 440 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
257 | 441 |
258 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 442 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
259 kWheelScrollGlobalY, 1, 1, 0, false); | 443 kWheelScrollGlobalY, 1, 1, 0, false); |
260 EXPECT_EQ(0U, queued_event_count()); | 444 EXPECT_EQ(0U, queued_event_count()); |
261 EXPECT_TRUE(event_in_flight()); | 445 EXPECT_TRUE(event_in_flight()); |
262 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 446 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
263 | 447 |
264 // New mouse wheel events won't cause gestures because a scroll | 448 // New mouse wheel events won't cause gestures because a scroll |
265 // is already in progress by another device. | 449 // is already in progress by another device. |
(...skipping 13 matching lines...) Expand all Loading... |
279 EXPECT_TRUE(event_in_flight()); | 463 EXPECT_TRUE(event_in_flight()); |
280 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 464 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
281 | 465 |
282 // Receive an ACK for the mouse wheel event. | 466 // Receive an ACK for the mouse wheel event. |
283 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 467 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
284 EXPECT_EQ(0U, queued_event_count()); | 468 EXPECT_EQ(0U, queued_event_count()); |
285 EXPECT_FALSE(event_in_flight()); | 469 EXPECT_FALSE(event_in_flight()); |
286 EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); | 470 EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); |
287 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 471 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
288 EXPECT_EQ(2U, all_sent_events().size()); | 472 EXPECT_EQ(2U, all_sent_events().size()); |
289 EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type); | 473 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
290 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type); | 474 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
291 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 475 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
292 } | 476 } |
293 | 477 |
294 } // namespace content | 478 } // namespace content |
OLD | NEW |