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

chrome/browser/ui/browser.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 "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 133 matching lines @@
 #include "content/browser/download/save_package.h"
 #include "content/browser/host_zoom_map.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/interstitial_page.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
-#include "content/browser/user_metrics.h"
 #include "content/public/browser/devtools_manager.h"
+#include "content/public/browser/intents_host.h"
+#include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/intents_host.h"
+#include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_restriction.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources_standard.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
@@ skipping 30 matching lines @@
 
 #if !defined(OS_CHROMEOS) || defined(USE_AURA)
 #include "chrome/browser/download/download_shelf.h"
 #endif
 
 #if defined(FILE_MANAGER_EXTENSION)
 #include "chrome/browser/extensions/file_manager_util.h"
 #endif
 
 using base::TimeDelta;
+using content::UserMetricsAction;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 // The URL to be loaded to display Help.
 const char kHelpContentUrl[] =
 #if defined(OS_CHROMEOS)
   #if defined(OFFICIAL_BUILD)
       "chrome-extension://honijodknafkokifofgiaalefdiedpko/main.html";
@@ skipping 1269 matching lines @@
     CancelWindowClose();
   return can_close;
 }
 
 bool Browser::CanGoBack() const {
   return GetSelectedTabContentsWrapper()->
       tab_contents()->controller().CanGoBack();
 }
 
 void Browser::GoBack(WindowOpenDisposition disposition) {
-  UserMetrics::RecordAction(UserMetricsAction("Back"));
+  content::RecordAction(UserMetricsAction("Back"));
 
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   if (CanGoBack()) {
     TabContents* new_tab = GetOrCloneTabForDisposition(disposition);
     // If we are on an interstitial page and clone the tab, it won't be copied
     // to the new tab, so we don't need to go back.
     if (current_tab->tab_contents()->showing_interstitial_page() &&
         (new_tab != current_tab->tab_contents()))
       return;
     new_tab->controller().GoBack();
   }
 }
 
 bool Browser::CanGoForward() const {
   return GetSelectedTabContentsWrapper()->
       tab_contents()->controller().CanGoForward();
 }
 
 void Browser::GoForward(WindowOpenDisposition disposition) {
-  UserMetrics::RecordAction(UserMetricsAction("Forward"));
+  content::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward())
     GetOrCloneTabForDisposition(disposition)->controller().GoForward();
 }
 
 void Browser::Reload(WindowOpenDisposition disposition) {
-  UserMetrics::RecordAction(UserMetricsAction("Reload"));
+  content::RecordAction(UserMetricsAction("Reload"));
   ReloadInternal(disposition, false);
 }
 
 void Browser::ReloadIgnoringCache(WindowOpenDisposition disposition) {
-  UserMetrics::RecordAction(UserMetricsAction("ReloadIgnoringCache"));
+  content::RecordAction(UserMetricsAction("ReloadIgnoringCache"));
   ReloadInternal(disposition, true);
 }
 
 void Browser::ReloadInternal(WindowOpenDisposition disposition,
                              bool ignore_cache) {
   // If we are showing an interstitial, treat this as an OpenURL.
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab && current_tab->showing_interstitial_page()) {
     NavigationEntry* entry = current_tab->controller().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
     OpenURL(entry->url(), GURL(), disposition, content::PAGE_TRANSITION_RELOAD);
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
   TabContents* tab = GetOrCloneTabForDisposition(disposition);
   if (!tab->FocusLocationBarByDefault())
     tab->Focus();
   if (ignore_cache)
     tab->controller().ReloadIgnoringCache(true);
   else
     tab->controller().Reload(true);
 }
 
 void Browser::Home(WindowOpenDisposition disposition) {
-  UserMetrics::RecordAction(UserMetricsAction("Home"));
+  content::RecordAction(UserMetricsAction("Home"));
   OpenURL(
       profile_->GetHomePage(), GURL(), disposition,
       content::PageTransitionFromInt(
           content::PAGE_TRANSITION_AUTO_BOOKMARK |
           content::PAGE_TRANSITION_HOME_PAGE));
 }
 
 void Browser::OpenCurrentURL() {
-  UserMetrics::RecordAction(UserMetricsAction("LoadURL"));
+  content::RecordAction(UserMetricsAction("LoadURL"));
   LocationBar* location_bar = window_->GetLocationBar();
   if (!location_bar)
     return;
 
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
   if (OpenInstant(open_disposition))
     return;
 
   GURL url(location_bar->GetInputString());
@@ skipping 20 matching lines @@
 
   DCHECK(profile_->GetExtensionService());
   if (profile_->GetExtensionService()->IsInstalledApp(url)) {
     UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppLaunchHistogram,
                               extension_misc::APP_LAUNCH_OMNIBOX_LOCATION,
                               extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
   }
 }
 
 void Browser::Stop() {
-  UserMetrics::RecordAction(UserMetricsAction("Stop"));
+  content::RecordAction(UserMetricsAction("Stop"));
   GetSelectedTabContentsWrapper()->tab_contents()->Stop();
 }
 
 void Browser::NewWindow() {
   IncognitoModePrefs::Availability incognito_avail =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
       incognito_avail != IncognitoModePrefs::DISABLED &&
       (CommandLine::ForCurrentProcess()->HasSwitch(switches::kIncognito) ||
        incognito_avail == IncognitoModePrefs::FORCED)) {
     NewIncognitoWindow();
     return;
   }
-  UserMetrics::RecordAction(UserMetricsAction("NewWindow"));
+  content::RecordAction(UserMetricsAction("NewWindow"));
   SessionService* session_service =
       SessionServiceFactory::GetForProfile(profile_->GetOriginalProfile());
   if (!session_service ||
       !session_service->RestoreIfNecessary(std::vector<GURL>())) {
     Browser::OpenEmptyWindow(profile_->GetOriginalProfile());
   }
 }
 
 void Browser::NewIncognitoWindow() {
   if (IncognitoModePrefs::GetAvailability(profile_->GetPrefs()) ==
           IncognitoModePrefs::DISABLED) {
     NewWindow();
     return;
   }
 
-  UserMetrics::RecordAction(UserMetricsAction("NewIncognitoWindow"));
+  content::RecordAction(UserMetricsAction("NewIncognitoWindow"));
   Browser::OpenEmptyWindow(profile_->GetOffTheRecordProfile());
 }
 
 void Browser::CloseWindow() {
-  UserMetrics::RecordAction(UserMetricsAction("CloseWindow"));
+  content::RecordAction(UserMetricsAction("CloseWindow"));
   window_->Close();
 }
 
 void Browser::NewTab() {
-  UserMetrics::RecordAction(UserMetricsAction("NewTab"));
+  content::RecordAction(UserMetricsAction("NewTab"));
 
   if (is_type_tabbed()) {
     AddBlankTab(true);
     GetSelectedTabContentsWrapper()->tab_contents()->view()->RestoreFocus();
   } else {
     Browser* b = GetOrCreateTabbedBrowser(profile_);
     b->AddBlankTab(true);
     b->window()->Show();
     // The call to AddBlankTab above did not set the focus to the tab as its
     // window was not active, so we have to do it explicitly.
     // See http://crbug.com/6380.
     b->GetSelectedTabContentsWrapper()->tab_contents()->view()->RestoreFocus();
   }
 }
 
 void Browser::CloseTab() {
-  UserMetrics::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
+  content::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   if (CanCloseTab())
     tab_handler_->GetTabStripModel()->CloseSelectedTabs();
 }
 
 void Browser::SelectNextTab() {
-  UserMetrics::RecordAction(UserMetricsAction("SelectNextTab"));
+  content::RecordAction(UserMetricsAction("SelectNextTab"));
   tab_handler_->GetTabStripModel()->SelectNextTab();
 }
 
 void Browser::SelectPreviousTab() {
-  UserMetrics::RecordAction(UserMetricsAction("SelectPrevTab"));
+  content::RecordAction(UserMetricsAction("SelectPrevTab"));
   tab_handler_->GetTabStripModel()->SelectPreviousTab();
 }
 
 void Browser::OpenTabpose() {
 #if defined(OS_MACOSX)
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableExposeForTabs)) {
     return;
   }
 
