Decouple TabRestoreService from Browser

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 188 matching lines @@
       command_updater_(this),
       toolbar_model_(this),
       chrome_updater_factory_(this),
       is_attempting_to_close_browser_(false),
       cancel_download_confirmation_state_(NOT_PROMPTED),
       maximized_state_(MAXIMIZED_STATE_DEFAULT),
       method_factory_(this),
       block_command_execution_(false),
       last_blocked_command_id_(-1),
       last_blocked_command_disposition_(CURRENT_TAB),
-      pending_web_app_action_(NONE) {
+      pending_web_app_action_(NONE),
+      tab_restore_service_delegate_(this) {
   registrar_.Add(this, NotificationType::SSL_VISIBLE_STATE_CHANGED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNINSTALLED,
                  NotificationService::AllSources());
@@ skipping 72 matching lines @@
     profile_->ResetTabRestoreService();
   }
 #endif
 
   SessionService* session_service = profile_->GetSessionService();
   if (session_service)
     session_service->WindowClosed(session_id_);
 
   TabRestoreService* tab_restore_service = profile()->GetTabRestoreService();
   if (tab_restore_service)
-    tab_restore_service->BrowserClosed(this);
+    tab_restore_service->BrowserClosed(tab_restore_service_delegate());
 
   encoding_auto_detect_.Destroy();
   printing_enabled_.Destroy();
   dev_tools_disabled_.Destroy();
   incognito_mode_allowed_.Destroy();
   instant_enabled_.Destroy();
   use_vertical_tabs_.Destroy();
 
   if (profile_->IsOffTheRecord() &&
       !BrowserList::IsOffTheRecordSessionActive()) {
@@ skipping 574 matching lines @@
     exiting = true;
   }
 
   // Don't use HasSessionService here, we want to force creation of the
   // session service so that user can restore what was open.
   SessionService* session_service = profile()->GetSessionService();
   if (session_service)
     session_service->WindowClosing(session_id());
 
   TabRestoreService* tab_restore_service = profile()->GetTabRestoreService();
-  if (tab_restore_service)
-    tab_restore_service->BrowserClosing(this);
+  if (tab_restore_service && type() == TYPE_NORMAL && tab_count())
+    tab_restore_service->BrowserClosing(tab_restore_service_delegate());
 
   // TODO(sky): convert session/tab restore to use notification.
   NotificationService::current()->Notify(
       NotificationType::BROWSER_CLOSING,
       Source<Browser>(this),
       Details<bool>(&exiting));
 
   CloseAllTabs();
 }
 
@@ skipping 50 matching lines @@
   TabContentsWrapper* wrapper = tabstrip_model()->GetTabContentsAt(index);
   if (wrapper)
     return wrapper->tab_contents();
   return NULL;
 }
 
 void Browser::SelectTabContentsAt(int index, bool user_gesture) {
   tab_handler_->GetTabStripModel()->SelectTabContentsAt(index, user_gesture);
 }
 
+bool Browser::IsTabPinned(int index) const {
+  return tabstrip_model()->IsTabPinned(index);
+}
+
 void Browser::CloseAllTabs() {
   tab_handler_->GetTabStripModel()->CloseAllTabs();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Browser, Tab adding/showing functions:
 
 bool Browser::IsTabStripEditable() const {
   return window()->IsTabStripEditable();
 }
@@ skipping 470 matching lines @@
   UserMetrics::RecordAction(UserMetricsAction("Duplicate"), profile_);
   DuplicateContentsAt(selected_index());
 }
 
 void Browser::RestoreTab() {
   UserMetrics::RecordAction(UserMetricsAction("RestoreTab"), profile_);
   TabRestoreService* service = profile_->GetTabRestoreService();
   if (!service)
     return;
 
-  service->RestoreMostRecentEntry(this);
+  service->RestoreMostRecentEntry(tab_restore_service_delegate());
 }
 
 void Browser::WriteCurrentURLToClipboard() {
   // TODO(ericu): There isn't currently a metric for this.  Should there be?
   // We don't appear to track the action when it comes from the
   // RenderContextViewMenu.
 
   TabContents* contents = GetSelectedTabContents();
   if (!contents->ShouldDisplayURL())
     return;
@@ skipping 1092 matching lines @@
   // We don't create historical tabs for incognito windows or windows without
   // profiles.
   if (!profile() || profile()->IsOffTheRecord() ||
       !profile()->GetTabRestoreService()) {
     return;
   }
 
   // We only create historical tab entries for tabbed browser windows.
   if (CanSupportWindowFeature(FEATURE_TABSTRIP)) {
     profile()->GetTabRestoreService()->CreateHistoricalTab(
-        &contents->controller());
+        &contents->controller(),
+        tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents));
   }
 }
 
 bool Browser::RunUnloadListenerBeforeClosing(TabContentsWrapper* contents) {
   return Browser::RunUnloadEventsHelper(contents->tab_contents());
 }
 
 bool Browser::CanReloadContents(TabContents* source) const {
   return type() != TYPE_DEVTOOLS;
 }
@@ skipping 1803 matching lines @@
     // The page transition below is only for the purpose of inserting the tab.
     browser->AddTab(view_source_contents, PageTransition::LINK);
   }
 
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service)
       session_service->TabRestored(&view_source_contents->controller(), false);
   }
 }