| Flutter Windows Embedder |

direct_manipulation_unittests.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
5 #include "flutter/shell/platform/windows/direct_manipulation.h"
6
7 #include "flutter/fml/macros.h"
8 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler_delegate.h"
9 #include "gtest/gtest.h"
10
11 using testing::_;
12
13 namespace flutter {
14 namespace testing {
15
16 class MockIDirectManipulationViewport : public IDirectManipulationViewport {
17 public:
18 MockIDirectManipulationViewport() {}
19
20 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, AddRef, ULONG());
21 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Release, ULONG());
22 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
23 QueryInterface,
24 HRESULT(REFIID, void**));
25 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Abandon, HRESULT());
26 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
27 ActivateConfiguration,
28 HRESULT(DIRECTMANIPULATION_CONFIGURATION));
29 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
30 AddConfiguration,
31 HRESULT(DIRECTMANIPULATION_CONFIGURATION));
32 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
33 AddContent,
34 HRESULT(IDirectManipulationContent*));
35 MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
36 AddEventHandler,
37 HRESULT(HWND,
38 IDirectManipulationViewportEventHandler*,
39 DWORD*));
40 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Disable, HRESULT());
41 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Enable, HRESULT());
42 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
43 GetPrimaryContent,
44 HRESULT(REFIID, void**));
45 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
46 GetStatus,
47 HRESULT(DIRECTMANIPULATION_STATUS*));
48 MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
49 GetTag,
50 HRESULT(REFIID, void**, UINT32*));
51 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
52 GetViewportRect,
53 HRESULT(RECT*));
54 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, ReleaseAllContacts, HRESULT());
55 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
56 ReleaseContact,
57 HRESULT(UINT32));
58 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
59 RemoveConfiguration,
60 HRESULT(DIRECTMANIPULATION_CONFIGURATION));
61 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
62 RemoveContent,
63 HRESULT(IDirectManipulationContent*));
64 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
65 RemoveEventHandler,
66 HRESULT(DWORD));
67 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
68 SetChaining,
69 HRESULT(DIRECTMANIPULATION_MOTION_TYPES));
70 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, SetContact, HRESULT(UINT32));
71 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
72 SetInputMode,
73 HRESULT(DIRECTMANIPULATION_INPUT_MODE));
74 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
75 SetManualGesture,
76 HRESULT(DIRECTMANIPULATION_GESTURE_CONFIGURATION));
77 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
78 SetTag,
79 HRESULT(IUnknown*, UINT32));
80 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
81 SetUpdateMode,
82 HRESULT(DIRECTMANIPULATION_INPUT_MODE));
83 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
84 SetViewportOptions,
85 HRESULT(DIRECTMANIPULATION_VIEWPORT_OPTIONS));
86 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
87 SetViewportRect,
88 HRESULT(const RECT*));
89 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
90 SetViewportTransform,
91 HRESULT(const float*, DWORD));
92 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Stop, HRESULT());
93 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
94 SyncDisplayTransform,
95 HRESULT(const float*, DWORD));
96 MOCK_METHOD5_WITH_CALLTYPE(
97 STDMETHODCALLTYPE,
98 ZoomToRect,
99 HRESULT(const float, const float, const float, const float, BOOL));
100
101 private:
102 FML_DISALLOW_COPY_AND_ASSIGN(MockIDirectManipulationViewport);
103 };
104
105 class MockIDirectManipulationContent : public IDirectManipulationContent {
106 public:
107 MockIDirectManipulationContent() {}
108
109 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, AddRef, ULONG());
110 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Release, ULONG());
111 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
112 QueryInterface,
113 HRESULT(REFIID, void**));
114 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, GetContentRect, HRESULT(RECT*));
115 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
116 GetContentTransform,
117 HRESULT(float*, DWORD));
118 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
119 GetOutputTransform,
120 HRESULT(float*, DWORD));
121 MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
122 GetTag,
123 HRESULT(REFIID, void**, UINT32*));
124 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
125 GetViewport,
126 HRESULT(REFIID, void**));
127 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
128 SetContentRect,
129 HRESULT(const RECT*));
130 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
131 SetTag,
132 HRESULT(IUnknown*, UINT32));
133 MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
134 SyncContentTransform,
135 HRESULT(const float*, DWORD));
136
137 private:
138 FML_DISALLOW_COPY_AND_ASSIGN(MockIDirectManipulationContent);
139 };
140
141 TEST(DirectManipulationTest, TestGesture) {
142 MockIDirectManipulationContent content;
143 MockWindowBindingHandlerDelegate delegate;
144 MockIDirectManipulationViewport viewport;
145 const float scale = 1.5;
146 const float pan_x = 32.0;
147 const float pan_y = 16.0;
148 const int DISPLAY_WIDTH = 800;
149 const int DISPLAY_HEIGHT = 600;
150 auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
151 owner->SetBindingHandlerDelegate(&delegate);
152 auto handler =
153 fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
154 int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
155 EXPECT_CALL(viewport, GetPrimaryContent(_, _))
156 .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
157 *out = &content;
158 return S_OK;
159 }))
160 .RetiresOnSaturation();
161 EXPECT_CALL(content, GetContentTransform(_, 6))
162 .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
163 transform[0] = 1.0f;
164 transform[4] = 0.0;
165 transform[5] = 0.0;
166 return S_OK;
167 }))
168 .RetiresOnSaturation();
169 EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
170 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
171 DIRECTMANIPULATION_RUNNING,
172 DIRECTMANIPULATION_READY);
173 EXPECT_CALL(content, GetContentTransform(_, 6))
174 .WillOnce(::testing::Invoke(
175 [scale, pan_x, pan_y](float* transform, DWORD size) {
176 transform[0] = scale;
177 transform[4] = pan_x;
178 transform[5] = pan_y;
179 return S_OK;
180 }));
181 EXPECT_CALL(delegate,
182 OnPointerPanZoomUpdate(device_id, pan_x, pan_y, scale, 0));
183 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
184 (IDirectManipulationContent*)&content);
185 EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
186 EXPECT_CALL(viewport, GetViewportRect(_))
187 .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
188 rect->left = 0;
189 rect->top = 0;
190 rect->right = DISPLAY_WIDTH;
191 rect->bottom = DISPLAY_HEIGHT;
192 return S_OK;
193 }));
194 EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
195 .WillOnce(::testing::Return(S_OK));
196 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
197 DIRECTMANIPULATION_INERTIA,
198 DIRECTMANIPULATION_RUNNING);
199 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
200 DIRECTMANIPULATION_READY,
201 DIRECTMANIPULATION_INERTIA);
202 }
203
204 // Verify that scale mantissa rounding works as expected
205 TEST(DirectManipulationTest, TestRounding) {
206 MockIDirectManipulationContent content;
207 MockWindowBindingHandlerDelegate delegate;
208 MockIDirectManipulationViewport viewport;
209 const float scale = 1.5;
210 const int DISPLAY_WIDTH = 800;
211 const int DISPLAY_HEIGHT = 600;
212 auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
213 owner->SetBindingHandlerDelegate(&delegate);
214 auto handler =
215 fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
216 int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
217 EXPECT_CALL(viewport, GetPrimaryContent(_, _))
218 .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
219 *out = &content;
220 return S_OK;
221 }))
222 .RetiresOnSaturation();
223 EXPECT_CALL(content, GetContentTransform(_, 6))
224 .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
225 transform[0] = 1.0f;
226 transform[4] = 0.0;
227 transform[5] = 0.0;
228 return S_OK;
229 }))
230 .RetiresOnSaturation();
231 EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
232 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
233 DIRECTMANIPULATION_RUNNING,
234 DIRECTMANIPULATION_READY);
235 EXPECT_CALL(content, GetContentTransform(_, 6))
236 .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
237 transform[0] = 1.5000001f;
238 transform[4] = 4.0;
239 transform[5] = 0.0;
240 return S_OK;
241 }))
242 .RetiresOnSaturation();
243 EXPECT_CALL(delegate,
244 OnPointerPanZoomUpdate(device_id, 4.0, 0, 1.5000001f, 0))
245 .Times(0);
246 EXPECT_CALL(delegate, OnPointerPanZoomUpdate(device_id, 4.0, 0, 1.5f, 0))
247 .Times(1)
248 .RetiresOnSaturation();
249 EXPECT_CALL(content, GetContentTransform(_, 6))
250 .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
251 transform[0] = 1.50000065f;
252 transform[4] = 2.0;
253 transform[5] = 0.0;
254 return S_OK;
255 }))
256 .RetiresOnSaturation();
257 EXPECT_CALL(delegate,
258 OnPointerPanZoomUpdate(device_id, 2.0, 0, 1.50000065f, 0))
259 .Times(0);
260 EXPECT_CALL(delegate,
261 OnPointerPanZoomUpdate(device_id, 2.0, 0, 1.50000047f, 0))
262 .Times(1)
263 .RetiresOnSaturation();
264 EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
265 EXPECT_CALL(viewport, GetViewportRect(_))
266 .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
267 rect->left = 0;
268 rect->top = 0;
269 rect->right = DISPLAY_WIDTH;
270 rect->bottom = DISPLAY_HEIGHT;
271 return S_OK;
272 }));
273 EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
274 .WillOnce(::testing::Return(S_OK));
275 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
276 (IDirectManipulationContent*)&content);
277 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
278 (IDirectManipulationContent*)&content);
279 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
280 DIRECTMANIPULATION_INERTIA,
281 DIRECTMANIPULATION_RUNNING);
282 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
283 DIRECTMANIPULATION_READY,
284 DIRECTMANIPULATION_INERTIA);
285 }
286
287 TEST(DirectManipulationTest, TestInertiaCancelSentForUserCancel) {
288 MockIDirectManipulationContent content;
289 MockWindowBindingHandlerDelegate delegate;
290 MockIDirectManipulationViewport viewport;
291 const int DISPLAY_WIDTH = 800;
292 const int DISPLAY_HEIGHT = 600;
293 auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
294 owner->SetBindingHandlerDelegate(&delegate);
295 auto handler =
296 fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
297 int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
298 // No need to mock the actual gesture, just start at the end.
299 EXPECT_CALL(viewport, GetViewportRect(_))
300 .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
301 rect->left = 0;
302 rect->top = 0;
303 rect->right = DISPLAY_WIDTH;
304 rect->bottom = DISPLAY_HEIGHT;
305 return S_OK;
306 }));
307 EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
308 .WillOnce(::testing::Return(S_OK));
309 EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
310 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
311 DIRECTMANIPULATION_INERTIA,
312 DIRECTMANIPULATION_RUNNING);
313 // Have pan_y change by 10 between inertia updates.
314 EXPECT_CALL(content, GetContentTransform(_, 6))
315 .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
316 transform[0] = 1;
317 transform[4] = 0;
318 transform[5] = 100;
319 return S_OK;
320 }));
321 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
322 (IDirectManipulationContent*)&content);
323 EXPECT_CALL(content, GetContentTransform(_, 6))
324 .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
325 transform[0] = 1;
326 transform[4] = 0;
327 transform[5] = 110;
328 return S_OK;
329 }));
330 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
331 (IDirectManipulationContent*)&content);
332 // This looks like an interruption in the middle of synthetic inertia because
333 // of user input.
334 EXPECT_CALL(delegate, OnScrollInertiaCancel(device_id));
335 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
336 DIRECTMANIPULATION_READY,
337 DIRECTMANIPULATION_INERTIA);
338 }
339
340 TEST(DirectManipulationTest, TestInertiaCamcelNotSentAtInertiaEnd) {
341 MockIDirectManipulationContent content;
342 MockWindowBindingHandlerDelegate delegate;
343 MockIDirectManipulationViewport viewport;
344 const int DISPLAY_WIDTH = 800;
345 const int DISPLAY_HEIGHT = 600;
346 auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
347 owner->SetBindingHandlerDelegate(&delegate);
348 auto handler =
349 fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
350 int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
351 // No need to mock the actual gesture, just start at the end.
352 EXPECT_CALL(viewport, GetViewportRect(_))
353 .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
354 rect->left = 0;
355 rect->top = 0;
356 rect->right = DISPLAY_WIDTH;
357 rect->bottom = DISPLAY_HEIGHT;
358 return S_OK;
359 }));
360 EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
361 .WillOnce(::testing::Return(S_OK));
362 EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
363 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
364 DIRECTMANIPULATION_INERTIA,
365 DIRECTMANIPULATION_RUNNING);
366 // Have no change in pan between events.
367 EXPECT_CALL(content, GetContentTransform(_, 6))
368 .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
369 transform[0] = 1;
370 transform[4] = 0;
371 transform[5] = 140;
372 return S_OK;
373 }));
374 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
375 (IDirectManipulationContent*)&content);
376 EXPECT_CALL(content, GetContentTransform(_, 6))
377 .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
378 transform[0] = 1;
379 transform[4] = 0;
380 transform[5] = 140;
381 return S_OK;
382 }));
383 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
384 (IDirectManipulationContent*)&content);
385 // OnScrollInertiaCancel should not be called.
386 EXPECT_CALL(delegate, OnScrollInertiaCancel(device_id)).Times(0);
387 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
388 DIRECTMANIPULATION_READY,
389 DIRECTMANIPULATION_INERTIA);
390 }
391
392 // Have some initial values in the matrix, only the differences should be
393 // reported.
394 TEST(DirectManipulationTest, TestGestureWithInitialData) {
395 MockIDirectManipulationContent content;
396 MockWindowBindingHandlerDelegate delegate;
397 MockIDirectManipulationViewport viewport;
398 const float scale = 1.5;
399 const float pan_x = 32.0;
400 const float pan_y = 16.0;
401 const int DISPLAY_WIDTH = 800;
402 const int DISPLAY_HEIGHT = 600;
403 auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
404 owner->SetBindingHandlerDelegate(&delegate);
405 auto handler =
406 fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
407 int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
408 EXPECT_CALL(viewport, GetPrimaryContent(_, _))
409 .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
410 *out = &content;
411 return S_OK;
412 }))
413 .RetiresOnSaturation();
414 EXPECT_CALL(content, GetContentTransform(_, 6))
415 .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
416 transform[0] = 2.0f;
417 transform[4] = 234.0;
418 transform[5] = 345.0;
419 return S_OK;
420 }))
421 .RetiresOnSaturation();
422 EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
423 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
424 DIRECTMANIPULATION_RUNNING,
425 DIRECTMANIPULATION_READY);
426 EXPECT_CALL(content, GetContentTransform(_, 6))
427 .WillOnce(::testing::Invoke(
428 [scale, pan_x, pan_y](float* transform, DWORD size) {
429 transform[0] = 2.0f * scale;
430 transform[4] = 234.0 + pan_x;
431 transform[5] = 345.0 + pan_y;
432 return S_OK;
433 }));
434 EXPECT_CALL(delegate,
435 OnPointerPanZoomUpdate(device_id, pan_x, pan_y, scale, 0));
436 handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
437 (IDirectManipulationContent*)&content);
438 EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
439 EXPECT_CALL(viewport, GetViewportRect(_))
440 .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
441 rect->left = 0;
442 rect->top = 0;
443 rect->right = DISPLAY_WIDTH;
444 rect->bottom = DISPLAY_HEIGHT;
445 return S_OK;
446 }));
447 EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
448 .WillOnce(::testing::Return(S_OK));
449 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
450 DIRECTMANIPULATION_INERTIA,
451 DIRECTMANIPULATION_RUNNING);
452 handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
453 DIRECTMANIPULATION_READY,
454 DIRECTMANIPULATION_INERTIA);
455 }
456
457 } // namespace testing
458 } // namespace flutter
content
union flutter::testing::@88::KeyboardChange::@0 content
direct_manipulation.h
flutter::testing::MockIDirectManipulationViewport::MockIDirectManipulationViewport
MockIDirectManipulationViewport()
Definition: direct_manipulation_unittests.cc:18
flutter::testing::MockIDirectManipulationViewport::MOCK_METHOD0_WITH_CALLTYPE
MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, AddRef, ULONG())
flutter::testing::MockIDirectManipulationViewport::MOCK_METHOD1_WITH_CALLTYPE
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, ActivateConfiguration, HRESULT(DIRECTMANIPULATION_CONFIGURATION))
flutter::testing::MockIDirectManipulationContent::MOCK_METHOD1_WITH_CALLTYPE
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, GetContentRect, HRESULT(RECT *))
flutter::testing::MockIDirectManipulationContent
Definition: direct_manipulation_unittests.cc:105
flutter::testing::MockIDirectManipulationContent::MOCK_METHOD2_WITH_CALLTYPE
MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, QueryInterface, HRESULT(REFIID, void **))
flutter::testing::MockIDirectManipulationContent::MOCK_METHOD3_WITH_CALLTYPE
MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTag, HRESULT(REFIID, void **, UINT32 *))
flutter::testing::MockIDirectManipulationContent::MockIDirectManipulationContent
MockIDirectManipulationContent()
Definition: direct_manipulation_unittests.cc:107
flutter::testing::MockIDirectManipulationViewport
Definition: direct_manipulation_unittests.cc:16
flutter
Definition: accessibility_bridge_windows.cc:11
flutter::testing::MockIDirectManipulationViewport::MOCK_METHOD2_WITH_CALLTYPE
MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, QueryInterface, HRESULT(REFIID, void **))
flutter::testing::MockIDirectManipulationViewport::MOCK_METHOD3_WITH_CALLTYPE
MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE, AddEventHandler, HRESULT(HWND, IDirectManipulationViewportEventHandler *, DWORD *))
flutter::testing::TEST
TEST(AccessibilityBridgeWindows, GetParent)
Definition: accessibility_bridge_windows_unittests.cc:237
flutter::testing::MockIDirectManipulationViewport::MOCK_METHOD5_WITH_CALLTYPE
MOCK_METHOD5_WITH_CALLTYPE(STDMETHODCALLTYPE, ZoomToRect, HRESULT(const float, const float, const float, const float, BOOL))
flutter::testing::MockIDirectManipulationContent::MOCK_METHOD0_WITH_CALLTYPE
MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, AddRef, ULONG())