-  UserMetrics::RecordAction(UserMetricsAction("OpenTabpose"));
+  content::RecordAction(UserMetricsAction("OpenTabpose"));
   window()->OpenTabpose();
 #else
   NOTREACHED();
 #endif
 }
 
 void Browser::MoveTabNext() {
-  UserMetrics::RecordAction(UserMetricsAction("MoveTabNext"));
+  content::RecordAction(UserMetricsAction("MoveTabNext"));
   tab_handler_->GetTabStripModel()->MoveTabNext();
 }
 
 void Browser::MoveTabPrevious() {
-  UserMetrics::RecordAction(UserMetricsAction("MoveTabPrevious"));
+  content::RecordAction(UserMetricsAction("MoveTabPrevious"));
   tab_handler_->GetTabStripModel()->MoveTabPrevious();
 }
 
 void Browser::SelectNumberedTab(int index) {
   if (index < tab_count()) {
-    UserMetrics::RecordAction(UserMetricsAction("SelectNumberedTab"));
+    content::RecordAction(UserMetricsAction("SelectNumberedTab"));
     tab_handler_->GetTabStripModel()->ActivateTabAt(index, true);
   }
 }
 
 void Browser::SelectLastTab() {
-  UserMetrics::RecordAction(UserMetricsAction("SelectLastTab"));
+  content::RecordAction(UserMetricsAction("SelectLastTab"));
   tab_handler_->GetTabStripModel()->SelectLastTab();
 }
 
 void Browser::DuplicateTab() {
-  UserMetrics::RecordAction(UserMetricsAction("Duplicate"));
+  content::RecordAction(UserMetricsAction("Duplicate"));
   DuplicateContentsAt(active_index());
 }
 
 void Browser::RestoreTab() {
-  UserMetrics::RecordAction(UserMetricsAction("RestoreTab"));
+  content::RecordAction(UserMetricsAction("RestoreTab"));
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile_);
   if (!service)
     return;
 
   service->RestoreMostRecentEntry(tab_restore_service_delegate());
 }
 
 void Browser::WriteCurrentURLToClipboard() {
   // TODO(ericu): There isn't currently a metric for this.  Should there be?
   // We don't appear to track the action when it comes from the
   // RenderContextViewMenu.
 
   TabContents* contents = GetSelectedTabContents();
   if (!toolbar_model_.ShouldDisplayURL())
     return;
 
   chrome_browser_net::WriteURLToClipboard(
       contents->GetURL(),
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void Browser::ConvertPopupToTabbedBrowser() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowAsTab"));
+  content::RecordAction(UserMetricsAction("ShowAsTab"));
   int tab_strip_index = tab_handler_->GetTabStripModel()->active_index();
   TabContentsWrapper* contents =
       tab_handler_->GetTabStripModel()->DetachTabContentsAt(tab_strip_index);
   Browser* browser = Browser::Create(profile_);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 // TODO(koz): Change |for_tab| to an enum.
 void Browser::ToggleFullscreenMode(bool for_tab) {
@@ skipping 29 matching lines @@
     NewTab();
   }
 }
 
 void Browser::ShowKeyboardOverlay() {
   window_->ShowKeyboardOverlay(window_->GetNativeHandle());
 }
 #endif
 
 void Browser::Exit() {
-  UserMetrics::RecordAction(UserMetricsAction("Exit"));
+  content::RecordAction(UserMetricsAction("Exit"));
   BrowserList::AttemptUserExit();
 }
 
 void Browser::BookmarkCurrentPage() {
-  UserMetrics::RecordAction(UserMetricsAction("Star"));
+  content::RecordAction(UserMetricsAction("Star"));
 
   BookmarkModel* model = profile()->GetBookmarkModel();
   if (!model || !model->IsLoaded())
     return;  // Ignore requests until bookmarks are loaded.
 
   GURL url;
   string16 title;
   TabContentsWrapper* tab = GetSelectedTabContentsWrapper();
   bookmark_utils::GetURLAndTitleToBookmark(tab->tab_contents(), &url, &title);
   bool was_bookmarked = model->IsBookmarked(url);
   if (!was_bookmarked && profile_->IsOffTheRecord()) {
     // If we're incognito the favicon may not have been saved. Save it now
     // so that bookmarks have an icon for the page.
     tab->favicon_tab_helper()->SaveFavicon();
   }
   bookmark_utils::AddIfNotBookmarked(model, url, title);
   // Make sure the model actually added a bookmark before showing the star. A
   // bookmark isn't created if the url is invalid.
   if (window_->IsActive() && model->IsBookmarked(url)) {
     // Only show the bubble if the window is active, otherwise we may get into
     // weird situations were the bubble is deleted as soon as it is shown.
     window_->ShowBookmarkBubble(url, was_bookmarked);
   }
 }
 
 void Browser::SavePage() {
-  UserMetrics::RecordAction(UserMetricsAction("SavePage"));
+  content::RecordAction(UserMetricsAction("SavePage"));
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab && current_tab->contents_mime_type() == "application/pdf")
-    UserMetrics::RecordAction(UserMetricsAction("PDF.SavePage"));
+    content::RecordAction(UserMetricsAction("PDF.SavePage"));
   GetSelectedTabContents()->OnSavePage();
 }
 
 void Browser::ViewSelectedSource() {
   ViewSource(GetSelectedTabContentsWrapper());
 }
 
 void Browser::ShowFindBar() {
   GetFindBarController()->Show();
 }
 
 bool Browser::SupportsWindowFeature(WindowFeature feature) const {
   return SupportsWindowFeatureImpl(feature, true);
 }
 
 bool Browser::CanSupportWindowFeature(WindowFeature feature) const {
   return SupportsWindowFeatureImpl(feature, false);
 }
 
 void Browser::EmailPageLocation() {
-  UserMetrics::RecordAction(UserMetricsAction("EmailPageLocation"));
+  content::RecordAction(UserMetricsAction("EmailPageLocation"));
   TabContents* tc = GetSelectedTabContents();
   DCHECK(tc);
 
   std::string title = net::EscapeQueryParamValue(
       UTF16ToUTF8(tc->GetTitle()), false);
   std::string page_url = net::EscapeQueryParamValue(tc->GetURL().spec(), false);
   std::string mailto = std::string("mailto:?subject=Fwd:%20") +
       title + "&body=%0A%0A" + page_url;
   platform_util::OpenExternal(GURL(mailto));
 }
 
 void Browser::Print() {
   if (switches::IsPrintPreviewEnabled())
     GetSelectedTabContentsWrapper()->print_view_manager()->PrintPreviewNow();
   else
     GetSelectedTabContentsWrapper()->print_view_manager()->PrintNow();
 }
 
 void Browser::AdvancedPrint() {
   GetSelectedTabContentsWrapper()->print_view_manager()->AdvancedPrintNow();
 }
 
 void Browser::ToggleEncodingAutoDetect() {
-  UserMetrics::RecordAction(UserMetricsAction("AutoDetectChange"));
+  content::RecordAction(UserMetricsAction("AutoDetectChange"));
   encoding_auto_detect_.SetValue(!encoding_auto_detect_.GetValue());
   // If "auto detect" is turned on, then any current override encoding
   // is cleared. This also implicitly performs a reload.
   // OTOH, if "auto detect" is turned off, we don't change the currently
   // active encoding.
   if (encoding_auto_detect_.GetValue()) {
     TabContents* contents = GetSelectedTabContents();
     if (contents)
       contents->ResetOverrideEncoding();
   }
 }
 
 void Browser::OverrideEncoding(int encoding_id) {
-  UserMetrics::RecordAction(UserMetricsAction("OverrideEncoding"));
+  content::RecordAction(UserMetricsAction("OverrideEncoding"));
   const std::string selected_encoding =
       CharacterEncoding::GetCanonicalEncodingNameByCommandId(encoding_id);
   TabContents* contents = GetSelectedTabContents();
   if (!selected_encoding.empty() && contents)
      contents->SetOverrideEncoding(selected_encoding);
   // Update the list of recently selected encodings.
   std::string new_selected_encoding_list;
   if (CharacterEncoding::UpdateRecentlySelectedEncoding(
         profile_->GetPrefs()->GetString(prefs::kRecentlySelectedEncoding),
         encoding_id,
         &new_selected_encoding_list)) {
     profile_->GetPrefs()->SetString(prefs::kRecentlySelectedEncoding,
                                     new_selected_encoding_list);
   }
 }
 
 void Browser::Cut() {
-  UserMetrics::RecordAction(UserMetricsAction("Cut"));
+  content::RecordAction(UserMetricsAction("Cut"));
   window()->Cut();
 }
 
 void Browser::Copy() {
-  UserMetrics::RecordAction(UserMetricsAction("Copy"));
+  content::RecordAction(UserMetricsAction("Copy"));
   window()->Copy();
 }
 
 void Browser::Paste() {
-  UserMetrics::RecordAction(UserMetricsAction("Paste"));
+  content::RecordAction(UserMetricsAction("Paste"));
   window()->Paste();
 }
 
 void Browser::Find() {
-  UserMetrics::RecordAction(UserMetricsAction("Find"));
+  content::RecordAction(UserMetricsAction("Find"));
   FindInPage(false, false);
 }
 
 void Browser::FindNext() {
-  UserMetrics::RecordAction(UserMetricsAction("FindNext"));
+  content::RecordAction(UserMetricsAction("FindNext"));
   FindInPage(true, true);
 }
 
 void Browser::FindPrevious() {
-  UserMetrics::RecordAction(UserMetricsAction("FindPrevious"));
+  content::RecordAction(UserMetricsAction("FindPrevious"));
   FindInPage(true, false);
 }
 
 void Browser::Zoom(content::PageZoom zoom) {
   if (is_devtools())
     return;
 
   RenderViewHost* host =
       GetSelectedTabContentsWrapper()->tab_contents()->render_view_host();
   if (zoom == content::PAGE_ZOOM_RESET) {
     host->SetZoomLevel(0);
-    UserMetrics::RecordAction(UserMetricsAction("ZoomNormal"));
+    content::RecordAction(UserMetricsAction("ZoomNormal"));
     return;
   }
 
   double current_zoom_level = GetSelectedTabContents()->GetZoomLevel();
   double default_zoom_level =
       profile_->GetPrefs()->GetDouble(prefs::kDefaultZoomLevel);
 
   // Generate a vector of zoom levels from an array of known presets along with
   // the default level added if necessary.
   std::vector<double> zoom_levels =
       chrome_page_zoom::PresetZoomLevels(default_zoom_level);
 
   if (zoom == content::PAGE_ZOOM_OUT) {
     // Iterate through the zoom levels in reverse order to find the next
     // lower level based on the current zoom level for this page.
     for (std::vector<double>::reverse_iterator i = zoom_levels.rbegin();
          i != zoom_levels.rend(); ++i) {
       double zoom_level = *i;
       if (content::ZoomValuesEqual(zoom_level, current_zoom_level))
         continue;
       if (zoom_level < current_zoom_level) {
         host->SetZoomLevel(zoom_level);
-        UserMetrics::RecordAction(UserMetricsAction("ZoomMinus"));
+        content::RecordAction(UserMetricsAction("ZoomMinus"));
         return;
       }
-      UserMetrics::RecordAction(UserMetricsAction("ZoomMinus_AtMinimum"));
+      content::RecordAction(UserMetricsAction("ZoomMinus_AtMinimum"));
     }
   } else {
     // Iterate through the zoom levels in normal order to find the next
     // higher level based on the current zoom level for this page.
     for (std::vector<double>::const_iterator i = zoom_levels.begin();
          i != zoom_levels.end(); ++i) {
       double zoom_level = *i;
       if (content::ZoomValuesEqual(zoom_level, current_zoom_level))
         continue;
       if (zoom_level > current_zoom_level) {
         host->SetZoomLevel(zoom_level);
-        UserMetrics::RecordAction(UserMetricsAction("ZoomPlus"));
+        content::RecordAction(UserMetricsAction("ZoomPlus"));
         return;
       }
     }
-    UserMetrics::RecordAction(UserMetricsAction("ZoomPlus_AtMaximum"));
+    content::RecordAction(UserMetricsAction("ZoomPlus_AtMaximum"));
   }
 }
 
 void Browser::FocusToolbar() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusToolbar"));
