Add touch drag UMA latency metric.

content/browser/renderer_host/input/input_router_impl.cc

 // Copyright 2013 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/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 126 matching lines @@
     const NativeWebKeyboardEventWithLatencyInfo& key_event) {
   // Put all WebKeyboardEvent objects in a queue since we can't trust the
   // renderer and we need to give something to the HandleKeyboardEvent
   // handler.
   key_queue_.push_back(key_event);
   LOCAL_HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
   gesture_event_queue_.FlingHasBeenHalted();
 
   // Only forward the non-native portions of our event.
-  FilterAndSendWebInputEvent(key_event.event, key_event.latency);
+  FilterAndSendWebInputEvent(key_event.event, &key_event.latency);
 }
 
 void InputRouterImpl::SendGestureEvent(
     const GestureEventWithLatencyInfo& original_gesture_event) {
   input_stream_validator_.Validate(original_gesture_event.event);
 
   GestureEventWithLatencyInfo gesture_event(original_gesture_event);
 
   if (touch_action_filter_.FilterGestureEvent(&gesture_event.event))
     return;
@@ skipping 25 matching lines @@
       if (!next_mouse_move_)
         next_mouse_move_.reset(new MouseEventWithLatencyInfo(mouse_event));
       else
         next_mouse_move_->CoalesceWith(mouse_event);
       return;
     }
     mouse_move_pending_ = true;
     current_mouse_move_ = mouse_event;
   }
 
-  FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency);
+  FilterAndSendWebInputEvent(mouse_event.event, &mouse_event.latency);
 }
 
 void InputRouterImpl::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
   if (WebTouchEventTraits::IsTouchSequenceStart(touch_event.event)) {
     touch_action_filter_.ResetTouchAction();
     // Note that if the previous touch-action was TOUCH_ACTION_NONE, enabling
     // the timeout here will not take effect until the *following* touch
     // sequence.  This is a desirable side-effect, giving the renderer a chance
     // to send a touch-action response without racing against the ack timeout.
     UpdateTouchAckTimeoutEnabled();
   }
 
-  FilterAndSendWebInputEvent(touch_event.event, touch_event.latency);
+  FilterAndSendWebInputEvent(touch_event.event, &touch_event.latency);
 }
 
 void InputRouterImpl::SendGestureEventImmediately(
     const GestureEventWithLatencyInfo& gesture_event) {
-  FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency);
+  FilterAndSendWebInputEvent(gesture_event.event, &gesture_event.latency);
 }
 
 const NativeWebKeyboardEvent* InputRouterImpl::GetLastKeyboardEvent() const {
   if (key_queue_.empty())
     return NULL;
   return &key_queue_.front().event;
 }
 
 void InputRouterImpl::NotifySiteIsMobileOptimized(bool is_mobile_optimized) {
   touch_event_queue_.SetIsMobileOptimizedSite(is_mobile_optimized);
@@ skipping 61 matching lines @@
 
 void InputRouterImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   touch_event_queue_.OnGestureEventAck(event, ack_result);
   ack_handler_->OnGestureEventAck(event, ack_result);
 }
 
 void InputRouterImpl::SendMouseWheelEventImmediately(
     const MouseWheelEventWithLatencyInfo& wheel_event) {
-  FilterAndSendWebInputEvent(wheel_event.event, wheel_event.latency);
+  FilterAndSendWebInputEvent(wheel_event.event, &wheel_event.latency);
 }
 
 void InputRouterImpl::OnMouseWheelEventAck(
     const MouseWheelEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   ack_handler_->OnWheelEventAck(event, ack_result);
 }
 
 bool InputRouterImpl::SendSelectMessage(
     scoped_ptr<IPC::Message> message) {
@@ skipping 27 matching lines @@
   move_caret_pending_ = true;
   return Send(message.release());
 }
 
 bool InputRouterImpl::Send(IPC::Message* message) {
   return sender_->Send(message);
 }
 
 void InputRouterImpl::FilterAndSendWebInputEvent(
     const WebInputEvent& input_event,
-    const ui::LatencyInfo& latency_info) {
+    ui::LatencyInfo* latency_info) {
   TRACE_EVENT1("input",
                "InputRouterImpl::FilterAndSendWebInputEvent",
                "type",
                WebInputEventTraits::GetName(input_event.type));
   TRACE_EVENT_WITH_FLOW2("input,benchmark,devtools.timeline",
                          "LatencyInfo.Flow",
-                         TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
+                         TRACE_ID_DONT_MANGLE(latency_info->trace_id()),
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "SendInputEventUI",
                          "frameTreeNodeId", frame_tree_node_id_);
 
   // Any input event cancels a pending mouse move event.
   next_mouse_move_.reset();
 
   OfferToHandlers(input_event, latency_info);
 }
 
 void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
