Remove the wrapper functions content::RecordAction et al

chrome/browser/ui/browser_commands.cc

 // Copyright 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 "chrome/browser/ui/browser_commands.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/user_metrics.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 52 matching lines @@
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "components/zoom/page_zoom.h"
 #include "components/zoom/zoom_controller.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
-#include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_state.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/common/user_agent.h"
 #include "extensions/features/features.h"
 #include "net/base/escape.h"
 #include "printing/features/features.h"
 #include "rlz/features/features.h"
@@ skipping 279 matching lines @@
       incognito = false;
     }
   } else if (profile->IsGuestSession() ||
              (browser_defaults::kAlwaysOpenIncognitoWindow &&
               IncognitoModePrefs::ShouldLaunchIncognito(
                   *base::CommandLine::ForCurrentProcess(), prefs))) {
     incognito = true;
   }
 
   if (incognito) {
-    content::RecordAction(UserMetricsAction("NewIncognitoWindow"));
+    base::RecordAction(UserMetricsAction("NewIncognitoWindow"));
     OpenEmptyWindow(profile->GetOffTheRecordProfile());
   } else {
-    content::RecordAction(UserMetricsAction("NewWindow"));
+    base::RecordAction(UserMetricsAction("NewWindow"));
     SessionService* session_service =
         SessionServiceFactory::GetForProfileForSessionRestore(
             profile->GetOriginalProfile());
     if (!session_service ||
         !session_service->RestoreIfNecessary(std::vector<GURL>())) {
       OpenEmptyWindow(profile->GetOriginalProfile());
     }
   }
 }
 
