Flutter Linux Embedder
fl_pointer_manager_test.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
8 
9 #include "flutter/shell/platform/linux/testing/linux_test.h"
10 #include "gtest/gtest.h"
11 
12 class FlPointerManagerTest : public flutter::testing::LinuxTest {};
13 
15  StartEngine();
16 
17  std::vector<FlutterPointerEvent> pointer_events;
18  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
19  SendPointerEvent,
20  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
21  size_t events_count) {
22  for (size_t i = 0; i < events_count; i++) {
23  pointer_events.push_back(events[i]);
24  }
25 
26  return kSuccess;
27  }));
28 
29  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
30  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
31  1.0, 2.0, 0, 0, 0);
32  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
33  3.0, 4.0, 0, 0);
34 
35  EXPECT_EQ(pointer_events.size(), 2u);
36 
37  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
38  EXPECT_EQ(pointer_events[0].x, 1.0);
39  EXPECT_EQ(pointer_events[0].y, 2.0);
40  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
41  EXPECT_EQ(pointer_events[0].buttons, 0);
42  EXPECT_EQ(pointer_events[0].view_id, 42);
43 
44  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
45  EXPECT_EQ(pointer_events[1].x, 3.0);
46  EXPECT_EQ(pointer_events[1].y, 4.0);
47  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
48  EXPECT_EQ(pointer_events[1].buttons, 0);
49  EXPECT_EQ(pointer_events[1].view_id, 42);
50 }
51 
53  StartEngine();
54 
55  std::vector<FlutterPointerEvent> pointer_events;
56  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
57  SendPointerEvent,
58  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
59  size_t events_count) {
60  for (size_t i = 0; i < events_count; i++) {
61  pointer_events.push_back(events[i]);
62  }
63 
64  return kSuccess;
65  }));
66 
67  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
68  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
69  1.0, 2.0, 0, 0, 0);
70  // Duplicate enter is ignored
71  fl_pointer_manager_handle_enter(manager, 1235, kFlutterPointerDeviceKindMouse,
72  3.0, 4.0, 0, 0, 0);
73 
74  EXPECT_EQ(pointer_events.size(), 1u);
75 
76  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
77  EXPECT_EQ(pointer_events[0].x, 1.0);
78  EXPECT_EQ(pointer_events[0].y, 2.0);
79  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
80  EXPECT_EQ(pointer_events[0].buttons, 0);
81  EXPECT_EQ(pointer_events[0].view_id, 42);
82 }
83 
84 TEST_F(FlPointerManagerTest, EnterLeaveLeave) {
85  StartEngine();
86 
87  std::vector<FlutterPointerEvent> pointer_events;
88  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
89  SendPointerEvent,
90  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
91  size_t events_count) {
92  for (size_t i = 0; i < events_count; i++) {
93  pointer_events.push_back(events[i]);
94  }
95 
96  return kSuccess;
97  }));
98 
99  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
100  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
101  1.0, 2.0, 0, 0, 0);
102  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
103  3.0, 4.0, 0, 0);
104  // Duplicate leave is ignored
105  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
106  5.0, 6.0, 0, 0);
107 
108  EXPECT_EQ(pointer_events.size(), 2u);
109 
110  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
111  EXPECT_EQ(pointer_events[0].x, 1.0);
112  EXPECT_EQ(pointer_events[0].y, 2.0);
113  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
114  EXPECT_EQ(pointer_events[0].buttons, 0);
115  EXPECT_EQ(pointer_events[0].view_id, 42);
116 
117  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
118  EXPECT_EQ(pointer_events[1].x, 3.0);
119  EXPECT_EQ(pointer_events[1].y, 4.0);
120  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
121  EXPECT_EQ(pointer_events[1].buttons, 0);
122  EXPECT_EQ(pointer_events[1].view_id, 42);
123 }
124 
125 TEST_F(FlPointerManagerTest, EnterButtonPress) {
126  StartEngine();
127 
128  std::vector<FlutterPointerEvent> pointer_events;
129  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
130  SendPointerEvent,
131  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
132  size_t events_count) {
133  for (size_t i = 0; i < events_count; i++) {
134  pointer_events.push_back(events[i]);
135  }
136 
137  return kSuccess;
138  }));
139 
140  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
141  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
142  1.0, 2.0, 0, 0, 0);
144  kFlutterPointerDeviceKindMouse, 4.0,
145  8.0, GDK_BUTTON_PRIMARY, 0, 0);
146 
147  EXPECT_EQ(pointer_events.size(), 2u);
148 
149  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
150  EXPECT_EQ(pointer_events[0].x, 1.0);
151  EXPECT_EQ(pointer_events[0].y, 2.0);
152  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
153  EXPECT_EQ(pointer_events[0].buttons, 0);
154  EXPECT_EQ(pointer_events[0].view_id, 42);
155 
156  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
157  EXPECT_EQ(pointer_events[1].x, 4.0);
158  EXPECT_EQ(pointer_events[1].y, 8.0);
159  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
160  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
161  EXPECT_EQ(pointer_events[1].view_id, 42);
162 }
163 
164 TEST_F(FlPointerManagerTest, NoEnterButtonPress) {
165  StartEngine();
166 
167  std::vector<FlutterPointerEvent> pointer_events;
168  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
169  SendPointerEvent,
170  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
171  size_t events_count) {
172  for (size_t i = 0; i < events_count; i++) {
173  pointer_events.push_back(events[i]);
174  }
175 
176  return kSuccess;
177  }));
178 
179  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
181  kFlutterPointerDeviceKindMouse, 4.0,
182  8.0, GDK_BUTTON_PRIMARY, 0, 0);
183 
184  EXPECT_EQ(pointer_events.size(), 2u);
185 
186  // Synthetic enter events
187  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
188  EXPECT_EQ(pointer_events[0].x, 4.0);
189  EXPECT_EQ(pointer_events[0].y, 8.0);
190  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
191  EXPECT_EQ(pointer_events[0].buttons, 0);
192  EXPECT_EQ(pointer_events[0].view_id, 42);
193 
194  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
195  EXPECT_EQ(pointer_events[1].x, 4.0);
196  EXPECT_EQ(pointer_events[1].y, 8.0);
197  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
198  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
199  EXPECT_EQ(pointer_events[1].view_id, 42);
200 }
201 
202 TEST_F(FlPointerManagerTest, ButtonPressButtonReleasePrimary) {
203  StartEngine();
204 
205  std::vector<FlutterPointerEvent> pointer_events;
206  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
207  SendPointerEvent,
208  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
209  size_t events_count) {
210  for (size_t i = 0; i < events_count; i++) {
211  pointer_events.push_back(events[i]);
212  }
213 
214  return kSuccess;
215  }));
216 
217  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
219  kFlutterPointerDeviceKindMouse, 4.0,
220  8.0, GDK_BUTTON_PRIMARY, 0, 0);
222  kFlutterPointerDeviceKindMouse, 5.0,
223  9.0, GDK_BUTTON_PRIMARY, 0, 0);
224 
225  EXPECT_EQ(pointer_events.size(), 3u);
226 
227  // Ignore first synthetic enter event
228  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
229  EXPECT_EQ(pointer_events[1].x, 4.0);
230  EXPECT_EQ(pointer_events[1].y, 8.0);
231  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
232  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
233  EXPECT_EQ(pointer_events[1].view_id, 42);
234  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
235  EXPECT_EQ(pointer_events[2].x, 5.0);
236  EXPECT_EQ(pointer_events[2].y, 9.0);
237  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
238  EXPECT_EQ(pointer_events[2].buttons, 0);
239  EXPECT_EQ(pointer_events[2].view_id, 42);
240 }
241 
242 TEST_F(FlPointerManagerTest, ButtonPressButtonReleaseSecondary) {
243  StartEngine();
244 
245  std::vector<FlutterPointerEvent> pointer_events;
246  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
247  SendPointerEvent,
248  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
249  size_t events_count) {
250  for (size_t i = 0; i < events_count; i++) {
251  pointer_events.push_back(events[i]);
252  }
253 
254  return kSuccess;
255  }));
256 
257  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
259  kFlutterPointerDeviceKindMouse, 4.0,
260  8.0, GDK_BUTTON_SECONDARY, 0, 0);
262  kFlutterPointerDeviceKindMouse, 5.0,
263  9.0, GDK_BUTTON_SECONDARY, 0, 0);
264 
265  EXPECT_EQ(pointer_events.size(), 3u);
266 
267  // Ignore first synthetic enter event
268  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
269  EXPECT_EQ(pointer_events[1].x, 4.0);
270  EXPECT_EQ(pointer_events[1].y, 8.0);
271  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
272  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseSecondary);
273  EXPECT_EQ(pointer_events[1].view_id, 42);
274  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
275  EXPECT_EQ(pointer_events[2].x, 5.0);
276  EXPECT_EQ(pointer_events[2].y, 9.0);
277  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
278  EXPECT_EQ(pointer_events[2].buttons, 0);
279  EXPECT_EQ(pointer_events[2].view_id, 42);
280 }
281 
282 TEST_F(FlPointerManagerTest, ButtonPressButtonReleaseMiddle) {
283  StartEngine();
284 
285  std::vector<FlutterPointerEvent> pointer_events;
286  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
287  SendPointerEvent,
288  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
289  size_t events_count) {
290  for (size_t i = 0; i < events_count; i++) {
291  pointer_events.push_back(events[i]);
292  }
293 
294  return kSuccess;
295  }));
296 
297  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
299  kFlutterPointerDeviceKindMouse, 4.0,
300  8.0, GDK_BUTTON_MIDDLE, 0, 0);
302  kFlutterPointerDeviceKindMouse, 5.0,
303  9.0, GDK_BUTTON_MIDDLE, 0, 0);
304 
305  EXPECT_EQ(pointer_events.size(), 3u);
306 
307  // Ignore first synthetic enter event
308  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
309  EXPECT_EQ(pointer_events[1].x, 4.0);
310  EXPECT_EQ(pointer_events[1].y, 8.0);
311  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
312  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseMiddle);
313  EXPECT_EQ(pointer_events[1].view_id, 42);
314  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
315  EXPECT_EQ(pointer_events[2].x, 5.0);
316  EXPECT_EQ(pointer_events[2].y, 9.0);
317  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
318  EXPECT_EQ(pointer_events[2].buttons, 0);
319  EXPECT_EQ(pointer_events[2].view_id, 42);
320 }
321 
322 TEST_F(FlPointerManagerTest, ButtonPressButtonReleaseBack) {
323  StartEngine();
324 
325  std::vector<FlutterPointerEvent> pointer_events;
326  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
327  SendPointerEvent,
328  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
329  size_t events_count) {
330  for (size_t i = 0; i < events_count; i++) {
331  pointer_events.push_back(events[i]);
332  }
333 
334  return kSuccess;
335  }));
336 
337  // Forward button is 8 (no GDK define).
338  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
340  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0, 8, 0, 0);
342  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 8, 0, 0);
343 
344  EXPECT_EQ(pointer_events.size(), 3u);
345 
346  // Ignore first synthetic enter event
347  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
348  EXPECT_EQ(pointer_events[1].x, 4.0);
349  EXPECT_EQ(pointer_events[1].y, 8.0);
350  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
351  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseBack);
352  EXPECT_EQ(pointer_events[1].view_id, 42);
353  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
354  EXPECT_EQ(pointer_events[2].x, 5.0);
355  EXPECT_EQ(pointer_events[2].y, 9.0);
356  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
357  EXPECT_EQ(pointer_events[2].buttons, 0);
358  EXPECT_EQ(pointer_events[2].view_id, 42);
359 }
360 
361 TEST_F(FlPointerManagerTest, ButtonPressButtonReleaseForward) {
362  StartEngine();
363 
364  std::vector<FlutterPointerEvent> pointer_events;
365  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
366  SendPointerEvent,
367  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
368  size_t events_count) {
369  for (size_t i = 0; i < events_count; i++) {
370  pointer_events.push_back(events[i]);
371  }
372 
373  return kSuccess;
374  }));
375 
376  // Forward button is 9 (no GDK define).
377  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
379  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0, 9, 0, 0);
381  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 9, 0, 0);
382 
383  EXPECT_EQ(pointer_events.size(), 3u);
384 
385  // Ignore first synthetic enter event
386  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
387  EXPECT_EQ(pointer_events[1].x, 4.0);
388  EXPECT_EQ(pointer_events[1].y, 8.0);
389  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
390  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseForward);
391  EXPECT_EQ(pointer_events[1].view_id, 42);
392  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
393  EXPECT_EQ(pointer_events[2].x, 5.0);
394  EXPECT_EQ(pointer_events[2].y, 9.0);
395  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
396  EXPECT_EQ(pointer_events[2].buttons, 0);
397  EXPECT_EQ(pointer_events[2].view_id, 42);
398 }
399 
400 TEST_F(FlPointerManagerTest, ButtonPressButtonReleaseThreeButtons) {
401  StartEngine();
402 
403  std::vector<FlutterPointerEvent> pointer_events;
404  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
405  SendPointerEvent,
406  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
407  size_t events_count) {
408  for (size_t i = 0; i < events_count; i++) {
409  pointer_events.push_back(events[i]);
410  }
411 
412  return kSuccess;
413  }));
414 
415  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
416  // Press buttons 1-2-3, release 3-2-1
418  kFlutterPointerDeviceKindMouse, 1.0,
419  2.0, GDK_BUTTON_PRIMARY, 0, 0);
421  kFlutterPointerDeviceKindMouse, 3.0,
422  4.0, GDK_BUTTON_SECONDARY, 0, 0);
424  kFlutterPointerDeviceKindMouse, 5.0,
425  6.0, GDK_BUTTON_MIDDLE, 0, 0);
427  kFlutterPointerDeviceKindMouse, 7.0,
428  8.0, GDK_BUTTON_MIDDLE, 0, 0);
430  kFlutterPointerDeviceKindMouse, 9.0,
431  10.0, GDK_BUTTON_SECONDARY, 0, 0);
433  manager, 1239, kFlutterPointerDeviceKindMouse, 11.0, 12.0,
434  kFlutterPointerButtonMousePrimary, 0, 0);
435 
436  EXPECT_EQ(pointer_events.size(), 7u);
437 
438  // Ignore first synthetic enter event
439  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
440  EXPECT_EQ(pointer_events[1].x, 1.0);
441  EXPECT_EQ(pointer_events[1].y, 2.0);
442  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
443  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
444  EXPECT_EQ(pointer_events[2].x, 3.0);
445  EXPECT_EQ(pointer_events[2].y, 4.0);
446  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary |
447  kFlutterPointerButtonMouseSecondary);
448  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
449  EXPECT_EQ(pointer_events[3].x, 5.0);
450  EXPECT_EQ(pointer_events[3].y, 6.0);
451  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary |
452  kFlutterPointerButtonMouseSecondary |
453  kFlutterPointerButtonMouseMiddle);
454  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
455  EXPECT_EQ(pointer_events[4].x, 7.0);
456  EXPECT_EQ(pointer_events[4].y, 8.0);
457  EXPECT_EQ(pointer_events[4].buttons, kFlutterPointerButtonMousePrimary |
458  kFlutterPointerButtonMouseSecondary);
459  EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
460  EXPECT_EQ(pointer_events[5].x, 9.0);
461  EXPECT_EQ(pointer_events[5].y, 10.0);
462  EXPECT_EQ(pointer_events[5].buttons, kFlutterPointerButtonMousePrimary);
463  EXPECT_EQ(pointer_events[6].timestamp, 1239000u);
464  EXPECT_EQ(pointer_events[6].x, 11.0);
465  EXPECT_EQ(pointer_events[6].y, 12.0);
466  EXPECT_EQ(pointer_events[6].buttons, 0);
467 }
468 
469 TEST_F(FlPointerManagerTest, ButtonPressStylusPrimaryButton) {
470  StartEngine();
471 
472  constexpr int64_t kStylusContact = 1 << 0;
473  constexpr int64_t kStylusPrimary = 1 << 1;
474 
475  std::vector<FlutterPointerEvent> pointer_events;
476  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
477  SendPointerEvent,
478  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
479  size_t events_count) {
480  for (size_t i = 0; i < events_count; i++) {
481  pointer_events.push_back(events[i]);
482  }
483 
484  return kSuccess;
485  }));
486 
487  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
489  kFlutterPointerDeviceKindStylus, 4.0,
490  8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
492  kFlutterPointerDeviceKindStylus, 4.0,
493  8.0, GDK_BUTTON_SECONDARY, 0.0, 0.5);
494 
495  EXPECT_EQ(pointer_events.size(), 3u);
496  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindStylus);
497  EXPECT_EQ(pointer_events[2].buttons, kStylusContact | kStylusPrimary);
498 }
499 
500 TEST_F(FlPointerManagerTest, ButtonPressStylusContact) {
501  StartEngine();
502 
503  constexpr int64_t kStylusContact = 1 << 0;
504 
505  std::vector<FlutterPointerEvent> pointer_events;
506  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
507  SendPointerEvent,
508  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
509  size_t events_count) {
510  for (size_t i = 0; i < events_count; i++) {
511  pointer_events.push_back(events[i]);
512  }
513 
514  return kSuccess;
515  }));
516 
517  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
519  kFlutterPointerDeviceKindStylus, 4.0,
520  8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
521 
522  EXPECT_EQ(pointer_events.size(), 2u);
523  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindStylus);
524  EXPECT_EQ(pointer_events[1].buttons, kStylusContact);
525 }
526 
527 TEST_F(FlPointerManagerTest, ButtonPressInvertedStylusContact) {
528  StartEngine();
529 
530  constexpr int64_t kStylusContact = 1 << 0;
531 
532  std::vector<FlutterPointerEvent> pointer_events;
533  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
534  SendPointerEvent,
535  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
536  size_t events_count) {
537  for (size_t i = 0; i < events_count; i++) {
538  pointer_events.push_back(events[i]);
539  }
540 
541  return kSuccess;
542  }));
543 
544  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
546  manager, 1234, kFlutterPointerDeviceKindInvertedStylus, 4.0, 8.0,
547  GDK_BUTTON_PRIMARY, 0.0, 0.5);
548 
549  EXPECT_EQ(pointer_events.size(), 2u);
550  EXPECT_EQ(pointer_events[1].device_kind,
551  kFlutterPointerDeviceKindInvertedStylus);
552  EXPECT_EQ(pointer_events[1].buttons, kStylusContact);
553 }
554 
555 TEST_F(FlPointerManagerTest, ButtonPressStylusSecondaryButton) {
556  StartEngine();
557 
558  constexpr int64_t kStylusContact = 1 << 0;
559  constexpr int64_t kStylusSecondary = 1 << 2;
560 
561  std::vector<FlutterPointerEvent> pointer_events;
562  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
563  SendPointerEvent,
564  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
565  size_t events_count) {
566  for (size_t i = 0; i < events_count; i++) {
567  pointer_events.push_back(events[i]);
568  }
569 
570  return kSuccess;
571  }));
572 
573  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
575  kFlutterPointerDeviceKindStylus, 4.0,
576  8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
578  kFlutterPointerDeviceKindStylus, 4.0,
579  8.0, GDK_BUTTON_MIDDLE, 0.0, 0.5);
580 
581  EXPECT_EQ(pointer_events.size(), 3u);
582  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindStylus);
583  EXPECT_EQ(pointer_events[2].buttons, kStylusContact | kStylusSecondary);
584 }
585 
586 TEST_F(FlPointerManagerTest, ButtonPressStylusUnknownButton) {
587  StartEngine();
588 
589  std::vector<FlutterPointerEvent> pointer_events;
590  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
591  SendPointerEvent,
592  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
593  size_t events_count) {
594  for (size_t i = 0; i < events_count; i++) {
595  pointer_events.push_back(events[i]);
596  }
597 
598  return kSuccess;
599  }));
600 
601  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
603  manager, 1234, kFlutterPointerDeviceKindStylus, 4.0, 8.0, 8, 0, 0);
604 
605  EXPECT_EQ(pointer_events.size(), 0u);
606 }
607 
608 TEST_F(FlPointerManagerTest, ButtonPressButtonPressButtonRelease) {
609  StartEngine();
610 
611  std::vector<FlutterPointerEvent> pointer_events;
612  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
613  SendPointerEvent,
614  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
615  size_t events_count) {
616  for (size_t i = 0; i < events_count; i++) {
617  pointer_events.push_back(events[i]);
618  }
619 
620  return kSuccess;
621  }));
622 
623  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
625  kFlutterPointerDeviceKindMouse, 4.0,
626  8.0, GDK_BUTTON_PRIMARY, 0, 0);
627  // A second press without a release means the release was lost, e.g. it went
628  // to the window manager at the end of an interactive move. The stale press
629  // is cancelled and this press is handled.
631  kFlutterPointerDeviceKindMouse, 6.0,
632  10.0, GDK_BUTTON_PRIMARY, 0, 0);
634  kFlutterPointerDeviceKindMouse, 5.0,
635  9.0, GDK_BUTTON_PRIMARY, 0, 0);
636 
637  EXPECT_EQ(pointer_events.size(), 5u);
638 
639  // Ignore first synthetic enter event
640  EXPECT_EQ(pointer_events[1].phase, kDown);
641  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
642  EXPECT_EQ(pointer_events[1].x, 4.0);
643  EXPECT_EQ(pointer_events[1].y, 8.0);
644  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
645  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
646  EXPECT_EQ(pointer_events[1].view_id, 42);
647  EXPECT_EQ(pointer_events[2].phase, kCancel);
648  EXPECT_EQ(pointer_events[2].timestamp, 1234000u);
649  EXPECT_EQ(pointer_events[2].x, 6.0);
650  EXPECT_EQ(pointer_events[2].y, 10.0);
651  EXPECT_EQ(pointer_events[2].buttons, 0);
652  EXPECT_EQ(pointer_events[2].view_id, 42);
653  EXPECT_EQ(pointer_events[3].phase, kDown);
654  EXPECT_EQ(pointer_events[3].timestamp, 1234000u);
655  EXPECT_EQ(pointer_events[3].x, 6.0);
656  EXPECT_EQ(pointer_events[3].y, 10.0);
657  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary);
658  EXPECT_EQ(pointer_events[3].view_id, 42);
659  EXPECT_EQ(pointer_events[4].phase, kUp);
660  EXPECT_EQ(pointer_events[4].timestamp, 1235000u);
661  EXPECT_EQ(pointer_events[4].x, 5.0);
662  EXPECT_EQ(pointer_events[4].y, 9.0);
663  EXPECT_EQ(pointer_events[4].device_kind, kFlutterPointerDeviceKindMouse);
664  EXPECT_EQ(pointer_events[4].buttons, 0);
665  EXPECT_EQ(pointer_events[4].view_id, 42);
666 }
667 
669  StartEngine();
670 
671  std::vector<FlutterPointerEvent> pointer_events;
672  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
673  SendPointerEvent,
674  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
675  size_t events_count) {
676  for (size_t i = 0; i < events_count; i++) {
677  pointer_events.push_back(events[i]);
678  }
679 
680  return kSuccess;
681  }));
682 
683  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
685  kFlutterPointerDeviceKindMouse, 4.0,
686  8.0, GDK_BUTTON_PRIMARY, 0, 0);
688  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 0, 0);
689  // The grab was taken by the window manager, e.g. an interactive move
690  // started. The press is cancelled at the last known position.
691  EXPECT_TRUE(fl_pointer_manager_cancel_input(manager, 1236));
692  // A later press is not dropped.
694  kFlutterPointerDeviceKindMouse, 6.0,
695  10.0, GDK_BUTTON_PRIMARY, 0, 0);
696 
697  EXPECT_EQ(pointer_events.size(), 5u);
698 
699  // Ignore first synthetic enter event
700  EXPECT_EQ(pointer_events[1].phase, kDown);
701  EXPECT_EQ(pointer_events[2].phase, kMove);
702  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary);
703  EXPECT_EQ(pointer_events[3].phase, kCancel);
704  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
705  EXPECT_EQ(pointer_events[3].x, 5.0);
706  EXPECT_EQ(pointer_events[3].y, 9.0);
707  EXPECT_EQ(pointer_events[3].buttons, 0);
708  EXPECT_EQ(pointer_events[3].view_id, 42);
709  EXPECT_EQ(pointer_events[4].phase, kDown);
710  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
711  EXPECT_EQ(pointer_events[4].x, 6.0);
712  EXPECT_EQ(pointer_events[4].y, 10.0);
713  EXPECT_EQ(pointer_events[4].buttons, kFlutterPointerButtonMousePrimary);
714  EXPECT_EQ(pointer_events[4].view_id, 42);
715 }
716 
717 TEST_F(FlPointerManagerTest, CancelInputAfterLeave) {
718  StartEngine();
719 
720  std::vector<FlutterPointerEvent> pointer_events;
721  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
722  SendPointerEvent,
723  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
724  size_t events_count) {
725  for (size_t i = 0; i < events_count; i++) {
726  pointer_events.push_back(events[i]);
727  }
728 
729  return kSuccess;
730  }));
731 
732  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
734  kFlutterPointerDeviceKindMouse, 4.0,
735  8.0, GDK_BUTTON_PRIMARY, 0, 0);
736  // The pointer was dragged out of the view, the remove is delayed until the
737  // button is released.
738  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
739  5.0, 9.0, 0, 0);
740  // The release never arrives as the grab was broken, so the pointer is
741  // cancelled and removed.
742  EXPECT_TRUE(fl_pointer_manager_cancel_input(manager, 1236));
743 
744  EXPECT_EQ(pointer_events.size(), 4u);
745 
746  // Ignore first synthetic enter event
747  EXPECT_EQ(pointer_events[1].phase, kDown);
748  EXPECT_EQ(pointer_events[2].phase, kCancel);
749  EXPECT_EQ(pointer_events[2].x, 5.0);
750  EXPECT_EQ(pointer_events[2].y, 9.0);
751  EXPECT_EQ(pointer_events[3].phase, kRemove);
752  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
753  EXPECT_EQ(pointer_events[3].x, 5.0);
754  EXPECT_EQ(pointer_events[3].y, 9.0);
755  EXPECT_EQ(pointer_events[3].buttons, 0);
756  EXPECT_EQ(pointer_events[3].view_id, 42);
757 
758  // The pointer is added again when it returns.
759  fl_pointer_manager_handle_enter(manager, 1237, kFlutterPointerDeviceKindMouse,
760  6.0, 10.0, 0, 0, 0);
761  EXPECT_EQ(pointer_events.size(), 5u);
762  EXPECT_EQ(pointer_events[4].phase, kAdd);
763 }
764 
765 TEST_F(FlPointerManagerTest, CancelInputNoButtons) {
766  StartEngine();
767 
768  std::vector<FlutterPointerEvent> pointer_events;
769  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
770  SendPointerEvent,
771  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
772  size_t events_count) {
773  for (size_t i = 0; i < events_count; i++) {
774  pointer_events.push_back(events[i]);
775  }
776 
777  return kSuccess;
778  }));
779 
780  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
781  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
782  1.0, 2.0, 0, 0, 0);
783  // Nothing to cancel if no buttons are pressed.
784  EXPECT_FALSE(fl_pointer_manager_cancel_input(manager, 1235));
785 
786  EXPECT_EQ(pointer_events.size(), 1u);
787 }
788 
789 TEST_F(FlPointerManagerTest, PointerReturnsWithoutButtonPressed) {
790  StartEngine();
791 
792  std::vector<FlutterPointerEvent> pointer_events;
793  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
794  SendPointerEvent,
795  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
796  size_t events_count) {
797  for (size_t i = 0; i < events_count; i++) {
798  pointer_events.push_back(events[i]);
799  }
800 
801  return kSuccess;
802  }));
803 
804  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
806  kFlutterPointerDeviceKindMouse, 4.0,
807  8.0, GDK_BUTTON_PRIMARY, 0, 0);
808  // The window system took the pointer for an interactive move or resize and
809  // gave it back without saying the button was released, e.g. Wayland, where
810  // the compositor runs the drag and no grab is broken.
811  fl_pointer_manager_handle_enter(manager, 1235, kFlutterPointerDeviceKindMouse,
812  5.0, 9.0, 0, 0, 0);
813 
814  EXPECT_EQ(pointer_events.size(), 3u);
815 
816  // Ignore first synthetic enter event
817  EXPECT_EQ(pointer_events[1].phase, kDown);
818  EXPECT_EQ(pointer_events[2].phase, kCancel);
819  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
820  EXPECT_EQ(pointer_events[2].x, 5.0);
821  EXPECT_EQ(pointer_events[2].y, 9.0);
822  EXPECT_EQ(pointer_events[2].buttons, 0);
823  EXPECT_EQ(pointer_events[2].view_id, 42);
824 
825  // Motion is reported as hover again, i.e. with no buttons pressed.
827  manager, 1236, kFlutterPointerDeviceKindMouse, 6.0, 10.0, 0, 0);
828 
829  EXPECT_EQ(pointer_events.size(), 4u);
830  EXPECT_EQ(pointer_events[3].phase, kHover);
831  EXPECT_EQ(pointer_events[3].buttons, 0);
832 }
833 
834 TEST_F(FlPointerManagerTest, PointerReturnsWithButtonStillPressed) {
835  StartEngine();
836 
837  std::vector<FlutterPointerEvent> pointer_events;
838  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
839  SendPointerEvent,
840  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
841  size_t events_count) {
842  for (size_t i = 0; i < events_count; i++) {
843  pointer_events.push_back(events[i]);
844  }
845 
846  return kSuccess;
847  }));
848 
849  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
851  kFlutterPointerDeviceKindMouse, 4.0,
852  8.0, GDK_BUTTON_PRIMARY, 0, 0);
853  // The pointer was dragged back into the view with the button still held, so
854  // the press continues.
855  fl_pointer_manager_handle_enter(manager, 1235, kFlutterPointerDeviceKindMouse,
856  5.0, 9.0, GDK_BUTTON1_MASK, 0, 0);
857 
858  EXPECT_EQ(pointer_events.size(), 2u);
859  EXPECT_EQ(pointer_events[1].phase, kDown);
860 
862  kFlutterPointerDeviceKindMouse, 6.0,
863  10.0, GDK_BUTTON_PRIMARY, 0, 0);
864 
865  EXPECT_EQ(pointer_events.size(), 3u);
866  EXPECT_EQ(pointer_events[2].phase, kUp);
867 }
868 
869 TEST_F(FlPointerManagerTest, ButtonPressButtonReleaseButtonRelease) {
870  StartEngine();
871 
872  std::vector<FlutterPointerEvent> pointer_events;
873  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
874  SendPointerEvent,
875  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
876  size_t events_count) {
877  for (size_t i = 0; i < events_count; i++) {
878  pointer_events.push_back(events[i]);
879  }
880 
881  return kSuccess;
882  }));
883 
884  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
886  kFlutterPointerDeviceKindMouse, 4.0,
887  8.0, GDK_BUTTON_PRIMARY, 0, 0);
889  kFlutterPointerDeviceKindMouse, 5.0,
890  9.0, GDK_BUTTON_PRIMARY, 0, 0);
891  // Ignore duplicate release
893  kFlutterPointerDeviceKindMouse, 6.0,
894  10.0, GDK_BUTTON_PRIMARY, 0, 0);
895 
896  EXPECT_EQ(pointer_events.size(), 3u);
897 
898  // Ignore first synthetic enter event
899  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
900  EXPECT_EQ(pointer_events[1].x, 4.0);
901  EXPECT_EQ(pointer_events[1].y, 8.0);
902  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
903  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
904  EXPECT_EQ(pointer_events[1].view_id, 42);
905  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
906  EXPECT_EQ(pointer_events[2].x, 5.0);
907  EXPECT_EQ(pointer_events[2].y, 9.0);
908  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
909  EXPECT_EQ(pointer_events[2].buttons, 0);
910  EXPECT_EQ(pointer_events[2].view_id, 42);
911 }
912 
913 TEST_F(FlPointerManagerTest, NoButtonPressButtonRelease) {
914  StartEngine();
915 
916  std::vector<FlutterPointerEvent> pointer_events;
917  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
918  SendPointerEvent,
919  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
920  size_t events_count) {
921  for (size_t i = 0; i < events_count; i++) {
922  pointer_events.push_back(events[i]);
923  }
924 
925  return kSuccess;
926  }));
927 
928  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
929  // Release without associated press, will be ignored
931  kFlutterPointerDeviceKindMouse, 5.0,
932  9.0, GDK_BUTTON_PRIMARY, 0, 0);
933 
934  EXPECT_EQ(pointer_events.size(), 0u);
935 }
936 
938  StartEngine();
939 
940  std::vector<FlutterPointerEvent> pointer_events;
941  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
942  SendPointerEvent,
943  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
944  size_t events_count) {
945  for (size_t i = 0; i < events_count; i++) {
946  pointer_events.push_back(events[i]);
947  }
948 
949  return kSuccess;
950  }));
951 
952  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
954  manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0, 0, 0);
956  manager, 1235, kFlutterPointerDeviceKindMouse, 3.0, 4.0, 0, 0);
958  manager, 1236, kFlutterPointerDeviceKindMouse, 5.0, 6.0, 0, 0);
959 
960  EXPECT_EQ(pointer_events.size(), 4u);
961 
962  // Ignore first synthetic enter event
963  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
964  EXPECT_EQ(pointer_events[1].x, 1.0);
965  EXPECT_EQ(pointer_events[1].y, 2.0);
966  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
967  EXPECT_EQ(pointer_events[1].buttons, 0);
968  EXPECT_EQ(pointer_events[1].view_id, 42);
969  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
970  EXPECT_EQ(pointer_events[2].x, 3.0);
971  EXPECT_EQ(pointer_events[2].y, 4.0);
972  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
973  EXPECT_EQ(pointer_events[2].buttons, 0);
974  EXPECT_EQ(pointer_events[2].view_id, 42);
975  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
976  EXPECT_EQ(pointer_events[3].x, 5.0);
977  EXPECT_EQ(pointer_events[3].y, 6.0);
978  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindMouse);
979  EXPECT_EQ(pointer_events[3].buttons, 0);
980  EXPECT_EQ(pointer_events[3].view_id, 42);
981 }
982 
984  StartEngine();
985 
986  std::vector<FlutterPointerEvent> pointer_events;
987  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
988  SendPointerEvent,
989  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
990  size_t events_count) {
991  for (size_t i = 0; i < events_count; i++) {
992  pointer_events.push_back(events[i]);
993  }
994 
995  return kSuccess;
996  }));
997 
998  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
1000  manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0, 0, 0);
1002  kFlutterPointerDeviceKindMouse, 3.0,
1003  4.0, GDK_BUTTON_PRIMARY, 0, 0);
1005  manager, 1236, kFlutterPointerDeviceKindMouse, 5.0, 6.0, 0, 0);
1007  kFlutterPointerDeviceKindMouse, 7.0,
1008  8.0, GDK_BUTTON_PRIMARY, 0, 0);
1010  manager, 1238, kFlutterPointerDeviceKindMouse, 9.0, 10.0, 0, 0);
1011 
1012  EXPECT_EQ(pointer_events.size(), 6u);
1013 
1014  // Ignore first synthetic enter event
1015  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
1016  EXPECT_EQ(pointer_events[1].x, 1.0);
1017  EXPECT_EQ(pointer_events[1].y, 2.0);
1018  EXPECT_EQ(pointer_events[1].buttons, 0);
1019  EXPECT_EQ(pointer_events[1].view_id, 42);
1020  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
1021  EXPECT_EQ(pointer_events[2].x, 3.0);
1022  EXPECT_EQ(pointer_events[2].y, 4.0);
1023  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary);
1024  EXPECT_EQ(pointer_events[2].view_id, 42);
1025  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
1026  EXPECT_EQ(pointer_events[3].x, 5.0);
1027  EXPECT_EQ(pointer_events[3].y, 6.0);
1028  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary);
1029  EXPECT_EQ(pointer_events[3].view_id, 42);
1030  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
1031  EXPECT_EQ(pointer_events[4].x, 7.0);
1032  EXPECT_EQ(pointer_events[4].y, 8.0);
1033  EXPECT_EQ(pointer_events[4].buttons, 0);
1034  EXPECT_EQ(pointer_events[4].view_id, 42);
1035  EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
1036  EXPECT_EQ(pointer_events[5].x, 9.0);
1037  EXPECT_EQ(pointer_events[5].y, 10.0);
1038  EXPECT_EQ(pointer_events[5].buttons, 0);
1039  EXPECT_EQ(pointer_events[5].view_id, 42);
1040 }
1041 
1043  StartEngine();
1044 
1045  std::vector<FlutterPointerEvent> pointer_events;
1046  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
1047  SendPointerEvent,
1048  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
1049  size_t events_count) {
1050  for (size_t i = 0; i < events_count; i++) {
1051  pointer_events.push_back(events[i]);
1052  }
1053 
1054  return kSuccess;
1055  }));
1056 
1057  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
1059  manager, 1234, kFlutterPointerDeviceKindTrackpad, 1.0, 2.0, 0, 0, 0);
1061  kFlutterPointerDeviceKindTrackpad, 1.0,
1062  2.0, GDK_BUTTON_PRIMARY, 0, 0);
1064  manager, 1238, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0, 0, 0);
1066  kFlutterPointerDeviceKindTrackpad,
1067  3.0, 4.0, GDK_BUTTON_PRIMARY, 0, 0);
1069  manager, 1235, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0, 0, 0);
1070 
1071  EXPECT_EQ(pointer_events.size(), 5u);
1072 
1073  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
1074  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindTrackpad);
1075  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindTrackpad);
1076  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindTrackpad);
1077  EXPECT_EQ(pointer_events[4].device_kind, kFlutterPointerDeviceKindTrackpad);
1078 }
g_autoptr(FlEngine) engine
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:942
FlPointerManager * fl_pointer_manager_new(FlutterViewId view_id, FlEngine *engine)
gboolean fl_pointer_manager_cancel_input(FlPointerManager *self, guint event_time)
gboolean fl_pointer_manager_handle_button_press(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_motion(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_enter(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_state, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_button_release(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_leave(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
TEST_F(FlPointerManagerTest, EnterLeave)
G_BEGIN_DECLS FlutterViewId view_id