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