+  content::RecordAction(UserMetricsAction("FocusToolbar"));
   window_->FocusToolbar();
 }
 
 void Browser::FocusAppMenu() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusAppMenu"));
+  content::RecordAction(UserMetricsAction("FocusAppMenu"));
   window_->FocusAppMenu();
 }
 
 void Browser::FocusLocationBar() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusLocation"));
+  content::RecordAction(UserMetricsAction("FocusLocation"));
   window_->SetFocusToLocationBar(true);
 }
 
 void Browser::FocusBookmarksToolbar() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusBookmarksToolbar"));
+  content::RecordAction(UserMetricsAction("FocusBookmarksToolbar"));
   window_->FocusBookmarksToolbar();
 }
 
 void Browser::FocusChromeOSStatus() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusChromeOSStatus"));
+  content::RecordAction(UserMetricsAction("FocusChromeOSStatus"));
   window_->FocusChromeOSStatus();
 }
 
 void Browser::FocusNextPane() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusNextPane"));
+  content::RecordAction(UserMetricsAction("FocusNextPane"));
   window_->RotatePaneFocus(true);
 }
 
 void Browser::FocusPreviousPane() {
-  UserMetrics::RecordAction(UserMetricsAction("FocusPreviousPane"));
+  content::RecordAction(UserMetricsAction("FocusPreviousPane"));
   window_->RotatePaneFocus(false);
 }
 
 void Browser::FocusSearch() {
   // TODO(beng): replace this with FocusLocationBar
-  UserMetrics::RecordAction(UserMetricsAction("FocusSearch"));
+  content::RecordAction(UserMetricsAction("FocusSearch"));
   window_->GetLocationBar()->FocusSearch();
 }
 
 void Browser::OpenFile() {
-  UserMetrics::RecordAction(UserMetricsAction("OpenFile"));
+  content::RecordAction(UserMetricsAction("OpenFile"));
   if (!select_file_dialog_.get())
     select_file_dialog_ = SelectFileDialog::Create(this);
 
   const FilePath directory = profile_->last_selected_directory();
 
   // TODO(beng): figure out how to juggle this.
   gfx::NativeWindow parent_window = window_->GetNativeHandle();
   select_file_dialog_->SelectFile(SelectFileDialog::SELECT_OPEN_FILE,
                                   string16(), directory,
                                   NULL, 0, FILE_PATH_LITERAL(""),
                                   GetSelectedTabContents(),
                                   parent_window, NULL);
 }
 
 void Browser::OpenCreateShortcutsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("CreateShortcut"));
