Split UserMetrics into API vs. implementation. Move API to content/public.

content/browser/renderer_host/render_widget_host.cc

 // Copyright (c) 2011 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.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_state.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
-#include "content/browser/user_metrics.h"
 #include "content/common/gpu/gpu_messages.h"
-#include "content/public/browser/notification_service.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/plugins/npapi/webplugin.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
-
+using content::UserMetricsAction;
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebTextDirection;
 
 // How long to (synchronously) wait for the renderer to respond with a
 // PaintRect message, when our backing-store is invalid, before giving up and
 // returning a null or incorrectly sized backing-store from GetBackingStore.
@@ skipping 186 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_CreatePluginContainer,
                         OnMsgCreatePluginContainer)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DestroyPluginContainer,
                         OnMsgDestroyPluginContainer)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   if (!msg_is_ok) {
     // The message de-serialization failed. Kill the renderer process.
-    UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_RWH"));
+    content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH"));
     process()->ReceivedBadMessage();
   }
   return handled;
 }
 
 bool RenderWidgetHost::Send(IPC::Message* msg) {
   return process_->Send(msg);
 }
 
 void RenderWidgetHost::WasHidden() {
@@ skipping 765 matching lines @@
     DCHECK(!params.bitmap_rect.IsEmpty());
     const size_t size = params.bitmap_rect.height() *
         params.bitmap_rect.width() * 4;
     TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
 
     // If gpu process does painting, scroll_rect and copy_rects are always empty
     // and backing store is never used.
     if (dib) {
       if (dib->size() < size) {
         DLOG(WARNING) << "Transport DIB too small for given rectangle";
-        UserMetrics::RecordAction(
+        content::RecordAction(
             UserMetricsAction("BadMessageTerminate_RWH1"));
         process()->ReceivedBadMessage();
       } else {
         // Scroll the backing store.
         if (!params.scroll_rect.IsEmpty()) {
           ScrollBackingStoreRect(params.dx, params.dy,
                                  params.scroll_rect,
                                  params.view_size);
         }
 
@@ skipping 102 matching lines @@
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_InputEventDelta", delta);
 
   // Cancel pending hung renderer checks since the renderer is responsive.
   StopHangMonitorTimeout();
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
-    UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
+    content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
     process()->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
       DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
       ForwardMouseEvent(*next_mouse_move_);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
@@ skipping 24 matching lines @@
     coalesced_mouse_wheel_events_.pop_front();
     ForwardWheelEvent(next_wheel_event);
   }
 
   if (!processed && !is_hidden_ && view_)
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
 void RenderWidgetHost::OnMsgFocus() {
   // Only RenderViewHost can deal with that message.
-  UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_RWH4"));
+  content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH4"));
   process()->ReceivedBadMessage();
 }
 
 void RenderWidgetHost::OnMsgBlur() {
   // Only RenderViewHost can deal with that message.
-  UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_RWH5"));
+  content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH5"));
   process()->ReceivedBadMessage();
 }
 
 void RenderWidgetHost::OnMsgSetCursor(const WebCursor& cursor) {
   if (!view_) {
     return;
   }
   view_->UpdateCursor(cursor);
 }
 
@@ skipping 230 matching lines @@
   Send(new ViewMsg_ScrollFocusedEditableNodeIntoRect(routing_id(), rect));
 }
 
 void RenderWidgetHost::SelectRange(const gfx::Point& start,
                                    const gfx::Point& end) {
   Send(new ViewMsg_SelectRange(routing_id(), start, end));
 }
 
 void RenderWidgetHost::Undo() {
   Send(new ViewMsg_Undo(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("Undo"));
+  content::RecordAction(UserMetricsAction("Undo"));
 }
 
 void RenderWidgetHost::Redo() {
   Send(new ViewMsg_Redo(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("Redo"));
+  content::RecordAction(UserMetricsAction("Redo"));
 }
 
 void RenderWidgetHost::Cut() {
   Send(new ViewMsg_Cut(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("Cut"));
+  content::RecordAction(UserMetricsAction("Cut"));
 }
 
 void RenderWidgetHost::Copy() {
   Send(new ViewMsg_Copy(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("Copy"));
+  content::RecordAction(UserMetricsAction("Copy"));
 }
 
 void RenderWidgetHost::CopyToFindPboard() {
 #if defined(OS_MACOSX)
   // Windows/Linux don't have the concept of a find pasteboard.
   Send(new ViewMsg_CopyToFindPboard(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("CopyToFindPboard"));
+  content::RecordAction(UserMetricsAction("CopyToFindPboard"));
 #endif
 }
 
 void RenderWidgetHost::Paste() {
   Send(new ViewMsg_Paste(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("Paste"));
+  content::RecordAction(UserMetricsAction("Paste"));
 }
 
 void RenderWidgetHost::PasteAndMatchStyle() {
   Send(new ViewMsg_PasteAndMatchStyle(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("PasteAndMatchStyle"));
+  content::RecordAction(UserMetricsAction("PasteAndMatchStyle"));
 }
 
 void RenderWidgetHost::Delete() {
   Send(new ViewMsg_Delete(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("DeleteSelection"));
+  content::RecordAction(UserMetricsAction("DeleteSelection"));
 }
 
 void RenderWidgetHost::SelectAll() {
   Send(new ViewMsg_SelectAll(routing_id()));
-  UserMetrics::RecordAction(UserMetricsAction("SelectAll"));
+  content::RecordAction(UserMetricsAction("SelectAll"));
 }
 bool RenderWidgetHost::GotResponseToLockMouseRequest(bool allowed) {
   if (!allowed) {
     RejectMouseLockOrUnlockIfNecessary();
     return false;
   } else {
     if (!pending_mouse_lock_request_) {
       // This is possible, e.g., the plugin sends us an unlock request before
       // the user allows to lock to mouse.
       return false;
@@ skipping 17 matching lines @@
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
 void RenderWidgetHost::AcknowledgePostSubBuffer(int32 route_id,
                                                 int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }