Makes pinned tab restore on startup if you haven't enabled session

chrome/browser/browser.cc

 // Copyright (c) 2010 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/browser.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/animation.h"
@@ skipping 620 matching lines @@
     return true;
 
   ProcessPendingTabs();
   return false;
 }
 
 void Browser::OnWindowClosing() {
   if (!ShouldCloseWindow())
     return;
 
+  bool exiting = false;
+
 #if defined(OS_WIN) || defined(OS_LINUX)
   // We don't want to do this on Mac since closing all windows isn't a sign
   // that the app is shutting down.
-  if (BrowserList::size() == 1)
+  if (BrowserList::size() == 1) {
     browser_shutdown::OnShutdownStarting(browser_shutdown::WINDOW_CLOSE);
+    exiting = true;
+  }
 #endif
 
   // 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);
 
+  // TODO(sky): convert session/tab restore to use notification.
+  NotificationService::current()->Notify(
+      NotificationType::BROWSER_CLOSING,
+      Source<Browser>(this),
+      Details<bool>(&exiting));
+
   CloseAllTabs();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // In-progress download termination handling:
 
 void Browser::InProgressDownloadResponse(bool cancel_downloads) {
   if (cancel_downloads) {
     cancel_download_confirmation_state_ = RESPONSE_RECEIVED;
     CloseWindow();
     return;
   }
 
   // Sets the confirmation state to NOT_PROMPTED so that if the user tries to
   // close again we'll show the warning again.
   cancel_download_confirmation_state_ = NOT_PROMPTED;
 
   // Show the download page so the user can figure-out what downloads are still
   // in-progress.
   ShowDownloadsTab();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Browser, Tab adding/showing functions:
 
 TabContents* Browser::AddTabWithURL(
     const GURL& url, const GURL& referrer, PageTransition::Type transition,
     bool foreground, int index, bool force_index,
     SiteInstance* instance) {
+  int add_types = 0;
+  if (force_index)
+    add_types |= ADD_FORCE_INDEX;
+  if (foreground)
+    add_types |= ADD_SELECTED;
+  return AddTabWithURL(url, referrer, transition, index, add_types, instance,
+                       std::string());
+}
+
+TabContents* Browser::AddTabWithURL(const GURL& url,
+                                    const GURL& referrer,
+                                    PageTransition::Type transition,
+                                    int index,
+                                    int add_types,
+                                    SiteInstance* instance,
+                                    const std::string& app_extension_id) {
   TabContents* contents = NULL;
   if (type_ == TYPE_NORMAL || tabstrip_model()->empty()) {
     GURL url_to_load = url;
     if (url_to_load.is_empty())
       url_to_load = GetHomePage();
     contents = CreateTabContentsForURL(url_to_load, referrer, profile_,
                                        transition, false, instance);
-    tabstrip_model_.AddTabContents(contents, index, force_index,
-                                   transition, foreground);
+    contents->SetAppExtensionById(app_extension_id);
+    // TODO(sky): TabStripModel::AddTabContents should take add_types directly.
+    tabstrip_model_.AddTabContents(contents, index,
+                                   (add_types & ADD_FORCE_INDEX) != 0,
+                                   transition,
+                                   (add_types & ADD_SELECTED) != 0);
+    tabstrip_model_.SetTabPinned(
+        tabstrip_model_.GetIndexOfTabContents(contents),
+        (add_types & ADD_PINNED) != 0);
+
     // By default, content believes it is not hidden.  When adding contents
     // in the background, tell it that it's hidden.
-    if (!foreground)
+    if ((add_types & ADD_SELECTED) == 0) {
+      // TODO(sky): see if this is really needed. I suspect not as
+      // TabStripModel::AddTabContents invokes HideContents if not foreground.
       contents->WasHidden();
+    }
   } else {
     // We're in an app window or a popup window. Find an existing browser to
     // open this URL in, creating one if none exists.
     Browser* b = GetOrCreateTabbedBrowser(profile_);
-    contents = b->AddTabWithURL(url, referrer, transition, foreground, index,
-                                force_index, instance);
+    contents = b->AddTabWithURL(url, referrer, transition, index, add_types,
+                                instance, app_extension_id);
     b->window()->Show();
   }
   return contents;
 }
 
 TabContents* Browser::AddTab(TabContents* tab_contents,
                              PageTransition::Type type) {
   tabstrip_model_.AddTabContents(tab_contents, -1, false, type, true);
   return tab_contents;
 }
@@ skipping 25 matching lines @@
 TabContents* Browser::AddRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int tab_index,
     int selected_navigation,
     const std::string& app_extension_id,
     bool select,
     bool pin,
     bool from_last_session) {
   TabContents* new_tab = new TabContents(profile(), NULL,
       MSG_ROUTING_NONE, tabstrip_model_.GetSelectedTabContents());
-  SetAppExtensionById(new_tab, app_extension_id);
+  new_tab->SetAppExtensionById(app_extension_id);
   new_tab->controller().RestoreFromState(navigations, selected_navigation,
                                          from_last_session);
 
   bool really_pin =
       (pin && tab_index == tabstrip_model()->IndexOfFirstNonMiniTab());
   tabstrip_model_.InsertTabContentsAt(tab_index, new_tab, select, false);
   if (really_pin)
     tabstrip_model_.SetTabPinned(tab_index, true);
   if (select)
     window_->Activate();
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service)
       session_service->TabRestored(&new_tab->controller(), really_pin);
   }
   return new_tab;
 }
 
 void Browser::ReplaceRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int selected_navigation,
     bool from_last_session,
     const std::string& app_extension_id) {
   TabContents* replacement = new TabContents(profile(), NULL,
       MSG_ROUTING_NONE, tabstrip_model_.GetSelectedTabContents());
-  SetAppExtensionById(replacement, app_extension_id);
+  replacement->SetAppExtensionById(app_extension_id);
   replacement->controller().RestoreFromState(navigations, selected_navigation,
                                              from_last_session);
 
   tabstrip_model_.ReplaceNavigationControllerAt(
       tabstrip_model_.selected_index(),
       &replacement->controller());
 }
 
 bool Browser::CanRestoreTab() {
   TabRestoreService* service = profile_->GetTabRestoreService();
@@ skipping 2600 matching lines @@
   if (TabHasUnloadListener(contents)) {
     // If the page has unload listeners, then we tell the renderer to fire
     // them. Once they have fired, we'll get a message back saying whether
     // to proceed closing the page or not, which sends us back to this method
     // with the HasUnloadListener bit cleared.
     contents->render_view_host()->FirePageBeforeUnload(false);
     return true;
   }
   return false;
 }
-
-void Browser::SetAppExtensionById(TabContents* contents,
-                                  const std::string& app_extension_id) {
-  if (app_extension_id.empty())
-    return;
-
-  ExtensionsService* extension_service = profile()->GetExtensionsService();
-  if (extension_service && extension_service->is_ready()) {
-    Extension* extension =
-        extension_service->GetExtensionById(app_extension_id, false);
-    if (extension)
-      contents->SetAppExtension(extension);
-  }
-}