+  content::RecordAction(UserMetricsAction("CreateShortcut"));
 #if !defined(OS_MACOSX)
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   DCHECK(current_tab &&
       web_app::IsValidUrl(current_tab->tab_contents()->GetURL())) <<
           "Menu item should be disabled.";
 
   NavigationEntry* entry =
       current_tab->tab_contents()->controller().GetLastCommittedEntry();
   if (!entry)
     return;
 
   // RVH's GetApplicationInfo should not be called before it returns.
   DCHECK(pending_web_app_action_ == NONE);
   pending_web_app_action_ = CREATE_SHORTCUT;
 
   // Start fetching web app info for CreateApplicationShortcut dialog and show
   // the dialog when the data is available in OnDidGetApplicationInfo.
   current_tab->extension_tab_helper()->GetApplicationInfo(entry->page_id());
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 void Browser::ToggleDevToolsWindow(DevToolsToggleAction action) {
   if (action == DEVTOOLS_TOGGLE_ACTION_SHOW_CONSOLE)
-    UserMetrics::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
+    content::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
   else
-    UserMetrics::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
+    content::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
 
   DevToolsWindow::ToggleDevToolsWindow(
       GetSelectedTabContentsWrapper()->tab_contents()->render_view_host(),
       action);
 }
 
 void Browser::OpenTaskManager(bool highlight_background_resources) {
-  UserMetrics::RecordAction(UserMetricsAction("TaskManager"));
+  content::RecordAction(UserMetricsAction("TaskManager"));
   if (highlight_background_resources)
     window_->ShowBackgroundPages();
   else
     window_->ShowTaskManager();
 }
 
 void Browser::OpenBugReportDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("ReportBug"));
