Move cc/debug/latency_info to ui/base.

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 <utility>
 
 #include "base/auto_reset.h"
@@ skipping 966 matching lines @@
 void RenderWidgetHostImpl::OnPointerEventActivate() {
 }
 
 void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   ForwardWheelEventWithLatencyInfo(wheel_event, NewInputLatencyInfo());
 }
 
 void RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo(
     const WebMouseWheelEvent& wheel_event,
-    const cc::LatencyInfo& latency_info) {
+    const ui::LatencyInfo& latency_info) {
   TRACE_EVENT0("renderer_host",
                "RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (delegate_->PreHandleWheelEvent(wheel_event))
     return;
 
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
@@ skipping 42 matching lines @@
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), latency_info,
                     false);
 }
 
 void RenderWidgetHostImpl::ForwardGestureEvent(
     const WebKit::WebGestureEvent& gesture_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardGestureEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
-  cc::LatencyInfo latency_info = NewInputLatencyInfo();
+  ui::LatencyInfo latency_info = NewInputLatencyInfo();
 
   if (!IsInOverscrollGesture() &&
       !gesture_event_filter_->ShouldForward(
           GestureEventWithLatencyInfo(gesture_event, latency_info)))
     return;
 
   ForwardInputEvent(gesture_event, sizeof(WebGestureEvent),
                     latency_info, false);
 }
 
@@ skipping 134 matching lines @@
 }
 
 void RenderWidgetHostImpl::SendCursorVisibilityState(bool is_visible) {
   Send(new InputMsg_CursorVisibilityChange(GetRoutingID(), is_visible));
 }
 
 int64 RenderWidgetHostImpl::GetLatencyComponentId() {
   return GetRoutingID() | (static_cast<int64>(GetProcess()->GetID()) << 32);
 }
 
-cc::LatencyInfo RenderWidgetHostImpl::NewInputLatencyInfo() {
-  cc::LatencyInfo info;
-  info.AddLatencyNumber(
-      cc::kInputEvent, GetLatencyComponentId(), ++last_input_number_);
+ui::LatencyInfo RenderWidgetHostImpl::NewInputLatencyInfo() {
+  ui::LatencyInfo info;
+  info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_COMPONENT,
+                        GetLatencyComponentId(),
+                        ++last_input_number_);
   return info;
 }
 
 void RenderWidgetHostImpl::SendInputEvent(const WebInputEvent& input_event,
                                           int event_size,
-                                          const cc::LatencyInfo& latency_info,
+                                          const ui::LatencyInfo& latency_info,
                                           bool is_keyboard_shortcut) {
   input_event_start_time_ = TimeTicks::Now();
   Send(new InputMsg_HandleInputEvent(
       routing_id_, &input_event, latency_info, is_keyboard_shortcut));
   increment_in_flight_event_count();
 }
 
 void RenderWidgetHostImpl::ForwardInputEvent(
     const WebInputEvent& input_event, int event_size,
-    const cc::LatencyInfo& latency_info, bool is_keyboard_shortcut) {
+    const ui::LatencyInfo& latency_info, bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardInputEvent");
 
   if (!process_->HasConnection())
     return;
 
   DCHECK(!process_->IgnoreInputEvents());
 
   if (overscroll_controller_.get() &&
       !overscroll_controller_->WillDispatchEvent(input_event, latency_info)) {
     // Reset the wheel-event state when appropriate.
@@ skipping 1232 matching lines @@
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
-void RenderWidgetHostImpl::FrameSwapped(const cc::LatencyInfo& latency_info) {
+void RenderWidgetHostImpl::FrameSwapped(const ui::LatencyInfo& latency_info) {
 }
 
 }  // namespace content