Restore all profiles which were active when restoring the last open pages.

chrome/browser/ui/browser_init.cc

 // Copyright (c) 2012 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_init.h"
 
 #include <algorithm>   // For max().
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 1520 matching lines @@
           (url.spec().find(chrome::kChromeUISettingsURL) == 0) ||
 #endif
           (url.spec().compare(chrome::kAboutBlankURL) == 0)) {
         urls.push_back(url);
       }
     }
   }
   return urls;
 }
 
-bool BrowserInit::ProcessCmdLineImpl(const CommandLine& command_line,
-                                     const FilePath& cur_dir,
-                                     bool process_startup,
-                                     Profile* profile,
-                                     int* return_code,
-                                     BrowserInit* browser_init) {
-  DCHECK(profile);
+bool BrowserInit::ProcessCmdLineImpl(
+    const CommandLine& command_line,
+    const FilePath& cur_dir,
+    bool process_startup,
+    Profile* last_active_profile,
+    const std::vector<Profile*>& other_profiles,
+    int* return_code,
+    BrowserInit* browser_init) {
+  DCHECK(last_active_profile);
   if (process_startup) {
     if (command_line.HasSwitch(switches::kDisablePromptOnRepost))
       content::NavigationController::DisablePromptOnRepost();
 
     RegisterComponentsForUpdate(command_line);
 
     // Look for the testing channel ID ONLY during process startup
     if (command_line.HasSwitch(switches::kTestingChannelID)) {
       std::string testing_channel_id = command_line.GetSwitchValueASCII(
           switches::kTestingChannelID);
       // TODO(sanjeevr) Check if we need to make this a singleton for
       // compatibility with the old testing code
       // If there are any extra parameters, we expect each one to generate a
       // new tab; if there are none then we get one homepage tab.
       int expected_tab_count = 1;
       if (command_line.HasSwitch(switches::kNoStartupWindow)) {
         expected_tab_count = 0;
 #if defined(OS_CHROMEOS)
       // kLoginManager will cause Chrome to start up with the ChromeOS login
       // screen instead of a browser window, so it won't load any tabs.
       } else if (command_line.HasSwitch(switches::kLoginManager)) {
         expected_tab_count = 0;
 #endif
       } else if (command_line.HasSwitch(switches::kRestoreLastSession)) {
         std::string restore_session_value(
             command_line.GetSwitchValueASCII(switches::kRestoreLastSession));
         base::StringToInt(restore_session_value, &expected_tab_count);
       } else {
         std::vector<GURL> urls_to_open = GetURLsFromCommandLine(
-            command_line, cur_dir, profile);
+            command_line, cur_dir, last_active_profile);
         expected_tab_count =
             std::max(1, static_cast<int>(urls_to_open.size()));
       }
       if (!CreateAutomationProvider<TestingAutomationProvider>(
           testing_channel_id,
-          profile,
+          last_active_profile,
           static_cast<size_t>(expected_tab_count)))
         return false;
     }
   }
 
   bool silent_launch = false;
 
   if (command_line.HasSwitch(switches::kAutomationClientChannelID)) {
     std::string automation_channel_id = command_line.GetSwitchValueASCII(
         switches::kAutomationClientChannelID);
     // If there are any extra parameters, we expect each one to generate a
     // new tab; if there are none then we have no tabs
     std::vector<GURL> urls_to_open = GetURLsFromCommandLine(
-        command_line, cur_dir, profile);
+        command_line, cur_dir, last_active_profile);
     size_t expected_tabs =
         std::max(static_cast<int>(urls_to_open.size()), 0);
     if (expected_tabs == 0)
       silent_launch = true;
 
     if (command_line.HasSwitch(switches::kChromeFrame)) {
 #if !defined(USE_AURA)
       if (!CreateAutomationProvider<ChromeFrameAutomationProvider>(
-          automation_channel_id, profile, expected_tabs))
+          automation_channel_id, last_active_profile, expected_tabs))
         return false;
 #endif
     } else {
       if (!CreateAutomationProvider<AutomationProvider>(
-          automation_channel_id, profile, expected_tabs))
+          automation_channel_id, last_active_profile, expected_tabs))
         return false;
     }
   }
 
   // If we have been invoked to display a desktop notification on behalf of
   // the service process, we do not want to open any browser windows.
   if (command_line.HasSwitch(switches::kNotifyCloudPrintTokenExpired)) {
     silent_launch = true;
-    CloudPrintProxyServiceFactory::GetForProfile(profile)->
+    CloudPrintProxyServiceFactory::GetForProfile(last_active_profile)->
         ShowTokenExpiredNotification();
   }
 
   // If we are just displaying a print dialog we shouldn't open browser
   // windows.
   if (command_line.HasSwitch(switches::kCloudPrintFile) &&
       print_dialog_cloud::CreatePrintDialogFromCommandLine(command_line)) {
     silent_launch = true;
   }
 