+  content::RecordAction(UserMetricsAction("ReportBug"));
   browser::ShowHtmlBugReportView(this, std::string(), 0);
 }
 
 void Browser::ToggleBookmarkBar() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowBookmarksBar"));
+  content::RecordAction(UserMetricsAction("ShowBookmarksBar"));
   window_->ToggleBookmarkBar();
 }
 
 void Browser::OpenBookmarkManager() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowBookmarkManager"));
-  UserMetrics::RecordAction(UserMetricsAction("ShowBookmarks"));
+  content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
+  content::RecordAction(UserMetricsAction("ShowBookmarks"));
   ShowSingletonTabOverwritingNTP(
       GetSingletonTabNavigateParams(GURL(chrome::kChromeUIBookmarksURL)));
 }
 
 void Browser::OpenBookmarkManagerWithHash(const std::string& action,
                                           int64 node_id) {
-  UserMetrics::RecordAction(UserMetricsAction("ShowBookmarkManager"));
-  UserMetrics::RecordAction(UserMetricsAction("ShowBookmarks"));
+  content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
+  content::RecordAction(UserMetricsAction("ShowBookmarks"));
   browser::NavigateParams params(GetSingletonTabNavigateParams(
       GURL(chrome::kChromeUIBookmarksURL).Resolve(
       StringPrintf("/#%s%s", action.c_str(),
       base::Int64ToString(node_id).c_str()))));
   params.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(params);
 }
 
 void Browser::OpenBookmarkManagerForNode(int64 node_id) {
   OpenBookmarkManagerWithHash("", node_id);
 }
 
 void Browser::OpenBookmarkManagerEditNode(int64 node_id) {
   OpenBookmarkManagerWithHash("e=", node_id);
 }
 
 void Browser::ShowAppMenu() {
   // We record the user metric for this event in WrenchMenu::RunMenu.
   window_->ShowAppMenu();
 }
 
 void Browser::ShowAvatarMenu() {
   window_->ShowAvatarBubbleFromAvatarButton();
 }
 
 void Browser::ShowHistoryTab() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowHistory"));