@@ skipping 18 matching lines @@
   AddSelectedTabWithURL(displayer.browser(), url,
       ui::PAGE_TRANSITION_LINK);
 }
 
 bool CanGoBack(const Browser* browser) {
   return browser->tab_strip_model()->GetActiveWebContents()->
       GetController().CanGoBack();
 }
 
 void GoBack(Browser* browser, WindowOpenDisposition disposition) {
-  content::RecordAction(UserMetricsAction("Back"));
+  base::RecordAction(UserMetricsAction("Back"));
 
   if (CanGoBack(browser)) {
     WebContents* current_tab =
         browser->tab_strip_model()->GetActiveWebContents();
     WebContents* new_tab = GetTabAndRevertIfNecessary(browser, 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 ((new_tab == current_tab) || !current_tab->ShowingInterstitialPage())
       new_tab->GetController().GoBack();
   }
 }
 
 bool CanGoForward(const Browser* browser) {
   return browser->tab_strip_model()->GetActiveWebContents()->
       GetController().CanGoForward();
 }
 
 void GoForward(Browser* browser, WindowOpenDisposition disposition) {
-  content::RecordAction(UserMetricsAction("Forward"));
+  base::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward(browser)) {
     GetTabAndRevertIfNecessary(browser, disposition)->
         GetController().GoForward();
   }
 }
 
 bool NavigateToIndexWithDisposition(Browser* browser,
                                     int index,
                                     WindowOpenDisposition disposition) {
   NavigationController* controller =
       &GetTabAndRevertIfNecessary(browser, disposition)->GetController();
   if (index < 0 || index >= controller->GetEntryCount())
     return false;
   controller->GoToIndex(index);
   return true;
 }
 
 void Reload(Browser* browser, WindowOpenDisposition disposition) {
-  content::RecordAction(UserMetricsAction("Reload"));
+  base::RecordAction(UserMetricsAction("Reload"));
   ReloadInternal(browser, disposition, false);
 }
 
 void ReloadBypassingCache(Browser* browser, WindowOpenDisposition disposition) {
-  content::RecordAction(UserMetricsAction("ReloadBypassingCache"));
+  base::RecordAction(UserMetricsAction("ReloadBypassingCache"));
   ReloadInternal(browser, disposition, true);
 }
 
 bool CanReload(const Browser* browser) {
   return !browser->is_devtools();
 }
 
 void Home(Browser* browser, WindowOpenDisposition disposition) {
-  content::RecordAction(UserMetricsAction("Home"));
+  base::RecordAction(UserMetricsAction("Home"));
 
   std::string extra_headers;
 #if BUILDFLAG(ENABLE_RLZ)
   // If the home page is a Google home page, add the RLZ header to the request.
   PrefService* pref_service = browser->profile()->GetPrefs();
   if (pref_service) {
     if (google_util::IsGoogleHomePageUrl(
         GURL(pref_service->GetString(prefs::kHomePage)))) {
       extra_headers = rlz::RLZTracker::GetAccessPointHttpHeader(
           rlz::RLZTracker::ChromeHomePage());
@@ skipping 27 matching lines @@
       url, Referrer(), disposition,
       ui::PageTransitionFromInt(
           ui::PAGE_TRANSITION_AUTO_BOOKMARK |
           ui::PAGE_TRANSITION_HOME_PAGE),
       false);
   params.extra_headers = extra_headers;
   browser->OpenURL(params);
 }
 
 void OpenCurrentURL(Browser* browser) {
-  content::RecordAction(UserMetricsAction("LoadURL"));
+  base::RecordAction(UserMetricsAction("LoadURL"));
   LocationBar* location_bar = browser->window()->GetLocationBar();
   if (!location_bar)
     return;
 
   GURL url(location_bar->GetDestinationURL());
 
   ui::PageTransition page_transition = location_bar->GetPageTransition();
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
   // A PAGE_TRANSITION_TYPED means the user has typed a URL. We do not want to
@@ skipping 28 matching lines @@
       extensions::ExtensionRegistry::Get(browser->profile())
           ->enabled_extensions().GetAppByURL(url);
   if (extension) {
     extensions::RecordAppLaunchType(extension_misc::APP_LAUNCH_OMNIBOX_LOCATION,
                                     extension->GetType());
   }
 #endif
 }
 
 void Stop(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Stop"));
+  base::RecordAction(UserMetricsAction("Stop"));
   browser->tab_strip_model()->GetActiveWebContents()->Stop();
 }
 
 void NewWindow(Browser* browser) {
   NewEmptyWindow(browser->profile()->GetOriginalProfile());
 }
 
 void NewIncognitoWindow(Browser* browser) {
   NewEmptyWindow(browser->profile()->GetOffTheRecordProfile());
 }
 
 void CloseWindow(Browser* browser) {
-  content::RecordAction(UserMetricsAction("CloseWindow"));
+  base::RecordAction(UserMetricsAction("CloseWindow"));
   browser->window()->Close();
 }
 
 void NewTab(Browser* browser) {
-  content::RecordAction(UserMetricsAction("NewTab"));
+  base::RecordAction(UserMetricsAction("NewTab"));
   // TODO(asvitkine): This is invoked programmatically from several places.
   // Audit the code and change it so that the histogram only gets collected for
   // user-initiated commands.
   UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", TabStripModel::NEW_TAB_COMMAND,
                             TabStripModel::NEW_TAB_ENUM_COUNT);
 
   if (browser->is_type_tabbed()) {
     AddTabAt(browser, GURL(), -1, true);
     browser->tab_strip_model()->GetActiveWebContents()->RestoreFocus();
   } else {
     ScopedTabbedBrowserDisplayer displayer(browser->profile());
     Browser* b = displayer.browser();
     AddTabAt(b, GURL(), -1, true);
     b->window()->Show();
     // The call to AddBlankTabAt 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->tab_strip_model()->GetActiveWebContents()->RestoreFocus();
   }
 }
 
 void CloseTab(Browser* browser) {
-  content::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
+  base::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   browser->tab_strip_model()->CloseSelectedTabs();
 }
 
 bool CanZoomIn(content::WebContents* contents) {
   return contents && !contents->IsCrashed() &&
          zoom::ZoomController::FromWebContents(contents)->GetZoomPercent() !=
              contents->GetMaximumZoomPercent();
 }
 
 bool CanZoomOut(content::WebContents* contents) {
@@ skipping 14 matching lines @@
   sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser->profile());
   if (!service || service->entries().empty())
     return TabStripModelDelegate::RESTORE_NONE;
   if (service->entries().front()->type == sessions::TabRestoreService::WINDOW)
     return TabStripModelDelegate::RESTORE_WINDOW;
   return TabStripModelDelegate::RESTORE_TAB;
 }
 
 void SelectNextTab(Browser* browser) {
-  content::RecordAction(UserMetricsAction("SelectNextTab"));
+  base::RecordAction(UserMetricsAction("SelectNextTab"));
   browser->tab_strip_model()->SelectNextTab();
 }
 
 void SelectPreviousTab(Browser* browser) {
-  content::RecordAction(UserMetricsAction("SelectPrevTab"));
+  base::RecordAction(UserMetricsAction("SelectPrevTab"));
   browser->tab_strip_model()->SelectPreviousTab();
 }
 
 void MoveTabNext(Browser* browser) {
-  content::RecordAction(UserMetricsAction("MoveTabNext"));
+  base::RecordAction(UserMetricsAction("MoveTabNext"));
   browser->tab_strip_model()->MoveTabNext();
 }
 
 void MoveTabPrevious(Browser* browser) {
-  content::RecordAction(UserMetricsAction("MoveTabPrevious"));
+  base::RecordAction(UserMetricsAction("MoveTabPrevious"));
   browser->tab_strip_model()->MoveTabPrevious();
 }
 
 void SelectNumberedTab(Browser* browser, int index) {
   if (index < browser->tab_strip_model()->count()) {
-    content::RecordAction(UserMetricsAction("SelectNumberedTab"));
+    base::RecordAction(UserMetricsAction("SelectNumberedTab"));
     browser->tab_strip_model()->ActivateTabAt(index, true);
   }
 }
 
 void SelectLastTab(Browser* browser) {
-  content::RecordAction(UserMetricsAction("SelectLastTab"));
+  base::RecordAction(UserMetricsAction("SelectLastTab"));
   browser->tab_strip_model()->SelectLastTab();
 }
 
 void DuplicateTab(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Duplicate"));
+  base::RecordAction(UserMetricsAction("Duplicate"));
   DuplicateTabAt(browser, browser->tab_strip_model()->active_index());
 }
 
 bool CanDuplicateTab(const Browser* browser) {
   return CanDuplicateTabAt(browser, browser->tab_strip_model()->active_index());
 }
 
 WebContents* DuplicateTabAt(Browser* browser, int index) {
   WebContents* contents = browser->tab_strip_model()->GetWebContentsAt(index);
   CHECK(contents);
@@ skipping 47 matching lines @@
 bool CanDuplicateTabAt(const Browser* browser, int index) {
   WebContents* contents = browser->tab_strip_model()->GetWebContentsAt(index);
   // If an interstitial is showing, do not allow tab duplication, since
   // the last committed entry is what would get duplicated and is not
   // what the user expects to duplicate.
   return contents && !contents->ShowingInterstitialPage() &&
          contents->GetController().GetLastCommittedEntry();
 }
 
 void ConvertPopupToTabbedBrowser(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ShowAsTab"));
+  base::RecordAction(UserMetricsAction("ShowAsTab"));
   TabStripModel* tab_strip = browser->tab_strip_model();
   WebContents* contents =
       tab_strip->DetachWebContentsAt(tab_strip->active_index());
   Browser* b = new Browser(Browser::CreateParams(browser->profile(), true));
   b->tab_strip_model()->AppendWebContents(contents, true);
   b->window()->Show();
 }
 
 void Exit() {
-  content::RecordAction(UserMetricsAction("Exit"));
+  base::RecordAction(UserMetricsAction("Exit"));
   chrome::AttemptUserExit();
 }
 
 void BookmarkCurrentPageIgnoringExtensionOverrides(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Star"));
+  base::RecordAction(UserMetricsAction("Star"));
 
   BookmarkModel* model =
       BookmarkModelFactory::GetForBrowserContext(browser->profile());
   if (!model || !model->loaded())
     return;  // Ignore requests until bookmarks are loaded.
 
   GURL url;
   base::string16 title;
   WebContents* web_contents =
       browser->tab_strip_model()->GetActiveWebContents();
@@ skipping 44 matching lines @@
   }
 #endif
   BookmarkCurrentPageIgnoringExtensionOverrides(browser);
 }
 
 bool CanBookmarkCurrentPage(const Browser* browser) {
   return CanBookmarkCurrentPageInternal(browser, true);
 }
 
 void BookmarkAllTabs(Browser* browser) {
-  content::RecordAction(UserMetricsAction("BookmarkAllTabs"));
+  base::RecordAction(UserMetricsAction("BookmarkAllTabs"));
   chrome::ShowBookmarkAllTabsDialog(browser);
 }
 
 bool CanBookmarkAllTabs(const Browser* browser) {
   return browser->tab_strip_model()->count() > 1 &&
              !chrome::ShouldRemoveBookmarkOpenPagesUI(browser->profile()) &&
              CanBookmarkCurrentPageInternal(browser, false);
 }
 
 void SaveCreditCard(Browser* browser) {
@@ skipping 29 matching lines @@
 void ManagePasswordsForPage(Browser* browser) {
   WebContents* web_contents =
       browser->tab_strip_model()->GetActiveWebContents();
   ManagePasswordsUIController* controller =
       ManagePasswordsUIController::FromWebContents(web_contents);
   TabDialogs::FromWebContents(web_contents)->ShowManagePasswordsBubble(
       !controller->IsAutomaticallyOpeningBubble());
 }
 
 void SavePage(Browser* browser) {
-  content::RecordAction(UserMetricsAction("SavePage"));
+  base::RecordAction(UserMetricsAction("SavePage"));
   WebContents* current_tab = browser->tab_strip_model()->GetActiveWebContents();
   if (current_tab && current_tab->GetContentsMimeType() == "application/pdf")
-    content::RecordAction(UserMetricsAction("PDF.SavePage"));
+    base::RecordAction(UserMetricsAction("PDF.SavePage"));
   current_tab->OnSavePage();
 }
 
 bool CanSavePage(const Browser* browser) {
   // LocalState can be NULL in tests.
   if (g_browser_process->local_state() &&
       !g_browser_process->local_state()->GetBoolean(
       prefs::kAllowFileSelectionDialogs)) {
     return false;
   }
@@ skipping 78 matching lines @@
       media_router::MediaRouterDialogController::GetOrCreateForWebContents(
           browser->tab_strip_model()->GetActiveWebContents());
   if (!dialog_controller)
     return;
 
   dialog_controller->ShowMediaRouterDialog();
 #endif  // defined(ENABLE_MEDIA_ROUTER)
 }
 
 void EmailPageLocation(Browser* browser) {
-  content::RecordAction(UserMetricsAction("EmailPageLocation"));
+  base::RecordAction(UserMetricsAction("EmailPageLocation"));
   WebContents* wc = browser->tab_strip_model()->GetActiveWebContents();
   DCHECK(wc);
 
   std::string title = net::EscapeQueryParamValue(
       base::UTF16ToUTF8(wc->GetTitle()), false);
   std::string page_url = net::EscapeQueryParamValue(wc->GetURL().spec(), false);
   std::string mailto = std::string("mailto:?subject=Fwd:%20") +
       title + "&body=%0A%0A" + page_url;
   platform_util::OpenExternal(browser->profile(), GURL(mailto));
 }
 
 bool CanEmailPageLocation(const Browser* browser) {
   return browser->toolbar_model()->ShouldDisplayURL() &&
       browser->tab_strip_model()->GetActiveWebContents()->GetURL().is_valid();
 }
 
 void CutCopyPaste(Browser* browser, int command_id) {
   if (command_id == IDC_CUT)
-    content::RecordAction(UserMetricsAction("Cut"));
+    base::RecordAction(UserMetricsAction("Cut"));
   else if (command_id == IDC_COPY)
-    content::RecordAction(UserMetricsAction("Copy"));
+    base::RecordAction(UserMetricsAction("Copy"));
   else
-    content::RecordAction(UserMetricsAction("Paste"));
+    base::RecordAction(UserMetricsAction("Paste"));
   browser->window()->CutCopyPaste(command_id);
 }
 
 void Find(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Find"));
+  base::RecordAction(UserMetricsAction("Find"));
   FindInPage(browser, false, false);
 }
 
 void FindNext(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FindNext"));
+  base::RecordAction(UserMetricsAction("FindNext"));
   FindInPage(browser, true, true);
 }
 
 void FindPrevious(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FindPrevious"));
+  base::RecordAction(UserMetricsAction("FindPrevious"));
   FindInPage(browser, true, false);
 }
 
 void FindInPage(Browser* browser, bool find_next, bool forward_direction) {
   ShowFindBar(browser);
   if (find_next) {
     base::string16 find_text;
     FindTabHelper* find_helper = FindTabHelper::FromWebContents(
         browser->tab_strip_model()->GetActiveWebContents());
 #if defined(OS_MACOSX)
     // We always want to search for the current contents of the find bar on
     // OS X. For regular profile it's always the current find pboard. For
     // Incognito window it's the newest value of the find pboard content and
     // user-typed text.
     FindBar* find_bar = browser->GetFindBarController()->find_bar();
     find_text = find_bar->GetFindText();
 #endif
     find_helper->StartFinding(find_text, forward_direction, false);
   }
 }
 
 void Zoom(Browser* browser, content::PageZoom zoom) {
   zoom::PageZoom::Zoom(browser->tab_strip_model()->GetActiveWebContents(),
                        zoom);
 }
 
 void FocusToolbar(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusToolbar"));
+  base::RecordAction(UserMetricsAction("FocusToolbar"));
   browser->window()->FocusToolbar();
 }
 
 void FocusLocationBar(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusLocation"));
+  base::RecordAction(UserMetricsAction("FocusLocation"));
   browser->window()->SetFocusToLocationBar(true);
 }
 
 void FocusSearch(Browser* browser) {
   // TODO(beng): replace this with FocusLocationBar
-  content::RecordAction(UserMetricsAction("FocusSearch"));
+  base::RecordAction(UserMetricsAction("FocusSearch"));
   browser->window()->GetLocationBar()->FocusSearch();
 }
 
 void FocusAppMenu(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusAppMenu"));
+  base::RecordAction(UserMetricsAction("FocusAppMenu"));
   browser->window()->FocusAppMenu();
 }
 
 void FocusBookmarksToolbar(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusBookmarksToolbar"));
+  base::RecordAction(UserMetricsAction("FocusBookmarksToolbar"));
   browser->window()->FocusBookmarksToolbar();
 }
 
 void FocusInfobars(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusInfobars"));
+  base::RecordAction(UserMetricsAction("FocusInfobars"));
   browser->window()->FocusInfobars();
 }
 
 void FocusNextPane(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusNextPane"));
+  base::RecordAction(UserMetricsAction("FocusNextPane"));
   browser->window()->RotatePaneFocus(true);
 }
 
 void FocusPreviousPane(Browser* browser) {
-  content::RecordAction(UserMetricsAction("FocusPreviousPane"));
+  base::RecordAction(UserMetricsAction("FocusPreviousPane"));
   browser->window()->RotatePaneFocus(false);
 }
 
 void ToggleDevToolsWindow(Browser* browser, DevToolsToggleAction action) {
   if (action.type() == DevToolsToggleAction::kShowConsolePanel)
-    content::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
+    base::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
   else
-    content::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
+    base::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
   DevToolsWindow::ToggleDevToolsWindow(browser, action);
 }
 
 bool CanOpenTaskManager() {
 #if !defined(OS_ANDROID)
   return true;
 #else
   return false;
 #endif
 }
 
 void OpenTaskManager(Browser* browser) {
 #if !defined(OS_ANDROID)
-  content::RecordAction(UserMetricsAction("TaskManager"));
+  base::RecordAction(UserMetricsAction("TaskManager"));
   chrome::ShowTaskManager(browser);
 #else
   NOTREACHED();
 #endif
 }
 
 void OpenFeedbackDialog(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Feedback"));
+  base::RecordAction(UserMetricsAction("Feedback"));
   chrome::ShowFeedbackPage(browser, std::string(), std::string());
 }
 
 void ToggleBookmarkBar(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ShowBookmarksBar"));
+  base::RecordAction(UserMetricsAction("ShowBookmarksBar"));
   ToggleBookmarkBarWhenVisible(browser->profile());
 }
 
 void ShowAppMenu(Browser* browser) {
   // We record the user metric for this event in AppMenu::RunMenu.
   browser->window()->ShowAppMenu();
 }
 
 void ShowAvatarMenu(Browser* browser) {
   browser->window()->ShowAvatarBubbleFromAvatarButton(
       BrowserWindow::AVATAR_BUBBLE_MODE_DEFAULT, signin::ManageAccountsParams(),
       signin_metrics::AccessPoint::ACCESS_POINT_AVATAR_BUBBLE_SIGN_IN, true);
 }
 
 void OpenUpdateChromeDialog(Browser* browser) {
   if (UpgradeDetector::GetInstance()->is_outdated_install()) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_OUTDATED_INSTALL,
         content::NotificationService::AllSources(),
         content::NotificationService::NoDetails());
   } else if (UpgradeDetector::GetInstance()->is_outdated_install_no_au()) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_OUTDATED_INSTALL_NO_AU,
         content::NotificationService::AllSources(),
         content::NotificationService::NoDetails());
   } else {
-    content::RecordAction(UserMetricsAction("UpdateChrome"));
+    base::RecordAction(UserMetricsAction("UpdateChrome"));
     browser->window()->ShowUpdateChromeDialog();
   }
 }
 
 void DistillCurrentPage(Browser* browser) {
   DistillCurrentPageAndView(browser->tab_strip_model()->GetActiveWebContents());
 }
 
 bool CanRequestTabletSite(WebContents* current_tab) {
   return current_tab &&
@@ skipping 61 matching lines @@
   if (!entry)
     return;
 
   ViewSource(browser, contents, entry->GetURL(), entry->GetPageState());
 }
 
 void ViewSource(Browser* browser,
                 WebContents* contents,
                 const GURL& url,
                 const content::PageState& page_state) {
-  content::RecordAction(UserMetricsAction("ViewSource"));
+  base::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
   WebContents* view_source_contents = contents->Clone();
   DCHECK(view_source_contents->GetController().CanPruneAllButLastCommitted());
   view_source_contents->GetController().PruneAllButLastCommitted();
   NavigationEntry* last_committed_entry =
       view_source_contents->GetController().GetLastCommittedEntry();
   if (!last_committed_entry)
     return;
 
@@ skipping 51 matching lines @@
 }
 
 bool CanViewSource(const Browser* browser) {
   return !browser->is_devtools() &&
       browser->tab_strip_model()->GetActiveWebContents()->GetController().
           CanViewSource();
 }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 void CreateApplicationShortcuts(Browser* browser) {
-  content::RecordAction(UserMetricsAction("CreateShortcut"));
+  base::RecordAction(UserMetricsAction("CreateShortcut"));
   extensions::TabHelper::FromWebContents(
       browser->tab_strip_model()->GetActiveWebContents())->
           CreateApplicationShortcuts();
 }
 
 void CreateBookmarkAppFromCurrentWebContents(Browser* browser) {
-  content::RecordAction(UserMetricsAction("CreateHostedApp"));
+  base::RecordAction(UserMetricsAction("CreateHostedApp"));
   extensions::TabHelper::FromWebContents(
       browser->tab_strip_model()->GetActiveWebContents())->
           CreateHostedAppFromWebContents();
 }
 
 bool CanCreateApplicationShortcuts(const Browser* browser) {
   return extensions::TabHelper::FromWebContents(
       browser->tab_strip_model()->GetActiveWebContents())->
           CanCreateApplicationShortcuts();
 }
@@ skipping 18 matching lines @@
       true));
   app_browser->tab_strip_model()->AppendWebContents(contents, true);
 
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->GetRenderViewHost()->SyncRendererPrefs();
   app_browser->window()->Show();
 }
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
 }  // namespace chrome