Factor out latency tracking from RenderWidgetHostImpl

content/browser/renderer_host/render_widget_host_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/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 165 matching lines @@
       in_get_backing_store_(false),
       ignore_input_events_(false),
       input_method_active_(false),
       text_direction_updated_(false),
       text_direction_(blink::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
-      last_input_number_(static_cast<int64>(GetProcess()->GetID()) << 32),
       subscribe_uniform_enabled_(false),
       next_browser_snapshot_id_(1),
       weak_factory_(this) {
   CHECK(delegate_);
   if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
     surface_id_ = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
         process_->GetID(),
         routing_id_);
   } else {
@@ skipping 14 matching lines @@
       g_routing_id_widget_map.Get().insert(std::make_pair(
           RenderWidgetHostID(process->GetID(), routing_id_), this));
   CHECK(result.second) << "Inserting a duplicate item!";
   process_->AddRoute(routing_id_, this);
 
   // If we're initially visible, tell the process host that we're alive.
   // Otherwise we'll notify the process host when we are first shown.
   if (!hidden)
     process_->WidgetRestored();
 
+  latency_tracker_.Initialize(routing_id_, GetProcess()->GetID());
+
   input_router_.reset(new InputRouterImpl(
       process_, this, this, routing_id_, GetInputRouterConfigForPlatform()));
 
   touch_emulator_.reset();
 
   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
       IsRenderView() ? RenderViewHost::From(this) : NULL);
   if (BrowserPluginGuest::IsGuest(rvh) ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
@@ skipping 647 matching lines @@
 
 void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
   ForwardMouseEventWithLatencyInfo(mouse_event, ui::LatencyInfo());
 }
 
 void RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo(
       const blink::WebMouseEvent& mouse_event,
       const ui::LatencyInfo& ui_latency) {
   TRACE_EVENT2("input", "RenderWidgetHostImpl::ForwardMouseEvent",
                "x", mouse_event.x, "y", mouse_event.y);
-  ui::LatencyInfo::InputCoordinate logical_coordinate(mouse_event.x,
-                                                      mouse_event.y);
-
-  ui::LatencyInfo latency_info = CreateInputEventLatencyInfoIfNotExist(
-      &ui_latency, mouse_event.type, &logical_coordinate, 1);
 
   for (size_t i = 0; i < mouse_event_callbacks_.size(); ++i) {
     if (mouse_event_callbacks_[i].Run(mouse_event))
       return;
   }
 
   if (IgnoreInputEvents())
     return;
 
   if (touch_emulator_ && touch_emulator_->HandleMouseEvent(mouse_event))
     return;
 
-  input_router_->SendMouseEvent(MouseEventWithLatencyInfo(mouse_event,
-                                                          latency_info));
+  MouseEventWithLatencyInfo mouse_with_latency(mouse_event, ui_latency);
+  latency_tracker_.OnInputEvent(mouse_event, &mouse_with_latency.latency);
+  input_router_->SendMouseEvent(mouse_with_latency);
 
   // Pass mouse state to gpu service if the subscribe uniform
   // extension is enabled.
   // TODO(orglofch): Only pass mouse information if one of the GL Contexts
   // is subscribed to GL_MOUSE_POSITION_CHROMIUM
   if (subscribe_uniform_enabled_) {
     gpu::ValueState state;
     state.int_value[0] = mouse_event.x;
     state.int_value[1] = mouse_event.y;
     GpuProcessHost::SendOnIO(
@@ skipping 10 matching lines @@
 void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   ForwardWheelEventWithLatencyInfo(wheel_event, ui::LatencyInfo());
 }
 
 void RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo(
       const blink::WebMouseWheelEvent& wheel_event,
       const ui::LatencyInfo& ui_latency) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardWheelEvent");
 
-  ui::LatencyInfo::InputCoordinate logical_coordinate(wheel_event.x,
-                                                      wheel_event.y);
-
-  ui::LatencyInfo latency_info = CreateInputEventLatencyInfoIfNotExist(
-      &ui_latency, wheel_event.type, &logical_coordinate, 1);
-
   if (IgnoreInputEvents())
     return;
 
   if (touch_emulator_ && touch_emulator_->HandleMouseWheelEvent(wheel_event))
     return;
 
-  input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(wheel_event,
-                                                               latency_info));
+  MouseWheelEventWithLatencyInfo wheel_with_latency(wheel_event, ui_latency);
+  latency_tracker_.OnInputEvent(wheel_event, &wheel_with_latency.latency);
+  input_router_->SendWheelEvent(wheel_with_latency);
 }
 
 void RenderWidgetHostImpl::ForwardGestureEvent(
     const blink::WebGestureEvent& gesture_event) {
   ForwardGestureEventWithLatencyInfo(gesture_event, ui::LatencyInfo());
 }
 
 void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo(
     const blink::WebGestureEvent& gesture_event,
     const ui::LatencyInfo& ui_latency) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardGestureEvent");
   // Early out if necessary, prior to performing latency logic.
   if (IgnoreInputEvents())
     return;
 
   if (delegate_->PreHandleGestureEvent(gesture_event))
     return;
 