@@ skipping 34 matching lines @@
   }
 #endif
 
   // If we don't want to launch a new browser window or tab (in the case
   // of an automation request), we are done here.
   if (!silent_launch) {
     IsProcessStartup is_process_startup = process_startup ?
         IS_PROCESS_STARTUP : IS_NOT_PROCESS_STARTUP;
     IsFirstRun is_first_run = first_run::IsChromeFirstRun() ?
         IS_FIRST_RUN : IS_NOT_FIRST_RUN;
-    return browser_init->LaunchBrowser(command_line, profile, cur_dir,
-        is_process_startup, is_first_run, return_code);
+    // Launch the last active profile with the full command line, and the other
+    // profiles without the URLs to launch.
+    CommandLine command_line_without_urls(command_line.GetProgram());
+    const CommandLine::SwitchMap& switches = command_line.GetSwitches();
+    CommandLine::SwitchMap::const_iterator switch_it;
+    for (switch_it = switches.begin(); switch_it != switches.end();
+         ++switch_it) {
+      command_line_without_urls.AppendSwitchNative(switch_it->first,
+                                                   switch_it->second);
+    }
+    std::vector<Profile*>::const_iterator it;
+    for (it = other_profiles.begin(); it != other_profiles.end(); ++it) {
+      if (*it == last_active_profile)
+        continue;
+      if (!browser_init->LaunchBrowser(
+              command_line_without_urls, *it, cur_dir, is_process_startup,
+              is_first_run, return_code)) {
+        return false;
+      }
+    }
+    return browser_init->LaunchBrowser(
+        command_line, last_active_profile, cur_dir, is_process_startup,
+        is_first_run, return_code);
   }
   return true;
 }
 
 template <class AutomationProviderClass>
 bool BrowserInit::CreateAutomationProvider(const std::string& channel_id,
                                            Profile* profile,
                                            size_t expected_tabs) {
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
 
   if (!automation->InitializeChannel(channel_id))
     return false;
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list = g_browser_process->GetAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
 
   return true;
 }
 
 // static
 void BrowserInit::ProcessCommandLineOnProfileCreated(
     const CommandLine& cmd_line,
     const FilePath& cur_dir,
     Profile* profile,
     Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED)
-    ProcessCmdLineImpl(cmd_line, cur_dir, false, profile, NULL, NULL);
+    ProcessCmdLineImpl(cmd_line, cur_dir, false, profile,
+                       std::vector<Profile*>(), NULL, NULL);
 }
 
 // static
 void BrowserInit::ProcessCommandLineAlreadyRunning(const CommandLine& cmd_line,
                                                    const FilePath& cur_dir) {
   if (cmd_line.HasSwitch(switches::kProfileDirectory)) {
     ProfileManager* profile_manager = g_browser_process->profile_manager();
     FilePath path = cmd_line.GetSwitchValuePath(switches::kProfileDirectory);
     path = profile_manager->user_data_dir().Append(path);
     profile_manager->CreateProfileAsync(path,
         base::Bind(&BrowserInit::ProcessCommandLineOnProfileCreated,
                    cmd_line, cur_dir));
     return;
   }
 
   Profile* profile = ProfileManager::GetLastUsedProfile();
   if (!profile) {
     // We should only be able to get here if the profile already exists and
     // has been created.
     NOTREACHED();
     return;
   }
-  ProcessCmdLineImpl(cmd_line, cur_dir, false, profile, NULL, NULL);
+  ProcessCmdLineImpl(cmd_line, cur_dir, false, profile, std::vector<Profile*>(),
+                     NULL, NULL);
 }