OLD: reland "views: change WrenchMenu to use each model's command ID's when creating MenuItemView's"

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/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.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"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/synced_session.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/toolbar/wrench_menu_model.h"
 #include "chrome/common/favicon/favicon_types.h"
 #include "chrome/common/pref_names.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/favicon_size.h"
 
 #if defined(USE_ASH)
 #include "ash/accelerators/accelerator_table.h"
 #endif  // defined(USE_ASH)
 
 namespace {
 
 // First comamnd id for navigatable (and hence executable) tab menu item.
 // The models and menu are not 1-1:
 // - menu has "Reopen closed tab", "No tabs from other devices", device section
 //   headers, separators and executable tab items.
 // - |tab_navigation_items_| only has navigatabale/executable tab items.
 // - |window_items_| only has executable open window items.
 // Using an initial command ids for tab/window items makes it easier and less
 // error-prone to manipulate the models and menu.
 // These values must be bigger than the maximum possible number of items in
 // menu, so that index of last menu item doesn't clash with this value when menu
 // items are retrieved via GetIndexOfCommandId.
-const int kFirstTabCommandId = 100;
-const int kFirstWindowCommandId = 200;
+// The range of all command ID's used in RecentTabsSubMenuModel must be between
+// WrenchMenuModel::kMinRecentTabsCommandId i.e. 1001 and 1200
+// (WrenchMenuModel::kMaxRecentTabsCommandId) inclusively.
+const int kFirstTabCommandId = WrenchMenuModel::kMinRecentTabsCommandId;
+const int kFirstWindowCommandId = 1051;
+const int kMinDeviceNameCommandId = 1100;
+const int kMaxDeviceNameCommandId = 1110;
 
 // The maximum number of recently closed entries to be shown in the menu.
 const int kMaxRecentlyClosedEntries = 8;
 
 // Comparator function for use with std::sort that will sort sessions by
 // descending modified_time (i.e., most recent first).
 bool SortSessionsByRecency(const browser_sync::SyncedSession* s1,
                            const browser_sync::SyncedSession* s2) {
   return s1->modified_time > s2->modified_time;
 }
 
 // Comparator function for use with std::sort that will sort tabs by
 // descending timestamp (i.e., most recent first).
 bool SortTabsByRecency(const SessionTab* t1, const SessionTab* t2) {
   return t1->timestamp > t2->timestamp;
 }
 
 // Returns true if the command id is related to a tab model index.
 bool IsTabModelCommandId(int command_id) {
   return command_id >= kFirstTabCommandId && command_id < kFirstWindowCommandId;
 }
 
 // Returns true if the command id is related to a window model index.
 bool IsWindowModelCommandId(int command_id) {
   return command_id >= kFirstWindowCommandId &&
          command_id < RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId;
 }
 
+bool IsDeviceNameCommandId(int command_id) {
+  return command_id >= kMinDeviceNameCommandId &&
+      command_id <= kMaxDeviceNameCommandId;
+}
+
 // Convert |tab_model_index| to command id of menu item.
 int TabModelIndexToCommandId(int tab_model_index) {
   int command_id = tab_model_index + kFirstTabCommandId;
   DCHECK_LT(command_id, kFirstWindowCommandId);
   return command_id;
 }
 
 // Convert |command_id| of menu item to index in tab model.
 int CommandIdToTabModelIndex(int command_id) {
   DCHECK_GE(command_id, kFirstTabCommandId);
@@ skipping 44 matching lines @@
   bool operator<(const TabNavigationItem& other) const {
     return url < other.url;
   }
 
   std::string session_tag;  // Empty for local tabs, non-empty for foreign tabs.
   SessionID::id_type tab_id;  // -1 for invalid, >= 0 otherwise.
   string16 title;
   GURL url;
 };
 
-const int RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId = 500;
-const int RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId = 501;
-const int RecentTabsSubMenuModel::kDeviceNameCommandId = 1000;
+const int RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId = 1120;
+const int RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId = 1121;
 
 RecentTabsSubMenuModel::RecentTabsSubMenuModel(
     ui::AcceleratorProvider* accelerator_provider,
     Browser* browser,
     browser_sync::SessionModelAssociator* associator)
     : ui::SimpleMenuModel(this),
       browser_(browser),
       associator_(associator),
       default_favicon_(ResourceBundle::GetSharedInstance().
           GetNativeImageNamed(IDR_DEFAULT_FAVICON)),
@@ skipping 23 matching lines @@
 RecentTabsSubMenuModel::~RecentTabsSubMenuModel() {
 }
 
 bool RecentTabsSubMenuModel::IsCommandIdChecked(int command_id) const {
   return false;
 }
 
 bool RecentTabsSubMenuModel::IsCommandIdEnabled(int command_id) const {
   if (command_id == kRecentlyClosedHeaderCommandId ||
       command_id == kDisabledRecentlyClosedHeaderCommandId ||
-      command_id == kDeviceNameCommandId ||
-      command_id == IDC_RECENT_TABS_NO_DEVICE_TABS) {
+      command_id == IDC_RECENT_TABS_NO_DEVICE_TABS ||
+      IsDeviceNameCommandId(command_id)) {
     return false;
   }
   return true;
 }
 
 bool RecentTabsSubMenuModel::GetAcceleratorForCommandId(
     int command_id, ui::Accelerator* accelerator) {
   // If there are no recently closed items, we show the accelerator beside
   // the header, otherwise, we show it beside the first item underneath it.
   int index_in_menu = GetIndexOfCommandId(command_id);
@@ skipping 10 matching lines @@
 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(kDeviceNameCommandId, command_id);
   DCHECK_NE(IDC_RECENT_TABS_NO_DEVICE_TABS, command_id);
+  DCHECK(!IsDeviceNameCommandId(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(
@@ skipping 36 matching lines @@
       UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", RESTORE_WINDOW,
                                 LIMIT_RECENT_TAB_ACTION);
       service->RestoreEntryById(delegate, window_items_[model_idx],
                                 browser_->host_desktop_type(), disposition);
     }
   }
 }
 
 const gfx::Font* RecentTabsSubMenuModel::GetLabelFontAt(int index) const {
   int command_id = GetCommandIdAt(index);
-  if (command_id == kDeviceNameCommandId ||
-      command_id == kRecentlyClosedHeaderCommandId) {
+  if (command_id == kRecentlyClosedHeaderCommandId ||
+      IsDeviceNameCommandId(command_id)) {
     return &ResourceBundle::GetSharedInstance().GetFont(
         ResourceBundle::BoldFont);
   }
   return NULL;
 }
 
 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 127 matching lines @@
       }
     }
     if (tabs_in_session.empty())
       continue;
     std::sort(tabs_in_session.begin(), tabs_in_session.end(),
               SortTabsByRecency);
 
     // Add the header for the device session.
     DCHECK(!session->session_name.empty());
     AddSeparator(ui::NORMAL_SEPARATOR);
-    AddItem(kDeviceNameCommandId, UTF8ToUTF16(session->session_name));
+    AddItem(kMinDeviceNameCommandId + i, UTF8ToUTF16(session->session_name));
     AddDeviceFavicon(GetItemCount() - 1, session->device_type);
 
     // Build tab menu items from sorted session tabs.
     const size_t kMaxTabsPerSessionToShow = 4;
     for (size_t k = 0;
          k < std::min(tabs_in_session.size(), kMaxTabsPerSessionToShow);
          ++k) {
       BuildForeignTabItem(session_tag, *tabs_in_session[k]);
     }  // for all tabs in one session
 
@@ skipping 136 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_;
 }