-  ui::LatencyInfo::InputCoordinate logical_coordinate(gesture_event.x,
-                                                      gesture_event.y);
-
-  ui::LatencyInfo latency_info = CreateInputEventLatencyInfoIfNotExist(
-      &ui_latency, gesture_event.type, &logical_coordinate, 1);
-
-  if (gesture_event.type == blink::WebInputEvent::GestureScrollUpdate) {
-    latency_info.AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT,
-        GetLatencyComponentId(),
-        ++last_input_number_);
-
-    // Make a copy of the INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT with a
-    // different name INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT.
-    // So we can track the latency specifically for scroll update events.
-    ui::LatencyInfo::LatencyComponent original_component;
-    if (latency_info.FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
-                                 0,
-                                 &original_component)) {
-      latency_info.AddLatencyNumberWithTimestamp(
-          ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
-          GetLatencyComponentId(),
-          original_component.sequence_number,
-          original_component.event_time,
-          original_component.event_count);
-    }
-  }
-
-  GestureEventWithLatencyInfo gesture_with_latency(gesture_event, latency_info);
+  GestureEventWithLatencyInfo gesture_with_latency(gesture_event, ui_latency);
+  latency_tracker_.OnInputEvent(gesture_event, &gesture_with_latency.latency);
   input_router_->SendGestureEvent(gesture_with_latency);
 }
 
 void RenderWidgetHostImpl::ForwardEmulatedTouchEvent(
       const blink::WebTouchEvent& touch_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardEmulatedTouchEvent");
 
-  ui::LatencyInfo::InputCoordinate
-      logical_coordinates[ui::LatencyInfo::kMaxInputCoordinates];
-  size_t logical_coordinates_size =
-      std::min(arraysize(logical_coordinates),
-               static_cast<size_t>(touch_event.touchesLength));
-  for (size_t i = 0; i < logical_coordinates_size; i++) {
-    logical_coordinates[i] = ui::LatencyInfo::InputCoordinate(
-        touch_event.touches[i].position.x, touch_event.touches[i].position.y);
-  }
-
-  ui::LatencyInfo latency_info = CreateInputEventLatencyInfoIfNotExist(
-      NULL, touch_event.type, logical_coordinates, logical_coordinates_size);
-  TouchEventWithLatencyInfo touch_with_latency(touch_event, latency_info);
+  TouchEventWithLatencyInfo touch_with_latency(touch_event);
+  latency_tracker_.OnInputEvent(touch_event, &touch_with_latency.latency);
   input_router_->SendTouchEvent(touch_with_latency);
 }
 
 void RenderWidgetHostImpl::ForwardTouchEventWithLatencyInfo(
       const blink::WebTouchEvent& touch_event,
       const ui::LatencyInfo& ui_latency) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardTouchEvent");
 
   // Always forward TouchEvents for touch stream consistency. They will be
   // ignored if appropriate in FilterInputEvent().
 
-  ui::LatencyInfo::InputCoordinate
-      logical_coordinates[ui::LatencyInfo::kMaxInputCoordinates];
-  size_t logical_coordinates_size =
-      std::min(arraysize(logical_coordinates),
-               static_cast<size_t>(touch_event.touchesLength));
-  for (size_t i = 0; i < logical_coordinates_size; i++) {
-    logical_coordinates[i] = ui::LatencyInfo::InputCoordinate(
-        touch_event.touches[i].position.x, touch_event.touches[i].position.y);
-  }
-
-  ui::LatencyInfo latency_info = CreateInputEventLatencyInfoIfNotExist(
-      &ui_latency,
-      touch_event.type,
-      logical_coordinates,
-      logical_coordinates_size);
-  TouchEventWithLatencyInfo touch_with_latency(touch_event, latency_info);
-
+  TouchEventWithLatencyInfo touch_with_latency(touch_event, ui_latency);
   if (touch_emulator_ &&
       touch_emulator_->HandleTouchEvent(touch_with_latency.event)) {
     if (view_) {
       view_->ProcessAckedTouchEvent(
           touch_with_latency, INPUT_EVENT_ACK_STATE_CONSUMED);
     }
     return;
   }
 
