Track plugin input event latency

ppapi/shared_impl/ppb_input_event_shared.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/shared_impl/ppb_input_event_shared.h"
 
+#include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var.h"
 
 using ppapi::thunk::PPB_InputEvent_API;
 
 namespace ppapi {
 
 InputEventData::InputEventData()
     : is_filtered(false),
       event_type(PP_INPUTEVENT_TYPE_UNDEFINED),
       event_time_stamp(0.0),
@@ skipping 167 matching lines @@
     default:
       return PP_MakeTouchPoint();
   }
   for (size_t i = 0; i < points->size(); i++) {
     if (points->at(i).id == id)
       return points->at(i);
   }
   return PP_MakeTouchPoint();
 }
 
+PP_Bool PPB_InputEvent_Shared::TraceInputLatency(PP_Bool has_damage) {
+  ui::LatencyInfo latency = data_.latency_info;
+  if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_PLUGIN_COMPONENT,
+                           0, NULL))

[dmichael (off chromium), 2014/05/08 21:47:07]

So the call to TraceInputLatency is coming from the plugin process. But the
renderer is where the LatencyInfo is made for the time the input event gets
created.

Does this ui::LatencyInfo automagically work across processes like this? It's a
bit magical looking to me.

[Yufeng Shen (Slow to review), 2014/05/08 23:49:40]

hmm, not sure what confuses you. The LatencyInfo is added to
InputEventData  as a data member. The input event and the LatencyInfo are
created in renderer and at that time we saved some components in it (e.g. this
BEGIN_PLUGIN_COMPONENT). Then the input event/LatencyInfo get passed/copied into
plugin process through IPC. Now if we call
TraceInputLatency(true) on it, we cached the LatencyInfo and later on send it
back to renderer through IPC.

 

[dmichael (off chromium), 2014/05/09 15:19:33]

OK, got it. I was forgetting about it riding along as a data member when the
input event gets sent.

+    return PP_FALSE;
+  if (has_damage) {
+    PpapiGlobals::Get()->AddLatencyInfo(latency, pp_instance());
+  } else {
+    latency.AddLatencyNumber(
+        ui::INPUT_EVENT_LATENCY_TERMINATED_PLUGIN_COMPONENT, 0, 0);
+  }
+  return PP_TRUE;
+}
+
 // static
 PP_Resource PPB_InputEvent_Shared::CreateIMEInputEvent(
     ResourceObjectType type,
     PP_Instance instance,
     PP_InputEvent_Type event_type,
     PP_TimeTicks time_stamp,
     struct PP_Var text,
     uint32_t segment_number,
     const uint32_t* segment_offsets,
     int32_t target_segment,
@@ skipping 126 matching lines @@
     return 0;
 
   InputEventData data;
   data.event_type = event_type;
   data.event_time_stamp = time_stamp;
   data.event_modifiers = modifiers;
   return (new PPB_InputEvent_Shared(type, instance, data))->GetReference();
 }
 
 }  // namespace ppapi