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/strings/string_number_conversions.h" 10 #include "base/strings/utf_string_conversions.h" 11 #include "chrome/app/chrome_command_ids.h" 12 #include "chrome/browser/favicon/favicon_service_factory.h" 13 #include "chrome/browser/prefs/scoped_user_pref_update.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/session_model_associator.h" 21 #include "chrome/browser/sync/glue/synced_session.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/common/favicon/favicon_types.h" 28 #include "chrome/common/pref_names.h" 29 #include "grit/browser_resources.h" 30 #include "grit/generated_resources.h" 31 #include "grit/theme_resources.h" 32 #include "grit/ui_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/gfx/favicon_size.h" 37 38 #if defined(USE_ASH) 39 #include "ash/accelerators/accelerator_table.h" 40 #endif // defined(USE_ASH) 41 42 namespace { 43 44 // First comamnd id for navigatable (and hence executable) tab menu item. 45 // The models and menu are not 1-1: 46 // - menu has "Reopen closed tab", "No tabs from other devices", device section 47 // headers, separators and executable tab items. 48 // - |tab_navigation_items_| only has navigatabale/executable tab items. 49 // - |window_items_| only has executable open window items. 50 // Using an initial command ids for tab/window items makes it easier and less 51 // error-prone to manipulate the models and menu. 52 // These values must be bigger than the maximum possible number of items in 53 // menu, so that index of last menu item doesn't clash with this value when menu 54 // items are retrieved via GetIndexOfCommandId. 55 const int kFirstTabCommandId = 100; 56 const int kFirstWindowCommandId = 200; 57 58 // The maximum number of recently closed entries to be shown in the menu. 59 const int kMaxRecentlyClosedEntries = 8; 60 61 // Comparator function for use with std::sort that will sort sessions by 62 // descending modified_time (i.e., most recent first). 63 bool SortSessionsByRecency(const browser_sync::SyncedSession* s1, 64 const browser_sync::SyncedSession* s2) { 65 return s1->modified_time > s2->modified_time; 66 } 67 68 // Comparator function for use with std::sort that will sort tabs by 69 // descending timestamp (i.e., most recent first). 70 bool SortTabsByRecency(const SessionTab* t1, const SessionTab* t2) { 71 return t1->timestamp > t2->timestamp; 72 } 73 74 // Returns true if the command id is related to a tab model index. 75 bool IsTabModelCommandId(int command_id) { 76 return command_id >= kFirstTabCommandId && command_id < kFirstWindowCommandId; 77 } 78 79 // Returns true if the command id is related to a window model index. 80 bool IsWindowModelCommandId(int command_id) { 81 return command_id >= kFirstWindowCommandId && 82 command_id < RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId; 83 } 84 85 // Convert |tab_model_index| to command id of menu item. 86 int TabModelIndexToCommandId(int tab_model_index) { 87 int command_id = tab_model_index + kFirstTabCommandId; 88 DCHECK_LT(command_id, kFirstWindowCommandId); 89 return command_id; 90 } 91 92 // Convert |command_id| of menu item to index in tab model. 93 int CommandIdToTabModelIndex(int command_id) { 94 DCHECK_GE(command_id, kFirstTabCommandId); 95 DCHECK_LT(command_id, kFirstWindowCommandId); 96 return command_id - kFirstTabCommandId; 97 } 98 99 // Convert |window_model_index| to command id of menu item. 100 int WindowModelIndexToCommandId(int window_model_index) { 101 int command_id = window_model_index + kFirstWindowCommandId; 102 DCHECK_LT(command_id, RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId); 103 return command_id; 104 } 105 106 // Convert |command_id| of menu item to index in window model. 107 int CommandIdToWindowModelIndex(int command_id) { 108 DCHECK_GE(command_id, kFirstWindowCommandId); 109 DCHECK_LT(command_id, RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId); 110 return command_id - kFirstWindowCommandId; 111 } 112 113 } // namespace 114 115 enum RecentTabAction { 116 LOCAL_SESSION_TAB = 0, 117 OTHER_DEVICE_TAB, 118 RESTORE_WINDOW, 119 SHOW_MORE, 120 LIMIT_RECENT_TAB_ACTION 121 }; 122 123 // An element in |RecentTabsSubMenuModel::tab_navigation_items_| that stores 124 // the navigation information of a local or foreign tab required to restore the 125 // tab. 126 struct RecentTabsSubMenuModel::TabNavigationItem { 127 TabNavigationItem() : tab_id(-1) {} 128 129 TabNavigationItem(const std::string& session_tag, 130 const SessionID::id_type& tab_id, 131 const string16& title, 132 const GURL& url) 133 : session_tag(session_tag), 134 tab_id(tab_id), 135 title(title), 136 url(url) {} 137 138 // For use by std::set for sorting. 139 bool operator<(const TabNavigationItem& other) const { 140 return url < other.url; 141 } 142 143 std::string session_tag; // Empty for local tabs, non-empty for foreign tabs. 144 SessionID::id_type tab_id; // -1 for invalid, >= 0 otherwise. 145 string16 title; 146 GURL url; 147 }; 148 149 const int RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId = 500; 150 const int RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId = 501; 151 const int RecentTabsSubMenuModel::kDeviceNameCommandId = 1000; 152 153 RecentTabsSubMenuModel::RecentTabsSubMenuModel( 154 ui::AcceleratorProvider* accelerator_provider, 155 Browser* browser, 156 browser_sync::SessionModelAssociator* associator) 157 : ui::SimpleMenuModel(this), 158 browser_(browser), 159 associator_(associator), 160 default_favicon_(ResourceBundle::GetSharedInstance(). 161 GetNativeImageNamed(IDR_DEFAULT_FAVICON)), 162 weak_ptr_factory_(this) { 163 Build(); 164 165 // Retrieve accelerator key for IDC_RESTORE_TAB now, because on ASH, it's not 166 // defined in |accelerator_provider|, but in shell, so simply retrieve it now 167 // for all ASH and non-ASH for use in |GetAcceleratorForCommandId|. 168 #if defined(USE_ASH) 169 for (size_t i = 0; i < ash::kAcceleratorDataLength; ++i) { 170 const ash::AcceleratorData& accel_data = ash::kAcceleratorData[i]; 171 if (accel_data.action == ash::RESTORE_TAB) { 172 reopen_closed_tab_accelerator_ = ui::Accelerator(accel_data.keycode, 173 accel_data.modifiers); 174 break; 175 } 176 } 177 #else 178 if (accelerator_provider) { 179 accelerator_provider->GetAcceleratorForCommandId( 180 IDC_RESTORE_TAB, &reopen_closed_tab_accelerator_); 181 } 182 #endif // defined(USE_ASH) 183 } 184 185 RecentTabsSubMenuModel::~RecentTabsSubMenuModel() { 186 } 187 188 bool RecentTabsSubMenuModel::IsCommandIdChecked(int command_id) const { 189 return false; 190 } 191 192 bool RecentTabsSubMenuModel::IsCommandIdEnabled(int command_id) const { 193 if (command_id == kRecentlyClosedHeaderCommandId || 194 command_id == kDisabledRecentlyClosedHeaderCommandId || 195 command_id == kDeviceNameCommandId || 196 command_id == IDC_RECENT_TABS_NO_DEVICE_TABS) { 197 return false; 198 } 199 return true; 200 } 201 202 bool RecentTabsSubMenuModel::GetAcceleratorForCommandId( 203 int command_id, ui::Accelerator* accelerator) { 204 // If there are no recently closed items, we show the accelerator beside 205 // the header, otherwise, we show it beside the first item underneath it. 206 int index_in_menu = GetIndexOfCommandId(command_id); 207 int header_index = GetIndexOfCommandId(kRecentlyClosedHeaderCommandId); 208 if ((command_id == kDisabledRecentlyClosedHeaderCommandId || 209 (header_index != -1 && index_in_menu == header_index + 1)) && 210 reopen_closed_tab_accelerator_.key_code() != ui::VKEY_UNKNOWN) { 211 *accelerator = reopen_closed_tab_accelerator_; 212 return true; 213 } 214 return false; 215 } 216 217 void RecentTabsSubMenuModel::ExecuteCommand(int command_id, int event_flags) { 218 if (command_id == IDC_SHOW_HISTORY) { 219 UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", SHOW_MORE, 220 LIMIT_RECENT_TAB_ACTION); 221 // We show all "other devices" on the history page. 222 chrome::ExecuteCommandWithDisposition(browser_, IDC_SHOW_HISTORY, 223 ui::DispositionFromEventFlags(event_flags)); 224 return; 225 } 226 227 DCHECK_NE(kDeviceNameCommandId, command_id); 228 DCHECK_NE(IDC_RECENT_TABS_NO_DEVICE_TABS, command_id); 229 230 WindowOpenDisposition disposition = 231 ui::DispositionFromEventFlags(event_flags); 232 if (disposition == CURRENT_TAB) // Force to open a new foreground tab. 233 disposition = NEW_FOREGROUND_TAB; 234 235 TabRestoreService* service = 236 TabRestoreServiceFactory::GetForProfile(browser_->profile()); 237 TabRestoreServiceDelegate* delegate = 238 TabRestoreServiceDelegate::FindDelegateForWebContents( 239 browser_->tab_strip_model()->GetActiveWebContents()); 240 if (IsTabModelCommandId(command_id)) { 241 int model_idx = CommandIdToTabModelIndex(command_id); 242 DCHECK(model_idx >= 0 && 243 model_idx < static_cast<int>(tab_navigation_items_.size())); 244 const TabNavigationItem& item = tab_navigation_items_[model_idx]; 245 DCHECK(item.tab_id > -1 && item.url.is_valid()); 246 247 if (item.session_tag.empty()) { // Restore tab of local session. 248 if (service && delegate) { 249 UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", 250 LOCAL_SESSION_TAB, LIMIT_RECENT_TAB_ACTION); 251 service->RestoreEntryById(delegate, item.tab_id, 252 browser_->host_desktop_type(), disposition); 253 } 254 } else { // Restore tab of foreign session. 255 browser_sync::SessionModelAssociator* associator = GetModelAssociator(); 256 if (!associator) 257 return; 258 const SessionTab* tab; 259 if (!associator->GetForeignTab(item.session_tag, item.tab_id, &tab)) 260 return; 261 if (tab->navigations.empty()) 262 return; 263 UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", 264 OTHER_DEVICE_TAB, LIMIT_RECENT_TAB_ACTION); 265 SessionRestore::RestoreForeignSessionTab( 266 browser_->tab_strip_model()->GetActiveWebContents(), 267 *tab, disposition); 268 } 269 } else { 270 DCHECK(IsWindowModelCommandId(command_id)); 271 if (service && delegate) { 272 int model_idx = CommandIdToWindowModelIndex(command_id); 273 DCHECK(model_idx >= 0 && 274 model_idx < static_cast<int>(window_items_.size())); 275 UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu", RESTORE_WINDOW, 276 LIMIT_RECENT_TAB_ACTION); 277 service->RestoreEntryById(delegate, window_items_[model_idx], 278 browser_->host_desktop_type(), disposition); 279 } 280 } 281 } 282 283 const gfx::Font* RecentTabsSubMenuModel::GetLabelFontAt(int index) const { 284 int command_id = GetCommandIdAt(index); 285 if (command_id == kDeviceNameCommandId || 286 command_id == kRecentlyClosedHeaderCommandId) { 287 return &ResourceBundle::GetSharedInstance().GetFont( 288 ResourceBundle::BoldFont); 289 } 290 return NULL; 291 } 292 293 int RecentTabsSubMenuModel::GetMaxWidthForItemAtIndex(int item_index) const { 294 int command_id = GetCommandIdAt(item_index); 295 if (command_id == IDC_RECENT_TABS_NO_DEVICE_TABS || 296 command_id == kRecentlyClosedHeaderCommandId || 297 command_id == kDisabledRecentlyClosedHeaderCommandId) { 298 return -1; 299 } 300 return 320; 301 } 302 303 bool RecentTabsSubMenuModel::GetURLAndTitleForItemAtIndex( 304 int index, 305 std::string* url, 306 string16* title) const { 307 int command_id = GetCommandIdAt(index); 308 if (IsTabModelCommandId(command_id)) { 309 int model_idx = CommandIdToTabModelIndex(command_id); 310 DCHECK(model_idx >= 0 && 311 model_idx < static_cast<int>(tab_navigation_items_.size())); 312 *url = tab_navigation_items_[model_idx].url.possibly_invalid_spec(); 313 *title = tab_navigation_items_[model_idx].title; 314 return true; 315 } 316 return false; 317 } 318 319 void RecentTabsSubMenuModel::Build() { 320 // The menu contains: 321 // - Recently closed tabs header, then list of tabs, then separator 322 // - device 1 section header, then list of tabs from device, then separator 323 // - device 2 section header, then list of tabs from device, then separator 324 // - device 3 section header, then list of tabs from device, then separator 325 // - More... to open the history tab to get more other devices. 326 // |tab_navigation_items_| only contains navigatable (and hence executable) 327 // tab items for other devices, and |window_items_| contains the recently 328 // closed windows. 329 BuildRecentTabs(); 330 BuildDevices(); 331 } 332 333 void RecentTabsSubMenuModel::BuildRecentTabs() { 334 ListValue recently_closed_list; 335 TabRestoreService* service = 336 TabRestoreServiceFactory::GetForProfile(browser_->profile()); 337 if (service) { 338 // This does nothing if the tabs have already been loaded or they 339 // shouldn't be loaded. 340 service->LoadTabsFromLastSession(); 341 } 342 343 if (!service || service->entries().size() == 0) { 344 // This is to show a disabled restore tab entry with the accelerator to 345 // teach users about this command. 346 AddItemWithStringId(kDisabledRecentlyClosedHeaderCommandId, 347 IDS_NEW_TAB_RECENTLY_CLOSED); 348 return; 349 } 350 351 AddItemWithStringId(kRecentlyClosedHeaderCommandId, 352 IDS_NEW_TAB_RECENTLY_CLOSED); 353 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); 354 SetIcon(GetItemCount() - 1, 355 rb.GetNativeImageNamed(IDR_RECENTLY_CLOSED_WINDOW)); 356 357 int added_count = 0; 358 TabRestoreService::Entries entries = service->entries(); 359 for (TabRestoreService::Entries::const_iterator it = entries.begin(); 360 it != entries.end() && added_count < kMaxRecentlyClosedEntries; ++it) { 361 TabRestoreService::Entry* entry = *it; 362 if (entry->type == TabRestoreService::TAB) { 363 TabRestoreService::Tab* tab = static_cast<TabRestoreService::Tab*>(entry); 364 const sessions::SerializedNavigationEntry& current_navigation = 365 tab->navigations.at(tab->current_navigation_index); 366 BuildLocalTabItem( 367 entry->id, 368 current_navigation.title(), 369 current_navigation.virtual_url()); 370 } else { 371 DCHECK_EQ(entry->type, TabRestoreService::WINDOW); 372 BuildWindowItem( 373 entry->id, 374 static_cast<TabRestoreService::Window*>(entry)->tabs.size()); 375 } 376 ++added_count; 377 } 378 } 379 380 void RecentTabsSubMenuModel::BuildDevices() { 381 browser_sync::SessionModelAssociator* associator = GetModelAssociator(); 382 std::vector<const browser_sync::SyncedSession*> sessions; 383 if (!associator || !associator->GetAllForeignSessions(&sessions)) { 384 AddSeparator(ui::NORMAL_SEPARATOR); 385 AddItemWithStringId(IDC_RECENT_TABS_NO_DEVICE_TABS, 386 IDS_RECENT_TABS_NO_DEVICE_TABS); 387 return; 388 } 389 390 // Sort sessions from most recent to least recent. 391 std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency); 392 393 const size_t kMaxSessionsToShow = 3; 394 size_t num_sessions_added = 0; 395 for (size_t i = 0; 396 i < sessions.size() && num_sessions_added < kMaxSessionsToShow; ++i) { 397 const browser_sync::SyncedSession* session = sessions[i]; 398 const std::string& session_tag = session->session_tag; 399 400 // Get windows of session. 401 std::vector<const SessionWindow*> windows; 402 if (!associator->GetForeignSession(session_tag, &windows) || 403 windows.empty()) { 404 continue; 405 } 406 407 // Collect tabs from all windows of session, pruning those that are not 408 // syncable or are NewTabPage, then sort them from most recent to least 409 // recent, independent of which window the tabs were from. 410 std::vector<const SessionTab*> tabs_in_session; 411 for (size_t j = 0; j < windows.size(); ++j) { 412 const SessionWindow* window = windows[j]; 413 for (size_t t = 0; t < window->tabs.size(); ++t) { 414 const SessionTab* tab = window->tabs[t]; 415 if (tab->navigations.empty()) 416 continue; 417 const sessions::SerializedNavigationEntry& current_navigation = 418 tab->navigations.at(tab->normalized_navigation_index()); 419 if (chrome::IsNTPURL(current_navigation.virtual_url(), 420 browser_->profile())) { 421 continue; 422 } 423 tabs_in_session.push_back(tab); 424 } 425 } 426 if (tabs_in_session.empty()) 427 continue; 428 std::sort(tabs_in_session.begin(), tabs_in_session.end(), 429 SortTabsByRecency); 430 431 // Add the header for the device session. 432 DCHECK(!session->session_name.empty()); 433 AddSeparator(ui::NORMAL_SEPARATOR); 434 AddItem(kDeviceNameCommandId, UTF8ToUTF16(session->session_name)); 435 AddDeviceFavicon(GetItemCount() - 1, session->device_type); 436 437 // Build tab menu items from sorted session tabs. 438 const size_t kMaxTabsPerSessionToShow = 4; 439 for (size_t k = 0; 440 k < std::min(tabs_in_session.size(), kMaxTabsPerSessionToShow); 441 ++k) { 442 BuildForeignTabItem(session_tag, *tabs_in_session[k]); 443 } // for all tabs in one session 444 445 ++num_sessions_added; 446 } // for all sessions 447 448 // We are not supposed to get here unless at least some items were added. 449 DCHECK_GT(GetItemCount(), 0); 450 AddSeparator(ui::NORMAL_SEPARATOR); 451 AddItemWithStringId(IDC_SHOW_HISTORY, IDS_RECENT_TABS_MORE); 452 } 453 454 void RecentTabsSubMenuModel::BuildLocalTabItem( 455 int session_id, 456 const string16& title, 457 const GURL& url) { 458 TabNavigationItem item("", session_id, title, url); 459 int command_id = TabModelIndexToCommandId(tab_navigation_items_.size()); 460 // There may be no tab title, in which case, use the url as tab title. 461 AddItem(command_id, title.empty() ? UTF8ToUTF16(item.url.spec()) : title); 462 AddTabFavicon(tab_navigation_items_.size(), command_id, item.url); 463 tab_navigation_items_.push_back(item); 464 } 465 466 void RecentTabsSubMenuModel::BuildForeignTabItem( 467 const std::string& session_tag, 468 const SessionTab& tab) { 469 const sessions::SerializedNavigationEntry& current_navigation = 470 tab.navigations.at(tab.normalized_navigation_index()); 471 TabNavigationItem item(session_tag, tab.tab_id.id(), 472 current_navigation.title(), 473 current_navigation.virtual_url()); 474 int command_id = TabModelIndexToCommandId(tab_navigation_items_.size()); 475 // There may be no tab title, in which case, use the url as tab title. 476 AddItem(command_id, 477 current_navigation.title().empty() ? 478 UTF8ToUTF16(item.url.spec()) : current_navigation.title()); 479 AddTabFavicon(tab_navigation_items_.size(), command_id, item.url); 480 tab_navigation_items_.push_back(item); 481 } 482 483 void RecentTabsSubMenuModel::BuildWindowItem( 484 const SessionID::id_type& window_id, 485 int num_tabs) { 486 int command_id = WindowModelIndexToCommandId(window_items_.size()); 487 if (num_tabs == 1) { 488 AddItemWithStringId(command_id, IDS_NEW_TAB_RECENTLY_CLOSED_WINDOW_SINGLE); 489 } else { 490 AddItem(command_id, l10n_util::GetStringFUTF16( 491 IDS_NEW_TAB_RECENTLY_CLOSED_WINDOW_MULTIPLE, 492 base::IntToString16(num_tabs))); 493 } 494 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); 495 SetIcon(GetItemCount() - 1, 496 rb.GetNativeImageNamed(IDR_RECENTLY_CLOSED_WINDOW)); 497 window_items_.push_back(window_id); 498 } 499 500 void RecentTabsSubMenuModel::AddDeviceFavicon( 501 int index_in_menu, 502 browser_sync::SyncedSession::DeviceType device_type) { 503 int favicon_id = -1; 504 switch (device_type) { 505 case browser_sync::SyncedSession::TYPE_PHONE: 506 favicon_id = IDR_PHONE_FAVICON; 507 break; 508 509 case browser_sync::SyncedSession::TYPE_TABLET: 510 favicon_id = IDR_TABLET_FAVICON; 511 break; 512 513 case browser_sync::SyncedSession::TYPE_CHROMEOS: 514 case browser_sync::SyncedSession::TYPE_WIN: 515 case browser_sync::SyncedSession::TYPE_MACOSX: 516 case browser_sync::SyncedSession::TYPE_LINUX: 517 case browser_sync::SyncedSession::TYPE_OTHER: 518 case browser_sync::SyncedSession::TYPE_UNSET: 519 favicon_id = IDR_LAPTOP_FAVICON; 520 break; 521 }; 522 523 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); 524 SetIcon(index_in_menu, rb.GetNativeImageNamed(favicon_id)); 525 } 526 527 void RecentTabsSubMenuModel::AddTabFavicon(int model_index, 528 int command_id, 529 const GURL& url) { 530 int index_in_menu = GetIndexOfCommandId(command_id); 531 532 // If tab has synced favicon, use it. 533 // Note that currently, foreign tab only has favicon if --sync-tab-favicons 534 // switch is on; according to zea@, this flag is now automatically enabled for 535 // iOS and android, and they're looking into enabling it for other platforms. 536 browser_sync::SessionModelAssociator* associator = GetModelAssociator(); 537 scoped_refptr<base::RefCountedMemory> favicon_png; 538 if (associator && 539 associator->GetSyncedFaviconForPageURL(url.spec(), &favicon_png)) { 540 gfx::Image image = gfx::Image::CreateFrom1xPNGBytes( 541 favicon_png->front(), 542 favicon_png->size()); 543 SetIcon(index_in_menu, image); 544 return; 545 } 546 547 // Otherwise, start to fetch the favicon from local history asynchronously. 548 // Set default icon first. 549 SetIcon(index_in_menu, default_favicon_); 550 // Start request to fetch actual icon if possible. 551 FaviconService* favicon_service = FaviconServiceFactory::GetForProfile( 552 browser_->profile(), Profile::EXPLICIT_ACCESS); 553 if (!favicon_service) 554 return; 555 556 favicon_service->GetFaviconImageForURL( 557 FaviconService::FaviconForURLParams(browser_->profile(), 558 url, 559 chrome::FAVICON, 560 gfx::kFaviconSize), 561 base::Bind(&RecentTabsSubMenuModel::OnFaviconDataAvailable, 562 weak_ptr_factory_.GetWeakPtr(), 563 command_id), 564 &cancelable_task_tracker_); 565 } 566 567 void RecentTabsSubMenuModel::OnFaviconDataAvailable( 568 int command_id, 569 const chrome::FaviconImageResult& image_result) { 570 if (image_result.image.IsEmpty()) 571 return; 572 DCHECK(!tab_navigation_items_.empty()); 573 int index_in_menu = GetIndexOfCommandId(command_id); 574 DCHECK(index_in_menu != -1); 575 SetIcon(index_in_menu, image_result.image); 576 if (GetMenuModelDelegate()) 577 GetMenuModelDelegate()->OnIconChanged(index_in_menu); 578 } 579 580 browser_sync::SessionModelAssociator* 581 RecentTabsSubMenuModel::GetModelAssociator() { 582 if (!associator_) { 583 ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()-> 584 GetForProfile(browser_->profile()); 585 // Only return the associator if it exists and it is done syncing sessions. 586 if (service && service->ShouldPushChanges()) 587 associator_ = service->GetSessionModelAssociator(); 588 } 589 return associator_; 590 } 591