+  content::RecordAction(UserMetricsAction("ShowHistory"));
   ShowSingletonTabOverwritingNTP(
       GetSingletonTabNavigateParams(GURL(chrome::kChromeUIHistoryURL)));
 }
 
 void Browser::ShowDownloadsTab() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowDownloads"));
+  content::RecordAction(UserMetricsAction("ShowDownloads"));
 #if !defined(OS_CHROMEOS)
   // ChromiumOS uses ActiveDownloadsUI instead of of DownloadShelf.
   if (window()) {
     DownloadShelf* shelf = window()->GetDownloadShelf();
     if (shelf->IsShowing())
       shelf->Close();
   }
 #endif
   ShowSingletonTabOverwritingNTP(
       GetSingletonTabNavigateParams(GURL(chrome::kChromeUIDownloadsURL)));
 }
 
 void Browser::ShowExtensionsTab() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowExtensions"));
+  content::RecordAction(UserMetricsAction("ShowExtensions"));
   ShowOptionsTab(chrome::kExtensionsSubPage);
 }
 
 void Browser::ShowAboutConflictsTab() {
-  UserMetrics::RecordAction(UserMetricsAction("AboutConflicts"));
+  content::RecordAction(UserMetricsAction("AboutConflicts"));
   ShowSingletonTab(GURL(chrome::kChromeUIConflictsURL));
 }
 
 void Browser::ShowBrokenPageTab(TabContents* contents) {
-  UserMetrics::RecordAction(UserMetricsAction("ReportBug"));
+  content::RecordAction(UserMetricsAction("ReportBug"));
   string16 page_title = contents->GetTitle();
   NavigationEntry* entry = contents->controller().GetActiveEntry();
   if (!entry)
     return;
   std::string page_url = entry->url().spec();
   std::vector<std::string> subst;
   subst.push_back(UTF16ToASCII(page_title));
   subst.push_back(page_url);
   std::string report_page_url =
       ReplaceStringPlaceholders(kBrokenPageUrl, subst, NULL);
   ShowSingletonTab(GURL(report_page_url));
 }
 
 void Browser::ShowOptionsTab(const std::string& sub_page) {
   browser::NavigateParams params(GetSingletonTabNavigateParams(
       GURL(chrome::kChromeUISettingsURL + sub_page)));
   params.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
 
   ShowSingletonTabOverwritingNTP(params);
 }
 
 void Browser::OpenClearBrowsingDataDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg"));
+  content::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg"));
   ShowOptionsTab(chrome::kClearBrowserDataSubPage);
 }
 
 void Browser::OpenOptionsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowOptions"));
+  content::RecordAction(UserMetricsAction("ShowOptions"));
   ShowOptionsTab("");
 }
 
 void Browser::OpenPasswordManager() {
-  UserMetrics::RecordAction(UserMetricsAction("Options_ShowPasswordManager"));
+  content::RecordAction(UserMetricsAction("Options_ShowPasswordManager"));
   ShowOptionsTab(chrome::kPasswordManagerSubPage);
 }
 
 void Browser::OpenImportSettingsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("Import_ShowDlg"));
+  content::RecordAction(UserMetricsAction("Import_ShowDlg"));
   ShowOptionsTab(chrome::kImportDataSubPage);
 }
 
 void Browser::OpenInstantConfirmDialog() {
   ShowOptionsTab(chrome::kInstantConfirmPage);
 }
 
 void Browser::OpenSyncMyBookmarksDialog() {
   sync_ui_util::OpenSyncMyBookmarksDialog(
       profile_, this, ProfileSyncService::START_FROM_WRENCH);
 }
 
 void Browser::OpenAboutChromeDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("AboutChrome"));
+  content::RecordAction(UserMetricsAction("AboutChrome"));
 #if defined(OS_CHROMEOS)
   std::string chrome_settings(chrome::kChromeUISettingsURL);
   ShowSingletonTab(GURL(chrome_settings.append(chrome::kAboutOptionsSubPage)));
 #else
   window_->ShowAboutChromeDialog();
 #endif
 }
 
 void Browser::OpenUpdateChromeDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("UpdateChrome"));
