1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
|
// Copyright (c) 2012 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 "ppapi/tests/test_input_event.h"
#include "ppapi/c/dev/ppb_testing_dev.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/c/ppb_input_event.h"
#include "ppapi/cpp/input_event.h"
#include "ppapi/cpp/module.h"
#include "ppapi/tests/test_utils.h"
#include "ppapi/tests/testing_instance.h"
REGISTER_TEST_CASE(InputEvent);
namespace {
const uint32_t kSpaceChar = 0x20;
const char* kSpaceString = " ";
#define FINISHED_WAITING_MESSAGE "TEST_INPUT_EVENT_FINISHED_WAITING"
pp::Point GetCenter(const pp::Rect& rect) {
return pp::Point(
rect.x() + rect.width() / 2,
rect.y() + rect.height() / 2);
}
} // namespace
void TestInputEvent::RunTests(const std::string& filter) {
RUN_TEST(Events, filter);
// The AcceptTouchEvent_N tests should not be run when the filter is empty;
// they can only be run one at a time.
// TODO(dmichael): Figure out a way to make these run in the same test fixture
// instance.
if (!ShouldRunAllTests(filter)) {
RUN_TEST(AcceptTouchEvent_1, filter);
RUN_TEST(AcceptTouchEvent_2, filter);
RUN_TEST(AcceptTouchEvent_3, filter);
RUN_TEST(AcceptTouchEvent_4, filter);
}
}
TestInputEvent::TestInputEvent(TestingInstance* instance)
: TestCase(instance),
input_event_interface_(NULL),
mouse_input_event_interface_(NULL),
wheel_input_event_interface_(NULL),
keyboard_input_event_interface_(NULL),
touch_input_event_interface_(NULL),
view_rect_(),
expected_input_event_(0),
received_expected_event_(false),
received_finish_message_(false) {
}
TestInputEvent::~TestInputEvent() {
// Remove the special listener that only responds to a
// FINISHED_WAITING_MESSAGE string. See Init for where it gets added.
std::string js_code;
js_code += "var plugin = document.getElementById('plugin');"
"plugin.removeEventListener('message',"
" plugin.wait_for_messages_handler);"
"delete plugin.wait_for_messages_handler;";
instance_->EvalScript(js_code);
}
bool TestInputEvent::Init() {
input_event_interface_ = static_cast<const PPB_InputEvent*>(
pp::Module::Get()->GetBrowserInterface(PPB_INPUT_EVENT_INTERFACE));
mouse_input_event_interface_ = static_cast<const PPB_MouseInputEvent*>(
pp::Module::Get()->GetBrowserInterface(
PPB_MOUSE_INPUT_EVENT_INTERFACE));
wheel_input_event_interface_ = static_cast<const PPB_WheelInputEvent*>(
pp::Module::Get()->GetBrowserInterface(
PPB_WHEEL_INPUT_EVENT_INTERFACE));
keyboard_input_event_interface_ = static_cast<const PPB_KeyboardInputEvent*>(
pp::Module::Get()->GetBrowserInterface(
PPB_KEYBOARD_INPUT_EVENT_INTERFACE));
touch_input_event_interface_ = static_cast<const PPB_TouchInputEvent*>(
pp::Module::Get()->GetBrowserInterface(
PPB_TOUCH_INPUT_EVENT_INTERFACE));
bool success =
input_event_interface_ &&
mouse_input_event_interface_ &&
wheel_input_event_interface_ &&
keyboard_input_event_interface_ &&
touch_input_event_interface_ &&
CheckTestingInterface();
// Set up a listener for our message that signals that all input events have
// been received.
std::string js_code;
// Note the following code is dependent on some features of test_case.html.
// E.g., it is assumed that the DOM element where the plugin is embedded has
// an id of 'plugin', and there is a function 'IsTestingMessage' that allows
// us to ignore the messages that are intended for use by the testing
// framework itself.
js_code += "var plugin = document.getElementById('plugin');"
"var wait_for_messages_handler = function(message_event) {"
" if (!IsTestingMessage(message_event.data) &&"
" message_event.data === '" FINISHED_WAITING_MESSAGE "') {"
" plugin.postMessage('" FINISHED_WAITING_MESSAGE "');"
" }"
"};"
"plugin.addEventListener('message', wait_for_messages_handler);"
// Stash it on the plugin so we can remove it in the destructor.
"plugin.wait_for_messages_handler = wait_for_messages_handler;";
instance_->EvalScript(js_code);
return success;
}
pp::InputEvent TestInputEvent::CreateMouseEvent(
PP_InputEvent_Type type,
PP_InputEvent_MouseButton buttons) {
return pp::MouseInputEvent(
instance_,
type,
100, // time_stamp
0, // modifiers
buttons,
GetCenter(view_rect_),
1, // click count
pp::Point()); // movement
}
pp::InputEvent TestInputEvent::CreateWheelEvent() {
return pp::WheelInputEvent(
instance_,
100, // time_stamp
0, // modifiers
pp::FloatPoint(1, 2),
pp::FloatPoint(3, 4),
PP_TRUE); // scroll_by_page
}
pp::InputEvent TestInputEvent::CreateKeyEvent(PP_InputEvent_Type type,
uint32_t key_code) {
return pp::KeyboardInputEvent(
instance_,
type,
100, // time_stamp
0, // modifiers
key_code,
pp::Var());
}
pp::InputEvent TestInputEvent::CreateCharEvent(const std::string& text) {
return pp::KeyboardInputEvent(
instance_,
PP_INPUTEVENT_TYPE_CHAR,
100, // time_stamp
0, // modifiers
0, // keycode
pp::Var(text));
}
pp::InputEvent TestInputEvent::CreateTouchEvent(PP_InputEvent_Type type,
const pp::FloatPoint& point) {
PP_TouchPoint touch_point = PP_MakeTouchPoint();
touch_point.position = point;
pp::TouchInputEvent touch_event(instance_, type, 100, 0);
touch_event.AddTouchPoint(PP_TOUCHLIST_TYPE_TOUCHES, touch_point);
touch_event.AddTouchPoint(PP_TOUCHLIST_TYPE_CHANGEDTOUCHES, touch_point);
touch_event.AddTouchPoint(PP_TOUCHLIST_TYPE_TARGETTOUCHES, touch_point);
return touch_event;
}
// Simulates the input event and calls PostMessage to let us know when
// we have received all resulting events from the browser.
bool TestInputEvent::SimulateInputEvent(
const pp::InputEvent& input_event) {
expected_input_event_ = pp::InputEvent(input_event.pp_resource());
received_expected_event_ = false;
received_finish_message_ = false;
testing_interface_->SimulateInputEvent(instance_->pp_instance(),
input_event.pp_resource());
instance_->PostMessage(pp::Var(FINISHED_WAITING_MESSAGE));
testing_interface_->RunMessageLoop(instance_->pp_instance());
return received_finish_message_ && received_expected_event_;
}
bool TestInputEvent::AreEquivalentEvents(PP_Resource received,
PP_Resource expected) {
if (!input_event_interface_->IsInputEvent(received) ||
!input_event_interface_->IsInputEvent(expected)) {
return false;
}
// Test common fields, except modifiers and time stamp, which may be changed
// by the browser.
int32_t received_type = input_event_interface_->GetType(received);
int32_t expected_type = input_event_interface_->GetType(expected);
if (received_type != expected_type) {
// Allow key down events to match "raw" key down events.
if (expected_type != PP_INPUTEVENT_TYPE_KEYDOWN &&
received_type != PP_INPUTEVENT_TYPE_RAWKEYDOWN) {
return false;
}
}
// Test event type-specific fields.
switch (input_event_interface_->GetType(received)) {
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
case PP_INPUTEVENT_TYPE_MOUSEUP:
case PP_INPUTEVENT_TYPE_MOUSEMOVE:
case PP_INPUTEVENT_TYPE_MOUSEENTER:
case PP_INPUTEVENT_TYPE_MOUSELEAVE:
// Check mouse fields, except position and movement, which may be
// modified by the renderer.
return
mouse_input_event_interface_->GetButton(received) ==
mouse_input_event_interface_->GetButton(expected) &&
mouse_input_event_interface_->GetClickCount(received) ==
mouse_input_event_interface_->GetClickCount(expected);
case PP_INPUTEVENT_TYPE_WHEEL:
return
pp::FloatPoint(wheel_input_event_interface_->GetDelta(received)) ==
pp::FloatPoint(wheel_input_event_interface_->GetDelta(expected)) &&
pp::FloatPoint(wheel_input_event_interface_->GetTicks(received)) ==
pp::FloatPoint(wheel_input_event_interface_->GetTicks(expected)) &&
wheel_input_event_interface_->GetScrollByPage(received) ==
wheel_input_event_interface_->GetScrollByPage(expected);
case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
case PP_INPUTEVENT_TYPE_KEYDOWN:
case PP_INPUTEVENT_TYPE_KEYUP:
return
keyboard_input_event_interface_->GetKeyCode(received) ==
keyboard_input_event_interface_->GetKeyCode(expected);
case PP_INPUTEVENT_TYPE_CHAR:
return
keyboard_input_event_interface_->GetKeyCode(received) ==
keyboard_input_event_interface_->GetKeyCode(expected) &&
pp::Var(pp::PASS_REF,
keyboard_input_event_interface_->GetCharacterText(received)) ==
pp::Var(pp::PASS_REF,
keyboard_input_event_interface_->GetCharacterText(expected));
case PP_INPUTEVENT_TYPE_TOUCHSTART:
case PP_INPUTEVENT_TYPE_TOUCHMOVE:
case PP_INPUTEVENT_TYPE_TOUCHEND:
case PP_INPUTEVENT_TYPE_TOUCHCANCEL: {
if (!touch_input_event_interface_->IsTouchInputEvent(received) ||
!touch_input_event_interface_->IsTouchInputEvent(expected))
return false;
uint32_t touch_count = touch_input_event_interface_->GetTouchCount(
received, PP_TOUCHLIST_TYPE_TOUCHES);
if (touch_count <= 0 ||
touch_count != touch_input_event_interface_->GetTouchCount(expected,
PP_TOUCHLIST_TYPE_TOUCHES))
return false;
for (uint32_t i = 0; i < touch_count; ++i) {
PP_TouchPoint expected_point = touch_input_event_interface_->
GetTouchByIndex(expected, PP_TOUCHLIST_TYPE_TOUCHES, i);
PP_TouchPoint received_point = touch_input_event_interface_->
GetTouchByIndex(received, PP_TOUCHLIST_TYPE_TOUCHES, i);
if (expected_point.id != received_point.id ||
expected_point.radius != received_point.radius ||
expected_point.rotation_angle != received_point.rotation_angle ||
expected_point.pressure != received_point.pressure)
return false;
if (expected_point.position.x != received_point.position.x ||
expected_point.position.y != received_point.position.y)
return false;
}
return true;
}
default:
break;
}
return false;
}
bool TestInputEvent::HandleInputEvent(const pp::InputEvent& input_event) {
// Some events may cause extra events to be generated, so look for the
// first one that matches.
if (!received_expected_event_) {
received_expected_event_ = AreEquivalentEvents(
input_event.pp_resource(),
expected_input_event_.pp_resource());
}
// Handle all input events.
return true;
}
void TestInputEvent::HandleMessage(const pp::Var& message_data) {
if (message_data.is_string() &&
(message_data.AsString() == FINISHED_WAITING_MESSAGE)) {
testing_interface_->QuitMessageLoop(instance_->pp_instance());
received_finish_message_ = true;
}
}
void TestInputEvent::DidChangeView(const pp::View& view) {
view_rect_ = view.GetRect();
}
std::string TestInputEvent::TestEvents() {
// Request all input event classes.
input_event_interface_->RequestInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_MOUSE |
PP_INPUTEVENT_CLASS_WHEEL |
PP_INPUTEVENT_CLASS_KEYBOARD |
PP_INPUTEVENT_CLASS_TOUCH);
// Send the events and check that we received them.
ASSERT_TRUE(
SimulateInputEvent(CreateMouseEvent(PP_INPUTEVENT_TYPE_MOUSEDOWN,
PP_INPUTEVENT_MOUSEBUTTON_LEFT)));
ASSERT_TRUE(
SimulateInputEvent(CreateWheelEvent()));
ASSERT_TRUE(
SimulateInputEvent(CreateKeyEvent(PP_INPUTEVENT_TYPE_KEYDOWN,
kSpaceChar)));
ASSERT_TRUE(
SimulateInputEvent(CreateCharEvent(kSpaceString)));
ASSERT_TRUE(SimulateInputEvent(CreateTouchEvent(PP_INPUTEVENT_TYPE_TOUCHSTART,
pp::FloatPoint(12, 23))));
// Request only mouse events.
input_event_interface_->ClearInputEventRequest(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_WHEEL |
PP_INPUTEVENT_CLASS_KEYBOARD);
// Check that we only receive mouse events.
ASSERT_TRUE(
SimulateInputEvent(CreateMouseEvent(PP_INPUTEVENT_TYPE_MOUSEDOWN,
PP_INPUTEVENT_MOUSEBUTTON_LEFT)));
ASSERT_FALSE(
SimulateInputEvent(CreateWheelEvent()));
ASSERT_FALSE(
SimulateInputEvent(CreateKeyEvent(PP_INPUTEVENT_TYPE_KEYDOWN,
kSpaceChar)));
ASSERT_FALSE(
SimulateInputEvent(CreateCharEvent(kSpaceString)));
PASS();
}
std::string TestInputEvent::TestAcceptTouchEvent_1() {
// The browser normally sends touch-events to the renderer only if the page
// has touch-event handlers. Since test-case.html does not have any
// touch-event handler, it would normally not receive any touch events from
// the browser. However, if a plugin in the page does accept touch events,
// then the browser should start sending touch-events to the page. In this
// test, the plugin simply registers for touch-events. The real test is to
// verify that the browser knows to send touch-events to the renderer.
// If the plugin is removed from the page, then there are no more touch-event
// handlers in the page, and browser stops sending touch-events. So to make
// it possible to test this properly, the plugin is not removed from the page
// at the end of the test.
instance_->set_remove_plugin(false);
input_event_interface_->RequestInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_MOUSE |
PP_INPUTEVENT_CLASS_WHEEL |
PP_INPUTEVENT_CLASS_KEYBOARD |
PP_INPUTEVENT_CLASS_TOUCH);
PASS();
}
std::string TestInputEvent::TestAcceptTouchEvent_2() {
// See comment in TestAcceptTouchEvent_1.
instance_->set_remove_plugin(false);
input_event_interface_->RequestInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_MOUSE |
PP_INPUTEVENT_CLASS_WHEEL |
PP_INPUTEVENT_CLASS_KEYBOARD |
PP_INPUTEVENT_CLASS_TOUCH);
input_event_interface_->ClearInputEventRequest(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_TOUCH);
PASS();
}
std::string TestInputEvent::TestAcceptTouchEvent_3() {
// See comment in TestAcceptTouchEvent_1.
instance_->set_remove_plugin(false);
input_event_interface_->RequestInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_MOUSE |
PP_INPUTEVENT_CLASS_WHEEL |
PP_INPUTEVENT_CLASS_KEYBOARD);
input_event_interface_->RequestFilteringInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_TOUCH);
PASS();
}
std::string TestInputEvent::TestAcceptTouchEvent_4() {
// See comment in TestAcceptTouchEvent_1.
instance_->set_remove_plugin(false);
input_event_interface_->RequestInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_MOUSE |
PP_INPUTEVENT_CLASS_WHEEL |
PP_INPUTEVENT_CLASS_KEYBOARD);
input_event_interface_->RequestInputEvents(instance_->pp_instance(),
PP_INPUTEVENT_CLASS_TOUCH);
PASS();
}
|