chrome/browser/ui/toolbar/recent_tabs_sub_menu_model.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/toolbar/recent_tabs_sub_menu_model.h"
   6
   7 #include "base/bind.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/prefs/scoped_user_pref_update.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/app/chrome_command_ids.h"
  13 #include "chrome/browser/favicon/favicon_service_factory.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/search/search.h"
  16 #include "chrome/browser/sessions/session_restore.h"
  17 #include "chrome/browser/sessions/tab_restore_service.h"
  18 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
  19 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  20 #include "chrome/browser/sync/glue/synced_session.h"
  21 #include "chrome/browser/sync/open_tabs_ui_delegate.h"
  22 #include "chrome/browser/sync/profile_sync_service.h"
  23 #include "chrome/browser/sync/profile_sync_service_factory.h"
  24 #include "chrome/browser/ui/browser.h"
  25 #include "chrome/browser/ui/browser_commands.h"
  26 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  27 #include "chrome/browser/ui/toolbar/wrench_menu_model.h"
  28 #include "chrome/common/pref_names.h"
  29 #include "components/favicon_base/favicon_types.h"
  30 #include "grit/browser_resources.h"
  31 #include "grit/generated_resources.h"
  32 #include "grit/theme_resources.h"
  33 #include "ui/base/accelerators/accelerator.h"
  34 #include "ui/base/l10n/l10n_util.h"
  35 #include "ui/base/resource/resource_bundle.h"
  36 #include "ui/resources/grit/ui_resources.h"
  37
  38 #if defined(USE_ASH)
  39 #include "ash/accelerators/accelerator_table.h"
  40 #endif  // defined(USE_ASH)
  41
  42 namespace {
  43
  44 // Initial comamnd ID's for navigatable (and hence executable) tab/window menu
  45 // items.  The menumodel and storage structures are not 1-1:
  46 // - menumodel has "Recently closed" header, "No tabs from other devices",
  47 //   device section headers, separators, local and other devices' tab items, and
  48 //   local window items.
  49 // - |local_tab_navigation_items_| and |other_devices_tab_navigation_items_|
  50 // only have navigatabale/executable tab items.
  51 // - |local_window_items_| only has executable open window items.
  52 // Using initial command IDs for local tab, local window and other devices' tab
  53 // items makes it easier and less error-prone to manipulate the menumodel and
  54 // storage structures.  These ids must be bigger than the maximum possible
  55 // number of items in the menumodel, so that index of the last menu item doesn't
  56 // clash with these values when menu items are retrieved via
  57 // GetIndexOfCommandId().
  58 // The range of all command ID's used in RecentTabsSubMenuModel, including the
  59 // "Recently closed" headers, must be between
  60 // |WrenchMenuModel::kMinRecentTabsCommandId| i.e. 1001 and 1200
  61 // (|WrenchMenuModel::kMaxRecentTabsCommandId|) inclusively.
  62 const int kFirstLocalTabCommandId = WrenchMenuModel::kMinRecentTabsCommandId;
  63 const int kFirstLocalWindowCommandId = 1031;
  64 const int kFirstOtherDevicesTabCommandId = 1051;
  65 const int kMinDeviceNameCommandId = 1100;
  66 const int kMaxDeviceNameCommandId = 1110;
  67
  68 // The maximum number of local recently closed entries (tab or window) to be
  69 // shown in the menu.
  70 const int kMaxLocalEntries = 8;
  71
  72 // Comparator function for use with std::sort that will sort sessions by
  73 // descending modified_time (i.e., most recent first).
  74 bool SortSessionsByRecency(const browser_sync::SyncedSession* s1,
  75                            const browser_sync::SyncedSession* s2) {
  76   return s1->modified_time > s2->modified_time;
  77 }
  78
  79 // Comparator function for use with std::sort that will sort tabs by
  80 // descending timestamp (i.e., most recent first).
  81 bool SortTabsByRecency(const SessionTab* t1, const SessionTab* t2) {
  82   return t1->timestamp > t2->timestamp;
  83 }
  84
  85 // Returns true if the command id identifies a tab menu item.
  86 bool IsTabModelCommandId(int command_id) {
  87   return ((command_id >= kFirstLocalTabCommandId &&
  88            command_id < kFirstLocalWindowCommandId) ||
  89           (command_id >= kFirstOtherDevicesTabCommandId &&
  90            command_id < kMinDeviceNameCommandId));
  91 }
  92
  93 // Returns true if the command id identifies a window menu item.
  94 bool IsWindowModelCommandId(int command_id) {
  95   return command_id >= kFirstLocalWindowCommandId &&
  96          command_id < kFirstOtherDevicesTabCommandId;
  97 }
  98
  99 bool IsDeviceNameCommandId(int command_id) {
 100   return command_id >= kMinDeviceNameCommandId &&
 101       command_id <= kMaxDeviceNameCommandId;
 102 }
 103
 104 // Convert |tab_vector_index| to command id of menu item, with
 105 // |first_command_id| as the base command id.
 106 int TabVectorIndexToCommandId(int tab_vector_index, int first_command_id) {
 107   int command_id = tab_vector_index + first_command_id;
 108   DCHECK(IsTabModelCommandId(command_id));
 109   return command_id;
 110 }
 111
 112 // Convert |window_vector_index| to command id of menu item.
 113 int WindowVectorIndexToCommandId(int window_vector_index) {
 114   int command_id = window_vector_index + kFirstLocalWindowCommandId;
 115   DCHECK(IsWindowModelCommandId(command_id));
 116   return command_id;
 117 }
 118
 119 // Convert |command_id| of menu item to index in |local_window_items_|.
 120 int CommandIdToWindowVectorIndex(int command_id) {
 121   DCHECK(IsWindowModelCommandId(command_id));
 122   return command_id - kFirstLocalWindowCommandId;
 123 }
 124
 125 }  // namespace
 126
 127 enum RecentTabAction {
 128   LOCAL_SESSION_TAB = 0,
 129   OTHER_DEVICE_TAB,
 130   RESTORE_WINDOW,
 131   SHOW_MORE,
 132   LIMIT_RECENT_TAB_ACTION
 133 };
 134
 135 // An element in |RecentTabsSubMenuModel::local_tab_navigation_items_| or
 136 // |RecentTabsSubMenuModel::other_devices_tab_navigation_items_| that stores
 137 // the navigation information of a local or other devices' tab required to
 138 // restore the tab.
 139 struct RecentTabsSubMenuModel::TabNavigationItem {
 140   TabNavigationItem() : tab_id(-1) {}
 141
 142   TabNavigationItem(const std::string& session_tag,
 143                     const SessionID::id_type& tab_id,
 144                     const base::string16& title,
 145                     const GURL& url)
 146       : session_tag(session_tag),
 147         tab_id(tab_id),
 148         title(title),
 149         url(url) {}
 150
 151   // For use by std::set for sorting.
 152   bool operator<(const TabNavigationItem& other) const {
 153     return url < other.url;
 154   }
 155
 156   // Empty for local tabs, non-empty for other devices' tabs.
 157   std::string session_tag;
 158   SessionID::id_type tab_id;  // -1 for invalid, >= 0 otherwise.
 159   base::string16 title;
 160   GURL url;
 161 };
 162
 163 const int RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId = 1120;
 164 const int RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId = 1121;
 165
 166 RecentTabsSubMenuModel::RecentTabsSubMenuModel(
 167     ui::AcceleratorProvider* accelerator_provider,
 168     Browser* browser,
 169     browser_sync::OpenTabsUIDelegate* open_tabs_delegate)
 170     : ui::SimpleMenuModel(this),
 171       browser_(browser),
 172       open_tabs_delegate_(open_tabs_delegate),
 173       last_local_model_index_(-1),
 174       default_favicon_(ui::ResourceBundle::GetSharedInstance().
 175                        GetNativeImageNamed(IDR_DEFAULT_FAVICON)),
 176       weak_ptr_factory_(this) {
 177   // Invoke asynchronous call to load tabs from local last session, which does
 178   // nothing if the tabs have already been loaded or they shouldn't be loaded.
 179   // TabRestoreServiceChanged() will be called after the tabs are loaded.
 180   TabRestoreService* service =
 181       TabRestoreServiceFactory::GetForProfile(browser_->profile());
 182   if (service) {
 183     service->LoadTabsFromLastSession();
 184
 185   // TODO(sail): enable this when mac implements the dynamic menu, together with
 186   // MenuModelDelegate::MenuStructureChanged().
 187 #if !defined(OS_MACOSX)
 188     service->AddObserver(this);
 189 #endif
 190   }
 191
 192   Build();
 193
 194   // Retrieve accelerator key for IDC_RESTORE_TAB now, because on ASH, it's not
 195   // defined in |accelerator_provider|, but in shell, so simply retrieve it now
 196   // for all ASH and non-ASH for use in |GetAcceleratorForCommandId|.
 197 #if defined(USE_ASH)
 198   for (size_t i = 0; i < ash::kAcceleratorDataLength; ++i) {
 199     const ash::AcceleratorData& accel_data = ash::kAcceleratorData[i];
 200     if (accel_data.action == ash::RESTORE_TAB) {
 201       reopen_closed_tab_accelerator_ = ui::Accelerator(accel_data.keycode,
 202                                                        accel_data.modifiers);
 203       break;
 204     }
 205   }
 206 #else
 207   if (accelerator_provider) {
 208     accelerator_provider->GetAcceleratorForCommandId(
 209         IDC_RESTORE_TAB, &reopen_closed_tab_accelerator_);
 210   }
 211 #endif  // defined(USE_ASH)
 212 }
 213
 214 RecentTabsSubMenuModel::~RecentTabsSubMenuModel() {
 215   TabRestoreService* service =
 216       TabRestoreServiceFactory::GetForProfile(browser_->profile());
 217   if (service)
 218     service->RemoveObserver(this);
 219 }
 220
 221 bool RecentTabsSubMenuModel::IsCommandIdChecked(int command_id) const {
 222   return false;
 223 }
 224
 225 bool RecentTabsSubMenuModel::IsCommandIdEnabled(int command_id) const {
 226   if (command_id == kRecentlyClosedHeaderCommandId ||
 227       command_id == kDisabledRecentlyClosedHeaderCommandId ||
 228       command_id == IDC_RECENT_TABS_NO_DEVICE_TABS ||
 229       IsDeviceNameCommandId(command_id)) {
 230     return false;
 231   }
 232   return true;
 233 }
 234
 235 bool RecentTabsSubMenuModel::GetAcceleratorForCommandId(
 236     int command_id, ui::Accelerator* accelerator) {
 237   // If there are no recently closed items, we show the accelerator beside
 238   // the header, otherwise, we show it beside the first item underneath it.
 239   int index_in_menu = GetIndexOfCommandId(command_id);
 240   int header_index = GetIndexOfCommandId(kRecentlyClosedHeaderCommandId);
 241   if ((command_id == kDisabledRecentlyClosedHeaderCommandId ||
 242        (header_index != -1 && index_in_menu == header_index + 1)) &&
 243       reopen_closed_tab_accelerator_.key_code() != ui::VKEY_UNKNOWN) {
 244     *accelerator = reopen_closed_tab_accelerator_;
 245     return true;
 246   }
 247   return false;
 248 }
 249
 250 void RecentTabsSubMenuModel::ExecuteCommand(int command_id, int event_flags) {
 251   if (command_id == IDC_SHOW_HISTORY) {
 252     UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", SHOW_MORE,
 253                               LIMIT_RECENT_TAB_ACTION);
 254     // We show all "other devices" on the history page.
 255     chrome::ExecuteCommandWithDisposition(browser_, IDC_SHOW_HISTORY,
 256         ui::DispositionFromEventFlags(event_flags));
 257     return;
 258   }
 259
 260   DCHECK_NE(IDC_RECENT_TABS_NO_DEVICE_TABS, command_id);
 261   DCHECK(!IsDeviceNameCommandId(command_id));
 262
 263   WindowOpenDisposition disposition =
 264       ui::DispositionFromEventFlags(event_flags);
 265   if (disposition == CURRENT_TAB)  // Force to open a new foreground tab.
 266     disposition = NEW_FOREGROUND_TAB;
 267
 268   TabRestoreService* service =
 269       TabRestoreServiceFactory::GetForProfile(browser_->profile());
 270   TabRestoreServiceDelegate* delegate =
 271       TabRestoreServiceDelegate::FindDelegateForWebContents(
 272           browser_->tab_strip_model()->GetActiveWebContents());
 273   if (IsTabModelCommandId(command_id)) {
 274     TabNavigationItems* tab_items = NULL;
 275     int tab_items_idx = CommandIdToTabVectorIndex(command_id, &tab_items);
 276     const TabNavigationItem& item = (*tab_items)[tab_items_idx];
 277     DCHECK(item.tab_id > -1 && item.url.is_valid());
 278
 279     if (item.session_tag.empty()) {  // Restore tab of local session.
 280       if (service && delegate) {
 281         UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
 282                                   LOCAL_SESSION_TAB, LIMIT_RECENT_TAB_ACTION);
 283         service->RestoreEntryById(delegate, item.tab_id,
 284                                   browser_->host_desktop_type(), disposition);
 285       }
 286     } else {  // Restore tab of session from other devices.
 287       browser_sync::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
 288       if (!open_tabs)
 289         return;
 290       const SessionTab* tab;
 291       if (!open_tabs->GetForeignTab(item.session_tag, item.tab_id, &tab))
 292         return;
 293       if (tab->navigations.empty())
 294         return;
 295       UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
 296                                 OTHER_DEVICE_TAB, LIMIT_RECENT_TAB_ACTION);
 297       SessionRestore::RestoreForeignSessionTab(
 298           browser_->tab_strip_model()->GetActiveWebContents(),
 299           *tab, disposition);
 300     }
 301   } else {
 302     DCHECK(IsWindowModelCommandId(command_id));
 303     if (service && delegate) {
 304       int window_items_idx = CommandIdToWindowVectorIndex(command_id);
 305       DCHECK(window_items_idx >= 0 &&
 306              window_items_idx < static_cast<int>(local_window_items_.size()));
 307       UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", RESTORE_WINDOW,
 308                                 LIMIT_RECENT_TAB_ACTION);
 309       service->RestoreEntryById(delegate, local_window_items_[window_items_idx],
 310                                 browser_->host_desktop_type(), disposition);
 311     }
 312   }
 313 }
 314
 315 int RecentTabsSubMenuModel::GetFirstRecentTabsCommandId() {
 316   return WindowVectorIndexToCommandId(0);
 317 }
 318
 319 const gfx::FontList* RecentTabsSubMenuModel::GetLabelFontListAt(
 320     int index) const {
 321   int command_id = GetCommandIdAt(index);
 322   if (command_id == kRecentlyClosedHeaderCommandId ||
 323       IsDeviceNameCommandId(command_id)) {
 324     return &ui::ResourceBundle::GetSharedInstance().GetFontList(
 325         ui::ResourceBundle::BoldFont);
 326   }
 327   return NULL;
 328 }
 329
 330 int RecentTabsSubMenuModel::GetMaxWidthForItemAtIndex(int item_index) const {
 331   int command_id = GetCommandIdAt(item_index);
 332   if (command_id == IDC_RECENT_TABS_NO_DEVICE_TABS ||
 333       command_id == kRecentlyClosedHeaderCommandId ||
 334       command_id == kDisabledRecentlyClosedHeaderCommandId) {
 335     return -1;
 336   }
 337   return 320;
 338 }
 339
 340 bool RecentTabsSubMenuModel::GetURLAndTitleForItemAtIndex(
 341     int index,
 342     std::string* url,
 343     base::string16* title) {
 344   int command_id = GetCommandIdAt(index);
 345   if (IsTabModelCommandId(command_id)) {
 346     TabNavigationItems* tab_items = NULL;
 347     int tab_items_idx = CommandIdToTabVectorIndex(command_id, &tab_items);
 348     const TabNavigationItem& item = (*tab_items)[tab_items_idx];
 349     *url = item.url.possibly_invalid_spec();
 350     *title = item.title;
 351     return true;
 352   }
 353   return false;
 354 }
 355
 356 void RecentTabsSubMenuModel::Build() {
 357   // The menu contains:
 358   // - Recently closed header, then list of local recently closed tabs/windows,
 359   //   then separator
 360   // - device 1 section header, then list of tabs from device, then separator
 361   // - device 2 section header, then list of tabs from device, then separator
 362   // - device 3 section header, then list of tabs from device, then separator
 363   // - More... to open the history tab to get more other devices.
 364   // |local_tab_navigation_items_| and |other_devices_tab_navigation_items_|
 365   // only contain navigatable (and hence executable) tab items for local
 366   // recently closed tabs and tabs from other devices respectively.
 367   // |local_window_items_| contains the local recently closed windows.
 368   BuildLocalEntries();
 369   BuildTabsFromOtherDevices();
 370 }
 371
 372 void RecentTabsSubMenuModel::BuildLocalEntries() {
 373   // All local items use InsertItem*At() to append or insert a menu item.
 374   // We're appending if building the entries for the first time i.e. invoked
 375   // from Constructor(), inserting when local entries change subsequently i.e.
 376   // invoked from TabRestoreServiceChanged().
 377
 378   DCHECK_EQ(last_local_model_index_, -1);
 379
 380   TabRestoreService* service =
 381       TabRestoreServiceFactory::GetForProfile(browser_->profile());
 382   if (!service || service->entries().size() == 0) {
 383     // This is to show a disabled restore tab entry with the accelerator to
 384     // teach users about this command.
 385     InsertItemWithStringIdAt(++last_local_model_index_,
 386                              kDisabledRecentlyClosedHeaderCommandId,
 387                              IDS_NEW_TAB_RECENTLY_CLOSED);
 388   } else {
 389     InsertItemWithStringIdAt(++last_local_model_index_,
 390                              kRecentlyClosedHeaderCommandId,
 391                              IDS_NEW_TAB_RECENTLY_CLOSED);
 392     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 393     SetIcon(last_local_model_index_,
 394             rb.GetNativeImageNamed(IDR_RECENTLY_CLOSED_WINDOW));
 395
 396     int added_count = 0;
 397     TabRestoreService::Entries entries = service->entries();
 398     for (TabRestoreService::Entries::const_iterator it = entries.begin();
 399          it != entries.end() && added_count < kMaxLocalEntries; ++it) {
 400       TabRestoreService::Entry* entry = *it;
 401       if (entry->type == TabRestoreService::TAB) {
 402         TabRestoreService::Tab* tab =
 403             static_cast<TabRestoreService::Tab*>(entry);
 404         const sessions::SerializedNavigationEntry& current_navigation =
 405             tab->navigations.at(tab->current_navigation_index);
 406         BuildLocalTabItem(
 407             entry->id,
 408             current_navigation.title(),
 409             current_navigation.virtual_url(),
 410             ++last_local_model_index_);
 411       } else  {
 412         DCHECK_EQ(entry->type, TabRestoreService::WINDOW);
 413         BuildLocalWindowItem(
 414             entry->id,
 415             static_cast<TabRestoreService::Window*>(entry)->tabs.size(),
 416             ++last_local_model_index_);
 417       }
 418       ++added_count;
 419     }
 420   }
 421
 422   DCHECK_GE(last_local_model_index_, 0);
 423 }
 424
 425 void RecentTabsSubMenuModel::BuildTabsFromOtherDevices() {
 426   // All other devices' items (device headers or tabs) use AddItem*() to append
 427   // a menu item, because they are always only built once (i.e. invoked from
 428   // Constructor()) and don't change after that.
 429
 430   browser_sync::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
 431   std::vector<const browser_sync::SyncedSession*> sessions;
 432   if (!open_tabs || !open_tabs->GetAllForeignSessions(&sessions)) {
 433     AddSeparator(ui::NORMAL_SEPARATOR);
 434     AddItemWithStringId(IDC_RECENT_TABS_NO_DEVICE_TABS,
 435                         IDS_RECENT_TABS_NO_DEVICE_TABS);
 436     return;
 437   }
 438
 439   // Sort sessions from most recent to least recent.
 440   std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency);
 441
 442   const size_t kMaxSessionsToShow = 3;
 443   size_t num_sessions_added = 0;
 444   for (size_t i = 0;
 445        i < sessions.size() && num_sessions_added < kMaxSessionsToShow; ++i) {
 446     const browser_sync::SyncedSession* session = sessions[i];
 447     const std::string& session_tag = session->session_tag;
 448
 449     // Get windows of session.
 450     std::vector<const SessionWindow*> windows;
 451     if (!open_tabs->GetForeignSession(session_tag, &windows) ||
 452         windows.empty()) {
 453       continue;
 454     }
 455
 456     // Collect tabs from all windows of session, pruning those that are not
 457     // syncable or are NewTabPage, then sort them from most recent to least
 458     // recent, independent of which window the tabs were from.
 459     std::vector<const SessionTab*> tabs_in_session;
 460     for (size_t j = 0; j < windows.size(); ++j) {
 461       const SessionWindow* window = windows[j];
 462       for (size_t t = 0; t < window->tabs.size(); ++t) {
 463         const SessionTab* tab = window->tabs[t];
 464         if (tab->navigations.empty())
 465           continue;
 466         const sessions::SerializedNavigationEntry& current_navigation =
 467             tab->navigations.at(tab->normalized_navigation_index());
 468         if (chrome::IsNTPURL(current_navigation.virtual_url(),
 469                              browser_->profile())) {
 470           continue;
 471         }
 472         tabs_in_session.push_back(tab);
 473       }
 474     }
 475     if (tabs_in_session.empty())
 476       continue;
 477     std::sort(tabs_in_session.begin(), tabs_in_session.end(),
 478               SortTabsByRecency);
 479
 480     // Add the header for the device session.
 481     DCHECK(!session->session_name.empty());
 482     AddSeparator(ui::NORMAL_SEPARATOR);
 483     int command_id = kMinDeviceNameCommandId + i;
 484     DCHECK_LE(command_id, kMaxDeviceNameCommandId);
 485     AddItem(command_id, base::UTF8ToUTF16(session->session_name));
 486     AddDeviceFavicon(GetItemCount() - 1, session->device_type);
 487
 488     // Build tab menu items from sorted session tabs.
 489     const size_t kMaxTabsPerSessionToShow = 4;
 490     for (size_t k = 0;
 491          k < std::min(tabs_in_session.size(), kMaxTabsPerSessionToShow);
 492          ++k) {
 493       BuildOtherDevicesTabItem(session_tag, *tabs_in_session[k]);
 494     }  // for all tabs in one session
 495
 496     ++num_sessions_added;
 497   }  // for all sessions
 498
 499   // We are not supposed to get here unless at least some items were added.
 500   DCHECK_GT(GetItemCount(), 0);
 501   AddSeparator(ui::NORMAL_SEPARATOR);
 502   AddItemWithStringId(IDC_SHOW_HISTORY, IDS_RECENT_TABS_MORE);
 503 }
 504
 505 void RecentTabsSubMenuModel::BuildLocalTabItem(int session_id,
 506                                                const base::string16& title,
 507                                                const GURL& url,
 508                                                int curr_model_index) {
 509   TabNavigationItem item(std::string(), session_id, title, url);
 510   int command_id = TabVectorIndexToCommandId(
 511       local_tab_navigation_items_.size(), kFirstLocalTabCommandId);
 512   // See comments in BuildLocalEntries() about usage of InsertItem*At().
 513   // There may be no tab title, in which case, use the url as tab title.
 514   InsertItemAt(curr_model_index, command_id,
 515                title.empty() ? base::UTF8ToUTF16(item.url.spec()) : title);
 516   AddTabFavicon(command_id, item.url);
 517   local_tab_navigation_items_.push_back(item);
 518 }
 519
 520 void RecentTabsSubMenuModel::BuildLocalWindowItem(
 521     const SessionID::id_type& window_id,
 522     int num_tabs,
 523     int curr_model_index) {
 524   int command_id = WindowVectorIndexToCommandId(local_window_items_.size());
 525   // See comments in BuildLocalEntries() about usage of InsertItem*At().
 526   if (num_tabs == 1) {
 527     InsertItemWithStringIdAt(curr_model_index, command_id,
 528                              IDS_NEW_TAB_RECENTLY_CLOSED_WINDOW_SINGLE);
 529   } else {
 530     InsertItemAt(curr_model_index, command_id, l10n_util::GetStringFUTF16(
 531         IDS_NEW_TAB_RECENTLY_CLOSED_WINDOW_MULTIPLE,
 532         base::IntToString16(num_tabs)));
 533   }
 534   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 535   SetIcon(curr_model_index, rb.GetNativeImageNamed(IDR_RECENTLY_CLOSED_WINDOW));
 536   local_window_items_.push_back(window_id);
 537 }
 538
 539 void RecentTabsSubMenuModel::BuildOtherDevicesTabItem(
 540     const std::string& session_tag,
 541     const SessionTab& tab) {
 542   const sessions::SerializedNavigationEntry& current_navigation =
 543       tab.navigations.at(tab.normalized_navigation_index());
 544   TabNavigationItem item(session_tag, tab.tab_id.id(),
 545                          current_navigation.title(),
 546                          current_navigation.virtual_url());
 547   int command_id = TabVectorIndexToCommandId(
 548       other_devices_tab_navigation_items_.size(),
 549       kFirstOtherDevicesTabCommandId);
 550   // See comments in BuildTabsFromOtherDevices() about usage of AddItem*().
 551   // There may be no tab title, in which case, use the url as tab title.
 552   AddItem(command_id,
 553           current_navigation.title().empty() ?
 554               base::UTF8ToUTF16(item.url.spec()) : current_navigation.title());
 555   AddTabFavicon(command_id, item.url);
 556   other_devices_tab_navigation_items_.push_back(item);
 557 }
 558
 559 void RecentTabsSubMenuModel::AddDeviceFavicon(
 560     int index_in_menu,
 561     browser_sync::SyncedSession::DeviceType device_type) {
 562   int favicon_id = -1;
 563   switch (device_type) {
 564     case browser_sync::SyncedSession::TYPE_PHONE:
 565       favicon_id = IDR_PHONE_FAVICON;
 566       break;
 567
 568     case browser_sync::SyncedSession::TYPE_TABLET:
 569       favicon_id = IDR_TABLET_FAVICON;
 570       break;
 571
 572     case browser_sync::SyncedSession::TYPE_CHROMEOS:
 573     case browser_sync::SyncedSession::TYPE_WIN:
 574     case browser_sync::SyncedSession::TYPE_MACOSX:
 575     case browser_sync::SyncedSession::TYPE_LINUX:
 576     case browser_sync::SyncedSession::TYPE_OTHER:
 577     case browser_sync::SyncedSession::TYPE_UNSET:
 578       favicon_id = IDR_LAPTOP_FAVICON;
 579       break;
 580   }
 581
 582   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 583   SetIcon(index_in_menu, rb.GetNativeImageNamed(favicon_id));
 584 }
 585
 586 void RecentTabsSubMenuModel::AddTabFavicon(int command_id, const GURL& url) {
 587   bool is_local_tab = command_id < kFirstOtherDevicesTabCommandId;
 588   int index_in_menu = GetIndexOfCommandId(command_id);
 589
 590   if (!is_local_tab) {
 591     // If tab has synced favicon, use it.
 592     // Note that currently, other devices' tabs only have favicons if
 593     // --sync-tab-favicons switch is on; according to zea@, this flag is now
 594     // automatically enabled for iOS and android, and they're looking into
 595     // enabling it for other platforms.
 596     browser_sync::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
 597     scoped_refptr<base::RefCountedMemory> favicon_png;
 598     if (open_tabs &&
 599         open_tabs->GetSyncedFaviconForPageURL(url.spec(), &favicon_png)) {
 600       gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(favicon_png);
 601       SetIcon(index_in_menu, image);
 602       return;
 603     }
 604   }
 605
 606   // Otherwise, start to fetch the favicon from local history asynchronously.
 607   // Set default icon first.
 608   SetIcon(index_in_menu, default_favicon_);
 609   // Start request to fetch actual icon if possible.
 610   FaviconService* favicon_service = FaviconServiceFactory::GetForProfile(
 611       browser_->profile(), Profile::EXPLICIT_ACCESS);
 612   if (!favicon_service)
 613     return;
 614
 615   favicon_service->GetFaviconImageForPageURL(
 616       url,
 617       base::Bind(&RecentTabsSubMenuModel::OnFaviconDataAvailable,
 618                  weak_ptr_factory_.GetWeakPtr(),
 619                  command_id),
 620       is_local_tab ? &local_tab_cancelable_task_tracker_
 621                    : &other_devices_tab_cancelable_task_tracker_);
 622 }
 623
 624 void RecentTabsSubMenuModel::OnFaviconDataAvailable(
 625     int command_id,
 626     const favicon_base::FaviconImageResult& image_result) {
 627   if (image_result.image.IsEmpty())
 628     return;
 629   int index_in_menu = GetIndexOfCommandId(command_id);
 630   DCHECK_GT(index_in_menu, -1);
 631   SetIcon(index_in_menu, image_result.image);
 632   ui::MenuModelDelegate* menu_model_delegate = GetMenuModelDelegate();
 633   if (menu_model_delegate)
 634     menu_model_delegate->OnIconChanged(index_in_menu);
 635 }
 636
 637 int RecentTabsSubMenuModel::CommandIdToTabVectorIndex(
 638     int command_id,
 639     TabNavigationItems** tab_items) {
 640   DCHECK(IsTabModelCommandId(command_id));
 641   if (command_id >= kFirstOtherDevicesTabCommandId) {
 642     *tab_items = &other_devices_tab_navigation_items_;
 643     return command_id - kFirstOtherDevicesTabCommandId;
 644   }
 645   *tab_items = &local_tab_navigation_items_;
 646   return command_id - kFirstLocalTabCommandId;
 647 }
 648
 649 void RecentTabsSubMenuModel::ClearLocalEntries() {
 650   // Remove local items (recently closed tabs and windows) from menumodel.
 651   while (last_local_model_index_ >= 0)
 652     RemoveItemAt(last_local_model_index_--);
 653
 654   // Cancel asynchronous FaviconService::GetFaviconImageForPageURL() tasks of
 655   // all
 656   // local tabs.
 657   local_tab_cancelable_task_tracker_.TryCancelAll();
 658
 659   // Remove all local tab navigation items.
 660   local_tab_navigation_items_.clear();
 661
 662   // Remove all local window items.
 663   local_window_items_.clear();
 664 }
 665
 666 browser_sync::OpenTabsUIDelegate*
 667     RecentTabsSubMenuModel::GetOpenTabsUIDelegate() {
 668   if (!open_tabs_delegate_) {
 669     ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
 670         GetForProfile(browser_->profile());
 671     // Only return the delegate if it exists and it is done syncing sessions.
 672     if (service && service->ShouldPushChanges())
 673       open_tabs_delegate_ = service->GetOpenTabsUIDelegate();
 674   }
 675   return open_tabs_delegate_;
 676 }
 677
 678 void RecentTabsSubMenuModel::TabRestoreServiceChanged(
 679     TabRestoreService* service) {
 680   ClearLocalEntries();
 681
 682   BuildLocalEntries();
 683
 684   ui::MenuModelDelegate* menu_model_delegate = GetMenuModelDelegate();
 685   if (menu_model_delegate)
 686     menu_model_delegate->OnMenuStructureChanged();
 687 }
 688
 689 void RecentTabsSubMenuModel::TabRestoreServiceDestroyed(
 690     TabRestoreService* service) {
 691   TabRestoreServiceChanged(service);
 692 }