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

chrome/browser/browser_init.cc

 // Copyright (c) 2009 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_init.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/event_recorder.h"
 #include "base/path_service.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/first_run.h"
 #include "chrome/browser/net/dns_global.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/session_startup_pref.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/shell_integration.h"
+#include "chrome/browser/tabs/pinned_tab_codec.h"
 #include "chrome/browser/tab_contents/infobar_delegate.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/status_icons/status_tray_manager.h"
 #include "chrome/browser/user_data_manager.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 286 matching lines @@
 #else
   // Just send caption & text to stdout on mac & linux.
   std::string out_text = WideToASCII(caption);
   out_text.append("\n\n");
   out_text.append(WideToASCII(message));
   out_text.append("\n");
   printf("%s", out_text.c_str());
 #endif
 }
 
+void UrlsToTabs(const std::vector<GURL>& urls,
+                std::vector<BrowserInit::LaunchWithProfile::Tab>* tabs) {
+  for (size_t i = 0; i < urls.size(); ++i) {
+    BrowserInit::LaunchWithProfile::Tab tab;
+    tab.is_pinned = false;
+    tab.url = urls[i];
+    tabs->push_back(tab);
+  }
+}
+
 }  // namespace
 
 // static
 bool BrowserInit::InProcessStartup() {
   return in_startup;
 }
 
 bool BrowserInit::LaunchBrowser(
     const CommandLine& command_line, Profile* profile,
     const std::wstring& cur_dir, bool process_startup,
@@ skipping 111 matching lines @@
     webkit_glue::SetUserAgent(command_line_.GetSwitchValueASCII(
         switches::kUserAgent));
   }
 
   // Open the required browser windows and tabs.
   // First, see if we're being run as an application window.
   if (!OpenApplicationWindow(profile)) {
     std::vector<GURL> urls_to_open = GetURLsFromCommandLine(profile_);
     RecordLaunchModeHistogram(urls_to_open.empty()?
                               LM_TO_BE_DECIDED : LM_WITH_URLS);
-    // Always attempt to restore the last session. OpenStartupURLs only opens
-    // the home pages if no additional URLs were passed on the command line.
-    if (!OpenStartupURLs(process_startup, urls_to_open)) {
+    if (!process_startup || !OpenStartupURLs(urls_to_open)) {
       // Add the home page and any special first run URLs.
       Browser* browser = NULL;
       if (urls_to_open.empty())
         AddStartupURLs(&urls_to_open);
       else if (!command_line_.HasSwitch(switches::kOpenInNewWindow))
         browser = BrowserList::GetLastActive();
 
       OpenURLsInBrowser(browser, process_startup, urls_to_open);
     }
 
@@ skipping 102 matching lines @@
     if (policy->IsWebSafeScheme(url.scheme()) ||
         url.SchemeIs(chrome::kFileScheme)) {
       Browser::OpenApplicationWindow(profile, url, false);
       return true;
     }
   }
   return false;
 }
 
 bool BrowserInit::LaunchWithProfile::OpenStartupURLs(
-    bool is_process_startup,
     const std::vector<GURL>& urls_to_open) {
   SessionStartupPref pref = GetSessionStartupPref(command_line_, profile_);
-  if (is_process_startup &&
-      command_line_.HasSwitch(switches::kTestingChannelID) &&
+  if (command_line_.HasSwitch(switches::kTestingChannelID) &&
       !command_line_.HasSwitch(switches::kRestoreLastSession) &&
       browser_defaults::kDefaultSessionStartupType !=
       SessionStartupPref::DEFAULT) {
     // When we have non DEFAULT session start type, then we won't open up a
     // fresh session. But none of the tests are written with this in mind, so
     // we explicitly ignore it during testing.
     return false;
   }
-  switch (pref.type) {
-    case SessionStartupPref::LAST:
-      if (!is_process_startup)
-        return false;
 
-      if (!profile_->DidLastSessionExitCleanly() &&
-          !command_line_.HasSwitch(switches::kRestoreLastSession)) {
-        // The last session crashed. It's possible automatically loading the
-        // page will trigger another crash, locking the user out of chrome.
-        // To avoid this, don't restore on startup but instead show the crashed
-        // infobar.
-        return false;
-      }
-      SessionRestore::RestoreSessionSynchronously(profile_, urls_to_open);
-      return true;
+  if (pref.type == SessionStartupPref::LAST) {
+    if (!profile_->DidLastSessionExitCleanly() &&
+        !command_line_.HasSwitch(switches::kRestoreLastSession)) {
+      // The last session crashed. It's possible automatically loading the
+      // page will trigger another crash, locking the user out of chrome.
+      // To avoid this, don't restore on startup but instead show the crashed
+      // infobar.
+      return false;
+    }
+    SessionRestore::RestoreSessionSynchronously(profile_, urls_to_open);
+    return true;
+  }
 
-    case SessionStartupPref::URLS:
-      // When the user launches the app only open the default set of URLs if
-      // we aren't going to open any URLs on the command line.
-      if (urls_to_open.empty()) {
-        if (pref.urls.empty()) {
-          // Open a New Tab page.
-          std::vector<GURL> urls;
-          urls.push_back(GURL(chrome::kChromeUINewTabURL));
-          OpenURLsInBrowser(NULL, is_process_startup, urls);
-          return true;
-        }
-        OpenURLsInBrowser(NULL, is_process_startup, pref.urls);
-        return true;
-      }
-      return false;
+  std::vector<Tab> tabs = PinnedTabCodec::ReadPinnedTabs(profile_);
 
-    default:
-      return false;
+  if (!urls_to_open.empty()) {
+    // If urls were specified on the command line, use them.
+    UrlsToTabs(urls_to_open, &tabs);
+  } else if (pref.type == SessionStartupPref::URLS && !pref.urls.empty()) {
+    // Only use the set of urls specified in preferences if nothing was
+    // specified on the command line.
+    UrlsToTabs(pref.urls, &tabs);
   }
+
+  if (tabs.empty())
+    return false;
+
+  OpenTabsInBrowser(NULL, true, tabs);
+  return true;
 }
 
 Browser* BrowserInit::LaunchWithProfile::OpenURLsInBrowser(
     Browser* browser,
     bool process_startup,
     const std::vector<GURL>& urls) {
-  DCHECK(!urls.empty());
+  std::vector<Tab> tabs;
+  UrlsToTabs(urls, &tabs);
+  return OpenTabsInBrowser(browser, process_startup, tabs);
+}
+
+Browser* BrowserInit::LaunchWithProfile::OpenTabsInBrowser(
+        Browser* browser,
+        bool process_startup,
+        const std::vector<Tab>& tabs) {
+  DCHECK(!tabs.empty());
   // If we don't yet have a profile, try to use the one we're given from
   // |browser|. While we may not end up actually using |browser| (since it
   // could be a popup window), we can at least use the profile.
   if (!profile_ && browser)
     profile_ = browser->profile();
 
   if (!browser || browser->type() != Browser::TYPE_NORMAL)
     browser = Browser::Create(profile_);
 
 #if !defined(OS_MACOSX)
   // In kiosk mode, we want to always be fullscreen, so switch to that now.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     browser->ToggleFullscreenMode();
 #endif
 
-  for (size_t i = 0; i < urls.size(); ++i) {
+  bool first_tab = true;
+  for (size_t i = 0; i < tabs.size(); ++i) {
     // We skip URLs that we'd have to launch an external protocol handler for.
     // This avoids us getting into an infinite loop asking ourselves to open
     // a URL, should the handler be (incorrectly) configured to be us. Anyone
     // asking us to open such a URL should really ask the handler directly.
-    if (!process_startup && !URLRequest::IsHandledURL(urls[i]))
+    if (!process_startup && !URLRequest::IsHandledURL(tabs[i].url))
       continue;
+
+    int add_types = first_tab ? Browser::ADD_SELECTED : 0;
+    if (tabs[i].is_pinned)
+      add_types |= Browser::ADD_PINNED;
+
     TabContents* tab = browser->AddTabWithURL(
-        urls[i], GURL(), PageTransition::START_PAGE, (i == 0), -1, false, NULL);
-    if (profile_ && i == 0 && process_startup)
+        tabs[i].url, GURL(), PageTransition::START_PAGE, -1, add_types, NULL,
+        tabs[i].app_id);
+
+    if (profile_ && first_tab && process_startup)
       AddCrashedInfoBarIfNecessary(tab);
+
+    first_tab = false;
   }
   browser->window()->Show();
   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
   //                focus explicitly.
   browser->GetSelectedTabContents()->view()->SetInitialFocus();
 
   return browser;
 }
 
 void BrowserInit::LaunchWithProfile::AddCrashedInfoBarIfNecessary(
@@ skipping 273 matching lines @@
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
   automation->ConnectToChannel(channel_id);
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list =
       g_browser_process->InitAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
 }