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

chrome/browser/profiles/profile_manager.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 <set>
 
 #include "chrome/browser/profiles/profile_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 163 matching lines @@
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetDefaultProfile(profile_manager->user_data_dir_);
 }
 
 // static
 Profile* ProfileManager::GetLastUsedProfile() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetLastUsedProfile(profile_manager->user_data_dir_);
 }
 
+// static
+std::vector<Profile*> ProfileManager::GetLastActiveProfiles() {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  return profile_manager->GetLastActiveProfiles(
+      profile_manager->user_data_dir_);
+}
+
 ProfileManager::ProfileManager(const FilePath& user_data_dir)
     : user_data_dir_(user_data_dir),
       logged_in_(false),
-      will_import_(false) {
+      will_import_(false),
+      shutdown_started_(false) {
   BrowserList::AddObserver(this);
 #if defined(OS_CHROMEOS)
   registrar_.Add(
       this,
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::NotificationService::AllSources());
 #endif
+  registrar_.Add(
+      this,
+      chrome::NOTIFICATION_BROWSER_OPENED,
+      content::NotificationService::AllSources());
+  registrar_.Add(
+      this,
+      chrome::NOTIFICATION_BROWSER_CLOSED,
+      content::NotificationService::AllSources());
+  registrar_.Add(
+      this,
+      content::NOTIFICATION_APP_EXITING,
+      content::NotificationService::AllSources());
 }
 
 ProfileManager::~ProfileManager() {
   BrowserList::RemoveObserver(this);
 #if defined(OS_WIN)
   if (profile_shortcut_manager_.get())
     profile_info_cache_->RemoveObserver(profile_shortcut_manager_.get());
 #endif
 }
 
@@ skipping 43 matching lines @@
   DCHECK(local_state);
 
   if (local_state->HasPrefPath(prefs::kProfileLastUsed))
     last_profile_used = local_state->GetString(prefs::kProfileLastUsed);
   last_used_profile_dir = last_profile_used.empty() ?
       last_used_profile_dir.AppendASCII(chrome::kInitialProfile) :
       last_used_profile_dir.AppendASCII(last_profile_used);
   return GetProfile(last_used_profile_dir);
 }
 
+std::vector<Profile*> ProfileManager::GetLastActiveProfiles(
+    const FilePath& user_data_dir) {
+  PrefService* local_state = g_browser_process->local_state();
+  DCHECK(local_state);
+
+  std::vector<Profile*> to_return;
+  if (local_state->HasPrefPath(prefs::kProfilesLastActive)) {
+    const ListValue* profile_list =
+        local_state->GetList(prefs::kProfilesLastActive);
+    if (profile_list) {
+      ListValue::const_iterator it;
+      std::string profile;
+      for (it = profile_list->begin(); it != profile_list->end(); ++it) {
+        if (!(*it)->GetAsString(&profile) || profile.empty()) {
+          LOG(WARNING) << "Invalid entry in " << prefs::kProfilesLastActive;
+          continue;
+        }
+        to_return.push_back(GetProfile(user_data_dir.AppendASCII(profile)));
+      }
+    }
+  }
+  return to_return;
+}
+
 Profile* ProfileManager::GetDefaultProfile(const FilePath& user_data_dir) {
   FilePath default_profile_dir(user_data_dir);
   default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
 #if defined(OS_CHROMEOS)
   if (!logged_in_) {
     Profile* profile = GetProfile(default_profile_dir);
     // For cros, return the OTR profile so we never accidentally keep
     // user data in an unencrypted profile. But doing this makes
     // many of the browser and ui tests fail. We do return the OTR profile
     // if the login-profile switch is passed so that we can test this.
@@ skipping 138 matching lines @@
   if (type == chrome::NOTIFICATION_LOGIN_USER_CHANGED) {
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     if (!command_line.HasSwitch(switches::kTestType)) {
       // If we don't have a mounted profile directory we're in trouble.
       // TODO(davemoore) Once we have better api this check should ensure that
       // our profile directory is the one that's mounted, and that it's mounted
       // as the current user.
       CHECK(chromeos::CrosLibrary::Get()->GetCryptohomeLibrary()->IsMounted());
     }
     logged_in_ = true;
+    return;
   }
 #endif
+  if (shutdown_started_)
+    return;
+
+  bool update_active_profiles = false;
+  switch (type) {
+    case content::NOTIFICATION_APP_EXITING: {
+      // Ignore any browsers closing from now on.
+      shutdown_started_ = true;
+      break;
+    }
+    case chrome::NOTIFICATION_BROWSER_OPENED: {
+      Browser* browser = content::Source<Browser>(source).ptr();
+      DCHECK(browser);
+      Profile* profile = browser->profile();
+      DCHECK(profile);
+      if (++browser_counts_[profile] == 1) {
+        active_profiles_.push_back(profile);
+        update_active_profiles = true;
+      }
+      break;
+    }
+    case chrome::NOTIFICATION_BROWSER_CLOSED: {
+      Browser* browser = content::Source<Browser>(source).ptr();
+      DCHECK(browser);
+      Profile* profile = browser->profile();
+      DCHECK(profile);
+      if (--browser_counts_[profile] == 0) {
+        active_profiles_.erase(
+            std::remove(active_profiles_.begin(), active_profiles_.end(),
+                        profile),
+            active_profiles_.end());
+        update_active_profiles = true;
+      }
+      break;
+    }
+    default:

[Miranda Callahan, 2012/01/09 14:38:55]

default block should also have braces.

[marja, 2012/01/10 14:12:03]

Done.

+      NOTREACHED();
+      break;
+  }
+  if (update_active_profiles) {
+    PrefService* local_state = g_browser_process->local_state();
+    DCHECK(local_state);
+    ListPrefUpdate update(local_state, prefs::kProfilesLastActive);
+    ListValue* profile_list = update.Get();
+
+    profile_list->Clear();
+    std::vector<Profile*>::const_iterator it;
+    for (it = active_profiles_.begin(); it != active_profiles_.end(); ++it) {
+      profile_list->Append(
+          new StringValue((*it)->GetPath().BaseName().MaybeAsASCII()));
+    }
+  }
 }
 
 void ProfileManager::SetWillImport() {
   will_import_ = true;
 }
 
 void ProfileManager::OnImportFinished(Profile* profile) {
   will_import_ = false;
   DCHECK(profile);
   content::NotificationService::current()->Notify(
@@ skipping 118 matching lines @@
   FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 
   profile_manager->CreateProfileAsync(new_path,
                                       base::Bind(&OnOpenWindowForNewProfile));
 }
 
 // static
 void ProfileManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kProfileLastUsed, "");
   prefs->RegisterIntegerPref(prefs::kProfilesNumCreated, 1);
+  prefs->RegisterListPref(prefs::kProfilesLastActive);
 }
 
 size_t ProfileManager::GetNumberOfProfiles() {
   return GetProfileInfoCache().GetNumberOfProfiles();
 }
 
 bool ProfileManager::CompareProfilePathAndName(
     const ProfileManager::ProfilePathAndName& pair1,
     const ProfileManager::ProfilePathAndName& pair2) {
   int name_compare = pair1.second.compare(pair2.second);
@@ skipping 176 matching lines @@
   profile_info_cache_->RemoveObserver(profile_shortcut_manager_.get());
 }
 #endif
 
 void ProfileManager::RunCallbacks(const std::vector<CreateCallback>& callbacks,
                                   Profile* profile,
                                   Profile::CreateStatus status) {
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run(profile, status);
 }