Remove the wrapper functions content::RecordAction et al

chrome/browser/ui/chrome_pages.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 "chrome/browser/ui/chrome_pages.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/metrics/user_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/browser/ui/settings_window_manager.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/options/content_settings_handler.h"
 #include "chrome/browser/ui/webui/site_settings_helper.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "components/signin/core/browser/signin_header_helper.h"
 #include "components/signin/core/common/profile_management_switches.h"
-#include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/url_util.h"
 #include "ui/base/window_open_disposition.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/win/enumerate_modules_model.h"
 #endif
@@ skipping 15 matching lines @@
 using base::UserMetricsAction;
 
 namespace chrome {
 namespace {
 
 const char kHashMark[] = "#";
 
 void OpenBookmarkManagerWithHash(Browser* browser,
                                  const std::string& action,
                                  int64_t node_id) {
-  content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
-  content::RecordAction(UserMetricsAction("ShowBookmarks"));
+  base::RecordAction(UserMetricsAction("ShowBookmarkManager"));
+  base::RecordAction(UserMetricsAction("ShowBookmarks"));
   NavigateParams params(GetSingletonTabNavigateParams(
       browser,
       GURL(kChromeUIBookmarksURL).Resolve(base::StringPrintf(
           "/#%s%s", action.c_str(), base::Int64ToString(node_id).c_str()))));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void NavigateToSingletonTab(Browser* browser, const GURL& url) {
   NavigateParams params(GetSingletonTabNavigateParams(browser, url));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 // Shows either the help app or the appropriate help page for |source|. If
 // |browser| is NULL and the help page is used (vs the app), the help page is
 // shown in the last active browser. If there is no such browser, a new browser
 // is created.
 void ShowHelpImpl(Browser* browser, Profile* profile, HelpSource source) {
-  content::RecordAction(UserMetricsAction("ShowHelpTab"));
+  base::RecordAction(UserMetricsAction("ShowHelpTab"));
 #if defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD)
   const extensions::Extension* extension =
       extensions::ExtensionRegistry::Get(profile)->GetExtensionById(
           genius_app::kGeniusAppId,
           extensions::ExtensionRegistry::EVERYTHING);
   extensions::AppLaunchSource app_launch_source(extensions::SOURCE_UNTRACKED);
   switch (source) {
     case HELP_SOURCE_KEYBOARD:
       app_launch_source = extensions::SOURCE_KEYBOARD;
       break;
@@ skipping 71 matching lines @@
 #if defined(OS_CHROMEOS)
 std::string GenerateContentSettingsSearchQueryPath(int query_message_id) {
   return std::string(chrome::kDeprecatedOptionsSearchSubPage) + kHashMark +
          l10n_util::GetStringUTF8(query_message_id);
 }
 #endif
 
 }  // namespace
 
 void ShowBookmarkManager(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
-  content::RecordAction(UserMetricsAction("ShowBookmarks"));
+  base::RecordAction(UserMetricsAction("ShowBookmarkManager"));
+  base::RecordAction(UserMetricsAction("ShowBookmarks"));
   ShowSingletonTabOverwritingNTP(
       browser,
       GetSingletonTabNavigateParams(browser, GURL(kChromeUIBookmarksURL)));
 }
 
 void ShowBookmarkManagerForNode(Browser* browser, int64_t node_id) {
   OpenBookmarkManagerWithHash(browser, std::string(), node_id);
 }
 
 void ShowHistory(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ShowHistory"));
+  base::RecordAction(UserMetricsAction("ShowHistory"));
   NavigateParams params(
       GetSingletonTabNavigateParams(browser, GURL(kChromeUIHistoryURL)));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void ShowDownloads(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ShowDownloads"));
+  base::RecordAction(UserMetricsAction("ShowDownloads"));
   if (browser->window() && browser->window()->IsDownloadShelfVisible())
     browser->window()->GetDownloadShelf()->Close(DownloadShelf::USER_ACTION);
 
   ShowSingletonTabOverwritingNTP(
       browser,
       GetSingletonTabNavigateParams(browser, GURL(kChromeUIDownloadsURL)));
 }
 
 void ShowExtensions(Browser* browser,
                     const std::string& extension_to_highlight) {
-  content::RecordAction(UserMetricsAction("ShowExtensions"));
+  base::RecordAction(UserMetricsAction("ShowExtensions"));
   NavigateParams params(
       GetSingletonTabNavigateParams(browser, GURL(kChromeUIExtensionsURL)));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   if (!extension_to_highlight.empty()) {
     GURL::Replacements replacements;
     std::string query("id=");
     query += extension_to_highlight;
     replacements.SetQueryStr(query);
     params.url = params.url.ReplaceComponents(replacements);
   }
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void ShowConflicts(Browser* browser) {
 #if defined(OS_WIN)
   EnumerateModulesModel* model = EnumerateModulesModel::GetInstance();
   GURL conflict_url = model->GetConflictUrl();
   if (conflict_url.is_valid()) {
     ShowSingletonTab(browser, conflict_url);
     model->AcknowledgeConflictNotification();
     return;
   }
 #endif
 
-  content::RecordAction(UserMetricsAction("AboutConflicts"));
+  base::RecordAction(UserMetricsAction("AboutConflicts"));
   ShowSingletonTab(browser, GURL(kChromeUIConflictsURL));
 }
 
 void ShowHelp(Browser* browser, HelpSource source) {
   ShowHelpImpl(browser, browser->profile(), source);
 }
 
 void ShowHelpForProfile(Profile* profile, HelpSource source) {
   ShowHelpImpl(NULL, profile, source);
 }
@@ skipping 68 matching lines @@
   } else {
     if (sub_page == chrome::kPowerSubPage) {
       // TODO(stevenjbj/derat): Remove this once we have a 'power' subpage,
       // crbug.com/633455.
       sub_page_path = "device";
     }
   }
 #endif
 
   if (::switches::SettingsWindowEnabled()) {
-    content::RecordAction(base::UserMetricsAction("ShowOptions"));
+    base::RecordAction(base::UserMetricsAction("ShowOptions"));
     SettingsWindowManager::GetInstance()->ShowChromePageForProfile(
         profile, GetSettingsUrl(sub_page_path));
     return;
   }
   Browser* browser = chrome::FindTabbedBrowser(profile, false);
   if (!browser) {
     browser = new Browser(Browser::CreateParams(profile, true));
   }
   ShowSettingsSubPageInTabbedBrowser(browser, sub_page_path);
 }
 
 void ShowSettingsSubPageInTabbedBrowser(Browser* browser,
                                         const std::string& sub_page) {
-  content::RecordAction(UserMetricsAction("ShowOptions"));
+  base::RecordAction(UserMetricsAction("ShowOptions"));
   GURL gurl = GetSettingsUrl(sub_page);
   NavigateParams params(GetSingletonTabNavigateParams(browser, gurl));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void ShowContentSettingsExceptions(Browser* browser,
                                    ContentSettingsType content_settings_type) {
   ShowSettingsSubPage(
       browser, GenerateContentSettingsExceptionsSubPage(content_settings_type));
 }
 
 void ShowContentSettingsExceptionsInWindow(
     Profile* profile,
     ContentSettingsType content_settings_type) {
   DCHECK(switches::SettingsWindowEnabled());
   ShowSettingsSubPageForProfile(
       profile, GenerateContentSettingsExceptionsSubPage(content_settings_type));
 }
 
 void ShowContentSettings(Browser* browser,
                          ContentSettingsType content_settings_type) {
   ShowSettingsSubPage(
       browser,
       kContentSettingsSubPage + std::string(kHashMark) +
           site_settings::ContentSettingsTypeToGroupName(content_settings_type));
 }
 
 void ShowClearBrowsingDataDialog(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg"));
+  base::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg"));
   ShowSettingsSubPage(browser, kClearBrowserDataSubPage);
 }
 
 void ShowPasswordManager(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Options_ShowPasswordManager"));
+  base::RecordAction(UserMetricsAction("Options_ShowPasswordManager"));
   ShowSettingsSubPage(browser, kPasswordManagerSubPage);
 }
 
 void ShowImportDialog(Browser* browser) {
-  content::RecordAction(UserMetricsAction("Import_ShowDlg"));
+  base::RecordAction(UserMetricsAction("Import_ShowDlg"));
   ShowSettingsSubPage(browser, kImportDataSubPage);
 }
 
 void ShowAboutChrome(Browser* browser) {
-  content::RecordAction(UserMetricsAction("AboutChrome"));
+  base::RecordAction(UserMetricsAction("AboutChrome"));
   if (::switches::SettingsWindowEnabled()) {
     SettingsWindowManager::GetInstance()->ShowChromePageForProfile(
         browser->profile(), GURL(kChromeUIHelpURL));
     return;
   }
   NavigateParams params(
       GetSingletonTabNavigateParams(browser, GURL(kChromeUIHelpURL)));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void ShowSearchEngineSettings(Browser* browser) {
-  content::RecordAction(UserMetricsAction("EditSearchEngines"));
+  base::RecordAction(UserMetricsAction("EditSearchEngines"));
   ShowSettingsSubPage(browser, kSearchEnginesSubPage);
 }
 
 #if !defined(OS_ANDROID)
 void ShowBrowserSignin(Browser* browser,
                        signin_metrics::AccessPoint access_point) {
   Profile* original_profile = browser->profile()->GetOriginalProfile();
   SigninManagerBase* manager =
       SigninManagerFactory::GetForProfile(original_profile);
   DCHECK(manager->IsSigninAllowed());
@@ skipping 41 matching lines @@
       SigninManagerFactory::GetForProfile(original_profile);
   DCHECK(manager->IsSigninAllowed());
   if (manager->IsAuthenticated())
     ShowSettings(browser);
   else
     ShowBrowserSignin(browser, access_point);
 }
 #endif
 
 }  // namespace chrome