Remove the wrapper functions content::RecordAction et al

chrome/browser/ui/tabs/tab_strip_model.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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/user_metrics.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/web_contents_sizer.h"
 #include "chrome/common/url_constants.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 using base::UserMetricsAction;
 using content::WebContents;
 
 namespace {
 
 // Returns true if the specified transition is one of the types that cause the
 // opener relationships for the tab in which the transition occurred to be
 // forgotten. This is generally any navigation that isn't a link click (i.e.
@@ skipping 855 matching lines @@
       NOTREACHED();
   }
   return false;
 }
 
 void TabStripModel::ExecuteContextMenuCommand(
     int context_index, ContextMenuCommand command_id) {
   DCHECK(command_id > CommandFirst && command_id < CommandLast);
   switch (command_id) {
     case CommandNewTab:
-      content::RecordAction(UserMetricsAction("TabContextMenu_NewTab"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_NewTab"));
       UMA_HISTOGRAM_ENUMERATION("Tab.NewTab",
                                 TabStripModel::NEW_TAB_CONTEXT_MENU,
                                 TabStripModel::NEW_TAB_ENUM_COUNT);
       delegate()->AddTabAt(GURL(), context_index + 1, true);
       break;
 
     case CommandReload: {
-      content::RecordAction(UserMetricsAction("TabContextMenu_Reload"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_Reload"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       for (size_t i = 0; i < indices.size(); ++i) {
         WebContents* tab = GetWebContentsAt(indices[i]);
         if (tab) {
           CoreTabHelperDelegate* core_delegate =
               CoreTabHelper::FromWebContents(tab)->delegate();
           if (!core_delegate || core_delegate->CanReloadContents(tab))
             tab->GetController().Reload(content::ReloadType::NORMAL, true);
         }
       }
       break;
     }
 
     case CommandDuplicate: {
-      content::RecordAction(UserMetricsAction("TabContextMenu_Duplicate"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_Duplicate"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       // Copy the WebContents off as the indices will change as tabs are
       // duplicated.
       std::vector<WebContents*> tabs;
       for (size_t i = 0; i < indices.size(); ++i)
         tabs.push_back(GetWebContentsAt(indices[i]));
       for (size_t i = 0; i < tabs.size(); ++i) {
         int index = GetIndexOfWebContents(tabs[i]);
         if (index != -1 && delegate_->CanDuplicateContentsAt(index))
           delegate_->DuplicateContentsAt(index);
       }
       break;
     }
 
     case CommandCloseTab: {
-      content::RecordAction(UserMetricsAction("TabContextMenu_CloseTab"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_CloseTab"));
       InternalCloseTabs(GetIndicesForCommand(context_index),
                         CLOSE_CREATE_HISTORICAL_TAB | CLOSE_USER_GESTURE);
       break;
     }
 
     case CommandCloseOtherTabs: {
-      content::RecordAction(
-          UserMetricsAction("TabContextMenu_CloseOtherTabs"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_CloseOtherTabs"));
       InternalCloseTabs(GetIndicesClosedByCommand(context_index, command_id),
                         CLOSE_CREATE_HISTORICAL_TAB);
       break;
     }
 
     case CommandCloseTabsToRight: {
-      content::RecordAction(
-          UserMetricsAction("TabContextMenu_CloseTabsToRight"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_CloseTabsToRight"));
       InternalCloseTabs(GetIndicesClosedByCommand(context_index, command_id),
                         CLOSE_CREATE_HISTORICAL_TAB);
       break;
     }
 
     case CommandRestoreTab: {
-      content::RecordAction(UserMetricsAction("TabContextMenu_RestoreTab"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_RestoreTab"));
       delegate_->RestoreTab();
       break;
     }
 
     case CommandTogglePinned: {
-      content::RecordAction(
-          UserMetricsAction("TabContextMenu_TogglePinned"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_TogglePinned"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       bool pin = WillContextMenuPin(context_index);
       if (pin) {
         for (size_t i = 0; i < indices.size(); ++i)
           SetTabPinned(indices[i], true);
       } else {
         // Unpin from the back so that the order is maintained (unpinning can
         // trigger moving a tab).
         for (size_t i = indices.size(); i > 0; --i)
           SetTabPinned(indices[i - 1], false);
       }
       break;
     }
 
     case CommandToggleTabAudioMuted: {
       const std::vector<int>& indices = GetIndicesForCommand(context_index);
       const bool mute = !chrome::AreAllTabsMuted(*this, indices);
       if (mute)
-        content::RecordAction(UserMetricsAction("TabContextMenu_MuteTabs"));
+        base::RecordAction(UserMetricsAction("TabContextMenu_MuteTabs"));
       else
-        content::RecordAction(UserMetricsAction("TabContextMenu_UnmuteTabs"));
+        base::RecordAction(UserMetricsAction("TabContextMenu_UnmuteTabs"));
       for (std::vector<int>::const_iterator i = indices.begin();
            i != indices.end(); ++i) {
         chrome::SetTabAudioMuted(GetWebContentsAt(*i), mute,
                                  TabMutedReason::CONTEXT_MENU, std::string());
       }
       break;
     }
 
     case CommandBookmarkAllTabs: {
-      content::RecordAction(
-          UserMetricsAction("TabContextMenu_BookmarkAllTabs"));
+      base::RecordAction(UserMetricsAction("TabContextMenu_BookmarkAllTabs"));
 
       delegate_->BookmarkAllTabs();
       break;
     }
 
     case CommandSelectByDomain:
     case CommandSelectByOpener: {
       std::vector<int> indices;
       if (command_id == CommandSelectByDomain)
         GetIndicesWithSameDomain(context_index, &indices);
@@ skipping 354 matching lines @@
 
 void TabStripModel::FixOpenersAndGroupsReferencing(int index) {
   WebContents* old_contents = GetWebContentsAtImpl(index);
   for (auto& data : contents_data_) {
     if (data->group() == old_contents)
       data->set_group(contents_data_[index]->group());
     if (data->opener() == old_contents)
       data->set_opener(contents_data_[index]->opener());
   }
 }