Track plugin input event latency

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/pp_errors.h"
 #include "ppapi/c/ppb_input_event.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/module.h"
@@ skipping 13 matching lines @@
 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);
+  RUN_TEST(EventsLatencyTracking, 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),
       nested_event_(instance->pp_instance()),
       view_rect_(),
       expected_input_event_(0),
       received_expected_event_(false),
-      received_finish_message_(false) {
+      received_finish_message_(false),
+      enable_latency_tracking_(false),
+      last_latency_tracking_successful_(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));
+  input_event_private_interface_ = static_cast<const PPB_InputEvent_Private*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_INPUTEVENT_PRIVATE_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_ &&
+      input_event_private_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.
@@ skipping 198 matching lines @@
 
 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.
+  if (enable_latency_tracking_) {
+    pp::InputEventPrivate private_event(input_event);
+    last_latency_tracking_successful_ = private_event.TraceInputLatency(true);
+  }
   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;
     nested_event_.Signal();
   }
 }
 
 void TestInputEvent::DidChangeView(const pp::View& view) {
   view_rect_ = view.GetRect();
 }
 
+std::string TestInputEvent::TestEventsLatencyTracking() {
+  enable_latency_tracking_ = true;
+  input_event_interface_->RequestInputEvents(instance_->pp_instance(),
+                                             PP_INPUTEVENT_CLASS_TOUCH);
+  PostMessageBarrier();
+
+  ASSERT_TRUE(SimulateInputEvent(CreateTouchEvent(PP_INPUTEVENT_TYPE_TOUCHSTART,
+                                                  pp::FloatPoint(12, 23))));
+  // Without calling StartTrackingLatency() first, TraceInputLatency() won't
+  // take effect and will return false;
+  ASSERT_FALSE(last_latency_tracking_successful_);
+
+  input_event_private_interface_->StartTrackingLatency(
+      instance_->pp_instance());
+
+  ASSERT_TRUE(SimulateInputEvent(CreateTouchEvent(PP_INPUTEVENT_TYPE_TOUCHSTART,
+                                                  pp::FloatPoint(12, 23))));
+  ASSERT_TRUE(last_latency_tracking_successful_);
+
+  PASS();
+}
+
 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);
   PostMessageBarrier();
 
   // Send the events and check that we received them.
@@ skipping 80 matching lines @@
   // 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();
 }