Track plugin input event latency

content/renderer/pepper/pepper_plugin_instance_impl.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 "content/renderer/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "cc/base/latency_info_swap_promise.h"
 #include "cc/layers/texture_layer.h"
+#include "cc/trees/layer_tree_host.h"
 #include "content/common/content_constants_internal.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/event_conversion.h"
 #include "content/renderer/pepper/fullscreen_container.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_dispatcher_wrapper.h"
@@ skipping 1057 matching lines @@
       // event. This allows out-of-process plugins to respond to the user
       // gesture after processing has finished here.
       if (WebUserGestureIndicator::isProcessingUserGesture()) {
         pending_user_gesture_ =
             ppapi::EventTimeToPPTimeTicks(event.timeStampSeconds);
         pending_user_gesture_token_ =
             WebUserGestureIndicator::currentUserGestureToken();
         pending_user_gesture_token_.setOutOfProcess();
       }
 
+      const ui::LatencyInfo* current_event_latency_info = NULL;
+      if (render_frame_->GetRenderWidget()) {
+        current_event_latency_info =
+            render_frame_->GetRenderWidget()->current_event_latency_info();

[piman, 2014/04/25 01:59:43]

In the future (e.g. after the blink merge), I'm hoping the LatencyInfo can stay
together with the WebInputEvent as it flows through webkit. This is a bit of a
hack for now...

[Yufeng Shen (Slow to review), 2014/04/25 20:42:42]

Right. I always want to couple WebInputEvent with LatencyInfo so we have more
latency coverage along the input path. It's just this requires more plumbing
rework and need a stronger use case to convince the blink reviewer. That's why I
take this hacky solution in this CL. 

+      }
+
       // Each input event may generate more than one PP_InputEvent.
       for (size_t i = 0; i < events.size(); i++) {
+        if (current_event_latency_info) {
+          events[i].latency_info.CopyLatencyFrom(
+              *current_event_latency_info,
+              ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT);
+          events[i].latency_info.CopyLatencyFrom(
+              *current_event_latency_info,
+              ui::INPUT_EVENT_LATENCY_UI_COMPONENT);
+        }
         if (filtered_input_event_mask_ & event_class)
           events[i].is_filtered = true;
         else
           rv = true;  // Unfiltered events are assumed to be handled.
         scoped_refptr<PPB_InputEvent_Shared> event_resource(
             new PPB_InputEvent_Shared(
                 ppapi::OBJECT_IS_IMPL, pp_instance(), events[i]));
 
         rv |= PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
             pp_instance(), event_resource->pp_resource()));
@@ skipping 867 matching lines @@
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!bound_graphics_2d_platform_)
     return false;
   return bound_graphics_2d_platform_->PrepareTextureMailbox(mailbox,
                                                             release_callback);
 }
 
 void PepperPluginInstanceImpl::OnDestruct() { render_frame_ = NULL; }
 
+void PepperPluginInstanceImpl::AddLatencyInfo(
+    const std::vector<ui::LatencyInfo>& latency_info) {
+  if (texture_layer_) {
+    cc::LayerTreeHost* layer_tree_host = texture_layer_->layer_tree_host();

[piman, 2014/04/25 01:59:43]

I'd rather we went to the compositor via the RenderWidget, otherwise this is
racy.
When newly created, the TextureLayer won't be added to the tree until the next
layout, meaning its LTH will be NULL.

Maybe ideally, we'd go through
RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor like
RenderWidget::OnHandleInputEvent

[Yufeng Shen (Slow to review), 2014/04/25 20:42:42]

done.
It now goes through render_frame_->GetRenderWidget()->compositor()

+    if (layer_tree_host) {
+      for (size_t i = 0; i < latency_info.size(); i++) {
+        scoped_ptr<cc::SwapPromise> swap_promise(
+            new cc::LatencyInfoSwapPromise(latency_info[i]));
+        layer_tree_host->QueueSwapPromise(swap_promise.Pass());
+      }
+    }
+  }
+}
+
 void PepperPluginInstanceImpl::AddPluginObject(PluginObject* plugin_object) {
   DCHECK(live_plugin_objects_.find(plugin_object) ==
          live_plugin_objects_.end());
   live_plugin_objects_.insert(plugin_object);
 }
 
 void PepperPluginInstanceImpl::RemovePluginObject(PluginObject* plugin_object) {
   // Don't actually verify that the object is in the set since during module
   // deletion we'll be in the process of freeing them.
   live_plugin_objects_.erase(plugin_object);
@@ skipping 1141 matching lines @@
     // Running out-of-process. Initiate an IPC call to notify the plugin
     // process.
     ppapi::proxy::HostDispatcher* dispatcher =
         ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
     dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
         ppapi::API_ID_PPP_INSTANCE, pp_instance(), pending_host_id, data));
   }
 }
 
 }  // namespace content