ppapi: Make sure the touch-event interface is detected correctly.

ppapi/tests/test_input_event.cc

 // 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"
@@ skipping 36 matching lines @@
 
 #undef RUN_TEST_EXACT_MATCH
 }
 
 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.
@@ skipping 50 matching lines @@
 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;
+  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));
@@ skipping 53 matching lines @@
 
     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;
+
+        // The expected position is in the page coordinate system, and the
+        // received event is in the plugins coordinate system.
+        if (expected_point.position.x != received_point.position.x +
+            view_rect_.x() ||
+            expected_point.position.y != received_point.position.y +
+            view_rect_.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.
@@ skipping 45 matching lines @@
       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)));
 
+#if !defined(PPAPI_OS_WIN)

[sadrul, 2012/08/28 19:18:40]

The test passes on debug builds, but fails on release builds. So I have disabled
this test on windows. I filed a bug for this and assigned to girard@ who has
worked on touch-events on windows.

+  // This fails on windows. See http://crbug.com/145236
+  // Request touch events.
+  input_event_interface_->RequestInputEvents(instance_->pp_instance(),
+                                             PP_INPUTEVENT_CLASS_TOUCH);
+  ASSERT_TRUE(SimulateInputEvent(CreateTouchEvent(PP_INPUTEVENT_TYPE_TOUCHSTART,
+                                                  pp::FloatPoint(12, 23))));
+#endif
   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
@@ skipping 41 matching lines @@
   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();
 }