+  latency_tracker_.OnInputEvent(touch_event, &touch_with_latency.latency);
   input_router_->SendTouchEvent(touch_with_latency);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (IgnoreInputEvents())
     return;
 
   if (!process_->HasConnection())
@@ skipping 47 matching lines @@
     if (delegate_->PreHandleKeyboardEvent(key_event, &is_shortcut))
       return;
 
     if (key_event.type == WebKeyboardEvent::RawKeyDown)
       suppress_next_char_events_ = false;
   }
 
   if (touch_emulator_ && touch_emulator_->HandleKeyboardEvent(key_event))
     return;
 
-  input_router_->SendKeyboardEvent(
-      key_event,
-      CreateInputEventLatencyInfoIfNotExist(NULL, key_event.type, NULL, 0),
-      is_shortcut);
+  ui::LatencyInfo latency;
+  latency_tracker_.OnInputEvent(key_event, &latency);
+  input_router_->SendKeyboardEvent(key_event, latency, is_shortcut);
 }
 
 void RenderWidgetHostImpl::QueueSyntheticGesture(
     scoped_ptr<SyntheticGesture> synthetic_gesture,
     const base::Callback<void(SyntheticGesture::Result)>& on_complete) {
   if (!synthetic_gesture_controller_ && view_) {
     synthetic_gesture_controller_.reset(
         new SyntheticGestureController(
             view_->CreateSyntheticGestureTarget().Pass()));
   }
@@ skipping 12 matching lines @@
 void RenderWidgetHostImpl::ShowContextMenuAtPoint(const gfx::Point& point) {
   Send(new ViewMsg_ShowContextMenu(
       GetRoutingID(), ui::MENU_SOURCE_MOUSE, point));
 }
 
 void RenderWidgetHostImpl::SendCursorVisibilityState(bool is_visible) {
   Send(new InputMsg_CursorVisibilityChange(GetRoutingID(), is_visible));
 }
 
 int64 RenderWidgetHostImpl::GetLatencyComponentId() const {
-  return GetRoutingID() | (static_cast<int64>(GetProcess()->GetID()) << 32);
+  return latency_tracker_.latency_component_id();
 }
 
 // static
 void RenderWidgetHostImpl::DisableResizeAckCheckForTesting() {
   g_check_for_pending_resize_ack = false;
 }
 
-ui::LatencyInfo RenderWidgetHostImpl::CreateInputEventLatencyInfoIfNotExist(
-    const ui::LatencyInfo* original,
-    WebInputEvent::Type type,
-    const ui::LatencyInfo::InputCoordinate* logical_coordinates,
-    size_t logical_coordinates_size) {
-  ui::LatencyInfo info;
-  if (original)
-    info = *original;
-  // In Aura, gesture event will already carry its original touch event's
-  // INPUT_EVENT_LATENCY_RWH_COMPONENT.
-  if (!info.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
-                        GetLatencyComponentId(),
-                        NULL)) {
-    info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
-                          GetLatencyComponentId(),
-                          ++last_input_number_);
-    info.TraceEventType(WebInputEventTraits::GetName(type));
-
-    // Convert logical coordinates to physical coordinates, based on the
-    // device scale factor.
-    float device_scale_factor =
-        screen_info_ ? screen_info_->deviceScaleFactor : 1;
-    DCHECK(logical_coordinates_size <= ui::LatencyInfo::kMaxInputCoordinates);
-    info.input_coordinates_size = logical_coordinates_size;
-    for (size_t i = 0; i < info.input_coordinates_size; i++) {
-      info.input_coordinates[i].x =
-          logical_coordinates[i].x * device_scale_factor;
-      info.input_coordinates[i].y =
-          logical_coordinates[i].y * device_scale_factor;
-    }
-  }
-
-  return info;
-}
-
-
 void RenderWidgetHostImpl::AddKeyPressEventCallback(
     const KeyPressEventCallback& callback) {
   key_press_event_callbacks_.push_back(callback);
 }
 
 void RenderWidgetHostImpl::RemoveKeyPressEventCallback(
     const KeyPressEventCallback& callback) {
   for (size_t i = 0; i < key_press_event_callbacks_.size(); ++i) {
     if (key_press_event_callbacks_[i].Equals(callback)) {
       key_press_event_callbacks_.erase(
@@ skipping 17 matching lines @@
     }
   }
 }
 
 void RenderWidgetHostImpl::GetWebScreenInfo(blink::WebScreenInfo* result) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::GetWebScreenInfo");
   if (view_)
     view_->GetScreenInfo(result);
   else
     RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
+  latency_tracker_.set_device_scale_factor(result->deviceScaleFactor);
   screen_info_out_of_date_ = false;
 }
 
 const NativeWebKeyboardEvent*
     RenderWidgetHostImpl::GetLastKeyboardEvent() const {
   return input_router_->GetLastKeyboardEvent();
 }
 
 void RenderWidgetHostImpl::NotifyScreenInfoChanged() {
   // The resize message (which may not happen immediately) will carry with it
@@ skipping 285 matching lines @@
                TRACE_DISABLED_BY_DEFAULT("OnSwapCompositorFrame"));
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return false;
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   uint32 output_surface_id = param.a;
   param.b.AssignTo(frame.get());
   std::vector<IPC::Message> messages_to_deliver_with_frame;
   messages_to_deliver_with_frame.swap(param.c);
 
