ppapi/tests/test_input_event.cc

   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
  14 REGISTER_TEST_CASE(InputEvent);
  15
  16 namespace {
  17
  18 const uint32_t kSpaceChar = 0x20;
  19 const char* kSpaceString = " ";
  20 const char* kSpaceCode = "Space";
  21
  22 #define FINISHED_WAITING_MESSAGE "TEST_INPUT_EVENT_FINISHED_WAITING"
  23
  24 pp::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
  32 void 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
  48 TestInputEvent::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
  64 TestInputEvent::~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
  75 bool 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
 125 pp::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
 139 pp::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
 149 pp::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
 162 pp::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
 173 pp::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
 186 void 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.
 195 bool 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
 205 bool 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
 305 bool 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
 321 void 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
 330 void TestInputEvent::DidChangeView(const pp::View& view) {
 331   view_rect_ = view.GetRect();
 332 }
 333
 334 std::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
 356 std::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
 399 std::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
 420 std::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
 433 std::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
 445 std::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 }