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

chrome/browser/tabs/tab_strip_model.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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
-#include "content/browser/user_metrics.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/browser/user_metrics.h"
+
+using content::UserMetricsAction;
 
 namespace {
 
 // Returns true if the specified transition is one of the types that cause the
 // opener relationships for the tab in which the transition occured to be
 // forgotten. This is generally any navigation that isn't a link click (i.e.
 // any navigation that can be considered to be the start of a new task distinct
 // from what had previously occurred in that tab).
 bool ShouldForgetOpenersForTransition(content::PageTransition transition) {
   return transition == content::PAGE_TRANSITION_TYPED ||
@@ skipping 781 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:
-      UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_NewTab"));
+      content::RecordAction(UserMetricsAction("TabContextMenu_NewTab"));
       delegate()->AddBlankTabAt(context_index + 1, true);
       break;
 
     case CommandReload: {
-      UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_Reload"));
+      content::RecordAction(UserMetricsAction("TabContextMenu_Reload"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       for (size_t i = 0; i < indices.size(); ++i) {
         TabContentsWrapper* tab = GetTabContentsAt(indices[i]);
         if (tab && tab->tab_contents()->delegate()->CanReloadContents(
                 tab->tab_contents())) {
           tab->tab_contents()->controller().Reload(true);
         }
       }
       break;
     }
 
     case CommandDuplicate: {
-      UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_Duplicate"));
+      content::RecordAction(UserMetricsAction("TabContextMenu_Duplicate"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       // Copy the TabContents off as the indices will change as tabs are
       // duplicated.
       std::vector<TabContentsWrapper*> tabs;
       for (size_t i = 0; i < indices.size(); ++i)
         tabs.push_back(GetTabContentsAt(indices[i]));
       for (size_t i = 0; i < tabs.size(); ++i) {
         int index = GetIndexOfTabContents(tabs[i]);
         if (index != -1 && delegate_->CanDuplicateContentsAt(index))
           delegate_->DuplicateContentsAt(index);
       }
       break;
     }
 
     case CommandCloseTab: {
-      UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_CloseTab"));
+      content::RecordAction(UserMetricsAction("TabContextMenu_CloseTab"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       // Copy the TabContents off as the indices will change as we remove
       // things.
       std::vector<TabContentsWrapper*> tabs;
       for (size_t i = 0; i < indices.size(); ++i)
         tabs.push_back(GetTabContentsAt(indices[i]));
       for (size_t i = 0; i < tabs.size() && delegate_->CanCloseTab(); ++i) {
         int index = GetIndexOfTabContents(tabs[i]);
         if (index != -1) {
           CloseTabContentsAt(index,
                              CLOSE_CREATE_HISTORICAL_TAB | CLOSE_USER_GESTURE);
         }
       }
       break;
     }
 
     case CommandCloseOtherTabs: {
-      UserMetrics::RecordAction(
+      content::RecordAction(
           UserMetricsAction("TabContextMenu_CloseOtherTabs"));
       InternalCloseTabs(GetIndicesClosedByCommand(context_index, command_id),
                         CLOSE_CREATE_HISTORICAL_TAB);
       break;
     }
 
     case CommandCloseTabsToRight: {
-      UserMetrics::RecordAction(
+      content::RecordAction(
           UserMetricsAction("TabContextMenu_CloseTabsToRight"));
       InternalCloseTabs(GetIndicesClosedByCommand(context_index, command_id),
                         CLOSE_CREATE_HISTORICAL_TAB);
       break;
     }
 
     case CommandRestoreTab: {
-      UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_RestoreTab"));
+      content::RecordAction(UserMetricsAction("TabContextMenu_RestoreTab"));
       delegate_->RestoreTab();
       break;
     }
 
     case CommandTogglePinned: {
-      UserMetrics::RecordAction(
+      content::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) {
           if (!IsAppTab(indices[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) {
           if (!IsAppTab(indices[i - 1]))
             SetTabPinned(indices[i - 1], false);
         }
       }
       break;
     }
 
     case CommandBookmarkAllTabs: {
-      UserMetrics::RecordAction(
+      content::RecordAction(
           UserMetricsAction("TabContextMenu_BookmarkAllTabs"));
 
       delegate_->BookmarkAllTabs();
       break;
     }
 
     case CommandSelectByDomain:
     case CommandSelectByOpener: {
       std::vector<int> indices;
       if (command_id == CommandSelectByDomain)
@@ skipping 379 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     const NavigationController* tab) {
   for (TabContentsDataVector::const_iterator i = contents_data_.begin();
        i != contents_data_.end(); ++i) {
     if ((*i)->group == tab)
       (*i)->group = NULL;
     if ((*i)->opener == tab)
       (*i)->opener = NULL;
   }
 }