-  for (size_t i = 0; i < frame->metadata.latency_info.size(); i++)
-    AddLatencyInfoComponentIds(&frame->metadata.latency_info[i]);
+  latency_tracker_.OnSwapCompositorFrame(&frame->metadata.latency_info);
 
   input_router_->OnViewUpdated(
       GetInputRouterViewFlagsFromCompositorFrameMetadata(frame->metadata));
 
   if (view_) {
     view_->OnSwapCompositorFrame(output_surface_id, frame.Pass());
     view_->DidReceiveRendererFrame();
   } else {
     cc::CompositorFrameAck ack;
     if (frame->gl_frame_data) {
@@ skipping 371 matching lines @@
 
     // WARNING: This RenderWidgetHostImpl can be deallocated at this point
     // (i.e.  in the case of Ctrl+W, where the call to
     // HandleKeyboardEvent destroys this RenderWidgetHostImpl).
   }
 }
 
 void RenderWidgetHostImpl::OnWheelEventAck(
     const MouseWheelEventWithLatencyInfo& wheel_event,
     InputEventAckState ack_result) {
-  ui::LatencyInfo latency = wheel_event.latency;
-  latency.AddLatencyNumber(
-      ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0);
-  if (!wheel_event.latency.FindLatency(
-          ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 0, NULL)) {
-    // MouseWheelEvent latency ends when it is acked but does not cause any
-    // rendering scheduled.
-    latency.AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT, 0, 0);
-  }
-  ComputeInputLatencyHistograms(blink::WebInputEvent::MouseWheel, latency);
+  latency_tracker_.OnInputEventAck(wheel_event.event, &wheel_event.latency);
 
   if (!is_hidden() && view_) {
     if (ack_result != INPUT_EVENT_ACK_STATE_CONSUMED &&
         delegate_->HandleWheelEvent(wheel_event.event)) {
       ack_result = INPUT_EVENT_ACK_STATE_CONSUMED;
     }
     view_->WheelEventAck(wheel_event.event, ack_result);
   }
 }
 
 void RenderWidgetHostImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