-                                      const ui::LatencyInfo& latency_info) {
+                                      ui::LatencyInfo* latency_info) {
   output_stream_validator_.Validate(input_event);
 
-  if (OfferToClient(input_event, latency_info))
+  if (OfferToClient(input_event, *latency_info))
     return;
 
   // Touch events should always indicate in the event whether they are
   // cancelable (respect ACK disposition) or not except touchmove.
   bool should_block = WebInputEventTraits::ShouldBlockEventStream(input_event);
 
-  OfferToRenderer(input_event, latency_info,
+  OfferToRenderer(input_event,
                   should_block
                       ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
-                      : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING);
+                      : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+                  latency_info);
 
   if (WebInputEvent::isTouchEventType(input_event.type) &&
       input_event.type != WebInputEvent::TouchMove) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
     DCHECK_EQ(should_block, touch.cancelable);
   }
 
   // Generate a synthetic ack if the event was sent so it doesn't block.
   if (!should_block) {
     ProcessInputEventAck(
-        input_event.type, INPUT_EVENT_ACK_STATE_IGNORED, latency_info,
+        input_event.type, INPUT_EVENT_ACK_STATE_IGNORED, *latency_info,
         WebInputEventTraits::GetUniqueTouchEventId(input_event),
         IGNORING_DISPOSITION);
   }
 }
 
 bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
                                     const ui::LatencyInfo& latency_info) {
   bool consumed = false;
 
   InputEventAckState filter_ack =
@@ skipping 14 matching lines @@
       consumed = true;
       break;
     default:
       break;
   }
 
   return consumed;
 }
 
 bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
-                                      const ui::LatencyInfo& latency_info,
-                                      InputEventDispatchType dispatch_type) {
+                                      InputEventDispatchType dispatch_type,
+                                      ui::LatencyInfo* latency_info) {
   // This conversion is temporary. WebInputEvent should be generated
   // directly from ui::Event with the viewport coordinates. See
   // crbug.com/563730.
   scoped_ptr<blink::WebInputEvent> event_in_viewport =
       ui::ScaleWebInputEvent(input_event, device_scale_factor_);
   const WebInputEvent* event_to_send =
       event_in_viewport ? event_in_viewport.get() : &input_event;
 
+  client_->OnForwardEventToRenderer(input_event, latency_info);
   if (Send(new InputMsg_HandleInputEvent(routing_id(), event_to_send,
-                                         latency_info, dispatch_type))) {
+                                         *latency_info, dispatch_type))) {
     // Ack messages for ignored ack event types should never be sent by the
     // renderer. Consequently, such event types should not affect event time
     // or in-flight event count metrics.
     if (dispatch_type == InputEventDispatchType::DISPATCH_TYPE_BLOCKING) {
       input_event_start_time_ = TimeTicks::Now();
       client_->IncrementInFlightEventCount();
     }
     return true;
   }
   return false;
@@ skipping 196 matching lines @@
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
 void InputRouterImpl::SetFrameTreeNodeId(int frameTreeNodeId) {
   frame_tree_node_id_ = frameTreeNodeId;
 }
 
 }  // namespace content