Add UMA tracking to "Recently Closed" submenu.

chrome/browser/ui/toolbar/recent_tabs_sub_menu_model.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/toolbar/recent_tabs_sub_menu_model.h"
 
 #include "base/bind.h"
+#include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/favicon/favicon_types.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
@@ skipping 87 matching lines @@
 
 // Convert |command_id| of menu item to index in window model.
 int CommandIdToWindowModelIndex(int command_id) {
   DCHECK_GE(command_id, kFirstWindowCommandId);
   DCHECK_LT(command_id, RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId);
   return command_id - kFirstWindowCommandId;
 }
 
 }  // namepace
 
+enum RecentTabAction {
+  LOCAL_SESSION_TAB = 0,
+  OTHER_DEVICE_TAB,
+  RESTORE_WINDOW,
+  SHOW_MORE,
+  LIMIT_RECENT_TAB_ACTION
+};
+
 // An element in |RecentTabsSubMenuModel::tab_navigation_items_| that stores
 // the navigation information of a local or foreign tab required to restore the
 // tab.
 struct RecentTabsSubMenuModel::TabNavigationItem {
   TabNavigationItem() : tab_id(-1) {}
 
   TabNavigationItem(const std::string& session_tag,
                     const SessionID::id_type& tab_id,
                     const GURL& url)
       : session_tag(session_tag),
@@ skipping 66 matching lines @@
   if (command_id == kRecentlyClosedHeaderCommandId &&
       reopen_closed_tab_accelerator_.key_code() != ui::VKEY_UNKNOWN) {
     *accelerator = reopen_closed_tab_accelerator_;
     return true;
   }
   return false;
 }
 
 void RecentTabsSubMenuModel::ExecuteCommand(int command_id, int event_flags) {
   if (command_id == IDC_SHOW_HISTORY) {
+    UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", SHOW_MORE,
+                              LIMIT_RECENT_TAB_ACTION);
     // We show all "other devices" on the history page.
     chrome::ExecuteCommandWithDisposition(browser_, IDC_SHOW_HISTORY,
         ui::DispositionFromEventFlags(event_flags));
     return;
   }
 
   DCHECK_NE(kOtherDeviceHeaderCommandId, command_id);
   DCHECK_NE(IDC_RECENT_TABS_NO_DEVICE_TABS, command_id);
 
   WindowOpenDisposition disposition =
       ui::DispositionFromEventFlags(event_flags);
   if (disposition == CURRENT_TAB)  // Force to open a new foreground tab.
     disposition = NEW_FOREGROUND_TAB;
 
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
   TabRestoreServiceDelegate* delegate =
       TabRestoreServiceDelegate::FindDelegateForWebContents(
           browser_->tab_strip_model()->GetActiveWebContents());
   if (IsTabModelCommandId(command_id)) {
     int model_idx = CommandIdToTabModelIndex(command_id);
     DCHECK(model_idx >= 0 &&
            model_idx < static_cast<int>(tab_navigation_items_.size()));
     const TabNavigationItem& item = tab_navigation_items_[model_idx];
     DCHECK(item.tab_id > -1 && item.url.is_valid());
 
     if (item.session_tag.empty()) {  // Restore tab of local session.
       if (service && delegate) {
+        UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
+                                  LOCAL_SESSION_TAB, LIMIT_RECENT_TAB_ACTION);
         service->RestoreEntryById(delegate, item.tab_id,
                                   browser_->host_desktop_type(), disposition);
       }
     } else {  // Restore tab of foreign session.
       browser_sync::SessionModelAssociator* associator = GetModelAssociator();
       if (!associator)
         return;
       const SessionTab* tab;
       if (!associator->GetForeignTab(item.session_tag, item.tab_id, &tab))
         return;
       if (tab->navigations.empty())
         return;
+      UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
+                                OTHER_DEVICE_TAB, LIMIT_RECENT_TAB_ACTION);
       SessionRestore::RestoreForeignSessionTab(
           browser_->tab_strip_model()->GetActiveWebContents(),
           *tab, disposition);
     }
   } else {
     DCHECK(IsWindowModelCommandId(command_id));
     if (service && delegate) {
       int model_idx = CommandIdToWindowModelIndex(command_id);
       DCHECK(model_idx >= 0 &&
              model_idx < static_cast<int>(window_items_.size()));
+      UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", RESTORE_WINDOW,
+                                LIMIT_RECENT_TAB_ACTION);
       service->RestoreEntryById(delegate, window_items_[model_idx],
                                 browser_->host_desktop_type(), disposition);
     }
   }
 }
 
 int RecentTabsSubMenuModel::GetMaxWidthForItemAtIndex(int item_index) const {
   int command_id = GetCommandIdAt(item_index);
   if (command_id == IDC_RECENT_TABS_NO_DEVICE_TABS ||
       command_id == kRecentlyClosedHeaderCommandId) {
@@ skipping 259 matching lines @@
     RecentTabsSubMenuModel::GetModelAssociator() {
   if (!associator_) {
     ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
         GetForProfile(browser_->profile());
     // Only return the associator if it exists and it is done syncing sessions.
     if (service && service->ShouldPushChanges())
       associator_ = service->GetSessionModelAssociator();
   }
   return associator_;
 }