-  if (!event.latency.FindLatency(
-          ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 0, NULL)) {
-    // GestureEvent latency ends when it is acked but does not cause any
-    // rendering scheduled.
-    ui::LatencyInfo latency = event.latency;
-    latency.AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT, 0 ,0);
-  }
+  latency_tracker_.OnInputEventAck(event.event, &event.latency);
 
   if (ack_result != INPUT_EVENT_ACK_STATE_CONSUMED) {
     if (delegate_->HandleGestureEvent(event.event))
       ack_result = INPUT_EVENT_ACK_STATE_CONSUMED;
   }
 
   if (view_)
     view_->GestureEventAck(event.event, ack_result);
 }
 
 void RenderWidgetHostImpl::OnTouchEventAck(
     const TouchEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
-  TouchEventWithLatencyInfo touch_event = event;
-  touch_event.latency.AddLatencyNumber(
-      ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0);
-  // TouchEvent latency ends at ack if it didn't cause any rendering.
-  if (!touch_event.latency.FindLatency(
-          ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 0, NULL)) {
-    touch_event.latency.AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT, 0, 0);
-  }
-  ComputeInputLatencyHistograms(
-      blink::WebInputEvent::TouchTypeFirst, touch_event.latency);
+  latency_tracker_.OnInputEventAck(event.event, &event.latency);
 
   if (touch_emulator_ &&
       touch_emulator_->HandleTouchEventAck(event.event, ack_result)) {
     return;
   }
 
   if (view_)
-    view_->ProcessAckedTouchEvent(touch_event, ack_result);
+    view_->ProcessAckedTouchEvent(event, ack_result);
 }
 
 void RenderWidgetHostImpl::OnUnexpectedEventAck(UnexpectedEventAckType type) {
   if (type == BAD_ACK_MESSAGE) {
     RecordAction(base::UserMetricsAction("BadMessageTerminate_RWH2"));
     process_->ReceivedBadMessage();
   } else if (type == UNEXPECTED_EVENT_TYPE) {
     suppress_next_char_events_ = false;
   }
 }
@@ skipping 102 matching lines @@
   if (!auto_resize_enabled_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
-void RenderWidgetHostImpl::ComputeInputLatencyHistograms(
-    blink::WebInputEvent::Type type,
-    const ui::LatencyInfo& latency_info) const {
-  ui::LatencyInfo::LatencyComponent rwh_component;
-  if (!latency_info.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
-                                GetLatencyComponentId(),
-                                &rwh_component))
-    return;
-  DCHECK_EQ(rwh_component.event_count, 1u);
-
-  ui::LatencyInfo::LatencyComponent ui_component;
-  if (latency_info.FindLatency(ui::INPUT_EVENT_LATENCY_UI_COMPONENT,
-                               0,
-                               &ui_component)) {
-    DCHECK_EQ(ui_component.event_count, 1u);
-    base::TimeDelta ui_delta =
-        rwh_component.event_time - ui_component.event_time;
-    switch (type) {
-      case blink::WebInputEvent::MouseWheel:
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Event.Latency.Browser.WheelUI",
-            ui_delta.InMicroseconds(), 1, 20000, 100);
-        break;
-      case blink::WebInputEvent::TouchTypeFirst:
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Event.Latency.Browser.TouchUI",
-            ui_delta.InMicroseconds(), 1, 20000, 100);
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-
-  ui::LatencyInfo::LatencyComponent acked_component;
-  if (latency_info.FindLatency(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT,
-                               0,
-                               &acked_component)) {
-    DCHECK_EQ(acked_component.event_count, 1u);
-    base::TimeDelta acked_delta =
-        acked_component.event_time - rwh_component.event_time;
-    switch (type) {
-      case blink::WebInputEvent::MouseWheel:
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Event.Latency.Browser.WheelAcked",
-            acked_delta.InMicroseconds(), 1, 1000000, 100);
-        break;
-      case blink::WebInputEvent::TouchTypeFirst:
-        UMA_HISTOGRAM_CUSTOM_COUNTS(
-            "Event.Latency.Browser.TouchAcked",
-            acked_delta.InMicroseconds(), 1, 1000000, 100);
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-}
-
 void RenderWidgetHostImpl::FrameSwapped(const ui::LatencyInfo& latency_info) {
   ui::LatencyInfo::LatencyComponent window_snapshot_component;
   if (latency_info.FindLatency(ui::WINDOW_OLD_SNAPSHOT_FRAME_NUMBER_COMPONENT,
                                GetLatencyComponentId(),
                                &window_snapshot_component)) {
     WindowOldSnapshotReachedScreen(
         static_cast<int>(window_snapshot_component.sequence_number));
   }
   if (latency_info.FindLatency(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
                                GetLatencyComponentId(),
                                &window_snapshot_component)) {
     int sequence_number = static_cast<int>(
         window_snapshot_component.sequence_number);
 #if defined(OS_MACOSX)
     // On Mac, when using CoreAnmation, there is a delay between when content
     // is drawn to the screen, and when the snapshot will actually pick up
     // that content. Insert a manual delay of 1/6th of a second (to simulate
     // 10 frames at 60 fps) before actually taking the snapshot.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RenderWidgetHostImpl::WindowSnapshotReachedScreen,
                    weak_factory_.GetWeakPtr(),
                    sequence_number),
         base::TimeDelta::FromSecondsD(1. / 6));
 #else
     WindowSnapshotReachedScreen(sequence_number);
 #endif
   }
 
-  ui::LatencyInfo::LatencyComponent swap_component;
-  if (!latency_info.FindLatency(
-          ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT,
-          0,
-          &swap_component)) {
-    return;
-  }
-  ui::LatencyInfo::LatencyComponent tab_switch_component;
-  if (latency_info.FindLatency(ui::TAB_SHOW_COMPONENT,
-                               GetLatencyComponentId(),
-                               &tab_switch_component)) {
-    base::TimeDelta delta =
-        swap_component.event_time - tab_switch_component.event_time;
-    for (size_t i = 0; i < tab_switch_component.event_count; i++) {
-      UMA_HISTOGRAM_TIMES("MPArch.RWH_TabSwitchPaintDuration", delta);
-    }
-  }
-
-  ui::LatencyInfo::LatencyComponent rwh_component;
-  if (!latency_info.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
-                                GetLatencyComponentId(),
-                                &rwh_component)) {
-    return;
-  }
-
-  ui::LatencyInfo::LatencyComponent original_component;
-  if (latency_info.FindLatency(
-          ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
-          GetLatencyComponentId(),
-          &original_component)) {
-    // This UMA metric tracks the time from when the original touch event is
-    // created (averaged if there are multiple) to when the scroll gesture
-    // results in final frame swap.
-    base::TimeDelta delta =
-        swap_component.event_time - original_component.event_time;
-    for (size_t i = 0; i < original_component.event_count; i++) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "Event.Latency.TouchToScrollUpdateSwap",
-          delta.InMicroseconds(),
-          1,
-          1000000,
-          100);
-    }
-  }
+  latency_tracker_.OnFrameSwapped(latency_info);
 }
 
 void RenderWidgetHostImpl::DidReceiveRendererFrame() {
   view_->DidReceiveRendererFrame();
 }
 
 void RenderWidgetHostImpl::WindowSnapshotAsyncCallback(
     int routing_id,
     int snapshot_id,
     gfx::Size snapshot_size,
@@ skipping 115 matching lines @@
           continue;
         }
         RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
         if (rwhi_set.insert(rwhi).second)
           rwhi->FrameSwapped(latency_info[i]);
       }
     }
   }
 }
 
-void RenderWidgetHostImpl::AddLatencyInfoComponentIds(
-    ui::LatencyInfo* latency_info) {
-  ui::LatencyInfo::LatencyMap new_components;
-  ui::LatencyInfo::LatencyMap::iterator lc =
-      latency_info->latency_components.begin();
-  while (lc != latency_info->latency_components.end()) {
-    ui::LatencyComponentType component_type = lc->first.first;
-    if (component_type == ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT ||
-        component_type == ui::WINDOW_OLD_SNAPSHOT_FRAME_NUMBER_COMPONENT) {
-      // Generate a new component entry with the correct component ID
-      ui::LatencyInfo::LatencyMap::key_type key =
-          std::make_pair(component_type, GetLatencyComponentId());
-      new_components[key] = lc->second;
-
-      // Remove the old entry
-      latency_info->latency_components.erase(lc++);
-    } else {
-      ++lc;
-    }
-  }
-
-  // Add newly generated components into the latency info
-  for (lc = new_components.begin(); lc != new_components.end(); ++lc) {
-    latency_info->latency_components[lc->first] = lc->second;
-  }
-}
-
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetRootBrowserAccessibilityManager() {
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
   return delegate_ ?
       delegate_->GetOrCreateRootBrowserAccessibilityManager() : NULL;
 }
 
 #if defined(OS_WIN)
 gfx::NativeViewAccessible
     RenderWidgetHostImpl::GetParentNativeViewAccessible() {
   return delegate_ ? delegate_->GetParentNativeViewAccessible() : NULL;
 }
 #endif
 
 SkColorType RenderWidgetHostImpl::PreferredReadbackFormat() {
   if (view_)
     return view_->PreferredReadbackFormat();
   return kN32_SkColorType;
 }
 
 }  // namespace content