+  content::RecordAction(UserMetricsAction("UpdateChrome"));
   window_->ShowUpdateChromeDialog();
 }
 
 void Browser::ShowHelpTab() {
-  UserMetrics::RecordAction(UserMetricsAction("ShowHelpTab"));
+  content::RecordAction(UserMetricsAction("ShowHelpTab"));
   GURL help_url(kHelpContentUrl);
   GURL localized_help_url = google_util::AppendGoogleLocaleParam(help_url);
   ShowSingletonTab(localized_help_url);
 }
 
 void Browser::OpenPrivacyDashboardTabAndActivate() {
   OpenURL(GURL(kPrivacyDashboardUrl), GURL(),
           NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_LINK);
   window_->Activate();
 }
 
 void Browser::OpenAutofillHelpTabAndActivate() {
   GURL help_url = google_util::AppendGoogleLocaleParam(GURL(kAutofillHelpUrl));
   AddSelectedTabWithURL(help_url, content::PAGE_TRANSITION_LINK);
 }
 
 void Browser::OpenSearchEngineOptionsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("EditSearchEngines"));
+  content::RecordAction(UserMetricsAction("EditSearchEngines"));
   ShowOptionsTab(chrome::kSearchEnginesSubPage);
 }
 
 #if defined(FILE_MANAGER_EXTENSION)
 void Browser::OpenFileManager() {
-  UserMetrics::RecordAction(UserMetricsAction("OpenFileManager"));
+  content::RecordAction(UserMetricsAction("OpenFileManager"));
   ShowSingletonTabRespectRef(GURL(chrome::kChromeUIFileManagerURL));
 }
 #endif
 
 #if defined(OS_CHROMEOS)
 void Browser::LockScreen() {
-  UserMetrics::RecordAction(UserMetricsAction("LockScreen"));
+  content::RecordAction(UserMetricsAction("LockScreen"));
   chromeos::CrosLibrary::Get()->GetScreenLockLibrary()->
       NotifyScreenLockRequested();
 }
 
 void Browser::Shutdown() {
-  UserMetrics::RecordAction(UserMetricsAction("Shutdown"));
+  content::RecordAction(UserMetricsAction("Shutdown"));
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
       RequestShutdown();
 }
 
 void Browser::OpenSystemOptionsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("OpenSystemOptionsDialog"));
+  content::RecordAction(UserMetricsAction("OpenSystemOptionsDialog"));
   ShowOptionsTab(chrome::kSystemOptionsSubPage);
 }
 
 void Browser::OpenInternetOptionsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("OpenInternetOptionsDialog"));
+  content::RecordAction(UserMetricsAction("OpenInternetOptionsDialog"));
   ShowOptionsTab(chrome::kInternetOptionsSubPage);
 }
 
 void Browser::OpenLanguageOptionsDialog() {
-  UserMetrics::RecordAction(UserMetricsAction("OpenLanguageOptionsDialog"));
+  content::RecordAction(UserMetricsAction("OpenLanguageOptionsDialog"));
   ShowOptionsTab(chrome::kLanguageOptionsSubPage);
 }
 
 void Browser::OpenSystemTabAndActivate() {
   OpenURL(GURL(chrome::kChromeUISystemInfoURL), GURL(),
           NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_LINK);
   window_->Activate();
 }
 
 void Browser::OpenMobilePlanTabAndActivate() {
@@ skipping 283 matching lines @@
   if (policy->IsPseudoScheme(protocol) || policy->IsDisabledScheme(protocol))
     return;
 
   ProtocolHandler handler =
       ProtocolHandler::CreateProtocolHandler(protocol, url, title);
 
   ProtocolHandlerRegistry* registry =
       tcw->profile()->GetProtocolHandlerRegistry();
 
   if (!registry->SilentlyHandleRegisterHandlerRequest(handler)) {
-    UserMetrics::RecordAction(
+    content::RecordAction(
         UserMetricsAction("RegisterProtocolHandler.InfoBar_Shown"));
     InfoBarTabHelper* infobar_helper = tcw->infobar_tab_helper();
     infobar_helper->AddInfoBar(
         new RegisterProtocolHandlerInfoBarDelegate(infobar_helper,
                                                    registry,
                                                    handler));
   }
 }
 
 // static
@@ skipping 2591 matching lines @@
       contents->tab_contents()->controller().GetActiveEntry();
   if (!active_entry)
     return;
 
   ViewSource(contents, active_entry->url(), active_entry->content_state());
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents,
                          const GURL& url,
                          const std::string& content_state) {
-  UserMetrics::RecordAction(UserMetricsAction("ViewSource"));
+  content::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
   TabContentsWrapper* view_source_contents = contents->Clone();
   view_source_contents->tab_contents()->controller().PruneAllButActive();
   NavigationEntry* active_entry =
       view_source_contents->tab_contents()->controller().GetActiveEntry();
   if (!active_entry)
     return;
 
   GURL view_source_url = GURL(chrome::kViewSourceScheme + std::string(":") +
@@ skipping 139 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }