Don't create a new profile when cleaning up stale ephemeral profiles.

chrome/browser/profiles/profile_manager.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/profiles/profile_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 627 matching lines @@
   }
   return *profile_info_cache_.get();
 }
 
 ProfileShortcutManager* ProfileManager::profile_shortcut_manager() {
   return profile_shortcut_manager_.get();
 }
 
 void ProfileManager::ScheduleProfileForDeletion(
     const base::FilePath& profile_dir,
+    bool suppress_profile_creation,
     const CreateCallback& callback) {
   DCHECK(profiles::IsMultipleProfilesEnabled());
 
   // Cancel all in-progress downloads before deleting the profile to prevent a
   // "Do you want to exit Google Chrome and cancel the downloads?" prompt
   // (crbug.com/336725).
   Profile* profile = GetProfileByPath(profile_dir);
   if (profile) {
     DownloadService* service =
         DownloadServiceFactory::GetForBrowserContext(profile);
@@ skipping 10 matching lines @@
     // Make sure that this profile is not pending deletion, and is not
     // legacy-supervised.
     if (cur_path != profile_dir &&
         !cache.ProfileIsLegacySupervisedAtIndex(i) &&
         !IsProfileMarkedForDeletion(cur_path)) {
       last_non_supervised_profile_path = cur_path;
       break;
     }
   }
 
-  base::FilePath new_path;
-  if (last_non_supervised_profile_path.empty()) {
+  base::FilePath new_path = last_non_supervised_profile_path;
+  if (new_path.empty()) {
     // If we are using --new-avatar-menu, then assign the default
     // placeholder avatar and name. Otherwise, use random ones.
-    bool is_new_avatar_menu = switches::IsNewAvatarMenu();
-    int avatar_index = profiles::GetPlaceholderAvatarIndex();
-    base::string16 new_avatar_url = is_new_avatar_menu ?
-        base::UTF8ToUTF16(profiles::GetDefaultAvatarIconUrl(avatar_index)) :
-        base::string16();
-    base::string16 new_profile_name = is_new_avatar_menu ?
-        cache.ChooseNameForNewProfile(avatar_index) : base::string16();
+    base::string16 new_avatar_url;
+    base::string16 new_profile_name;
+    if (switches::IsNewAvatarMenu()) {
+      int avatar_index = profiles::GetPlaceholderAvatarIndex();
+      new_avatar_url =
+          base::UTF8ToUTF16(profiles::GetDefaultAvatarIconUrl(avatar_index));
+      new_profile_name = cache.ChooseNameForNewProfile(avatar_index);
+    }
 
     new_path = GenerateNextProfileDirectoryPath();
-    CreateProfileAsync(new_path,
-                       base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
-                                  base::Unretained(this),
-                                  profile_dir,
-                                  new_path,
-                                  callback),
-                       new_profile_name,
-                       new_avatar_url,
-                       std::string());
+    if (!suppress_profile_creation) {
+      CreateProfileAsync(new_path,
+                         base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
+                                    base::Unretained(this),
+                                    profile_dir,
+                                    new_path,
+                                    callback),
+                         new_profile_name,
+                         new_avatar_url,
+                         std::string());
 
-    ProfileMetrics::LogProfileAddNewUser(
-        ProfileMetrics::ADD_NEW_USER_LAST_DELETED);
-    return;
+      ProfileMetrics::LogProfileAddNewUser(
+          ProfileMetrics::ADD_NEW_USER_LAST_DELETED);
+      return;
+    }
   }
 
 #if defined(OS_MACOSX)
   // On the Mac, the browser process is not killed when all browser windows are
   // closed, so just in case we are deleting the active profile, and no other
   // profile has been loaded, we must pre-load a next one.
   const std::string last_used_profile =
       g_browser_process->local_state()->GetString(prefs::kProfileLastUsed);
-  if (last_used_profile == profile_dir.BaseName().MaybeAsASCII() ||
-      last_used_profile == GetGuestProfilePath().BaseName().MaybeAsASCII()) {
+  if ((last_used_profile == profile_dir.BaseName().MaybeAsASCII() ||
+       last_used_profile == GetGuestProfilePath().BaseName().MaybeAsASCII()) &&
+      !suppress_profile_creation) {
+    DCHECK(!last_non_supervised_profile_path.empty());
     CreateProfileAsync(last_non_supervised_profile_path,
                        base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
                                   base::Unretained(this),
                                   profile_dir,
                                   last_non_supervised_profile_path,
                                   callback),
                        base::string16(),
                        base::string16(),
                        std::string());
     return;
   }
 #endif  // defined(OS_MACOSX)
 
-  FinishDeletingProfile(profile_dir, last_non_supervised_profile_path);
-}
-
-// static
-void ProfileManager::CleanUpStaleProfiles(
-    const std::vector<base::FilePath>& profile_paths) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-
-  for (std::vector<base::FilePath>::const_iterator it = profile_paths.begin();
-       it != profile_paths.end(); ++it) {
-    NukeProfileFromDisk(*it);
-  }
+  FinishDeletingProfile(profile_dir, new_path);
 }
 
 void ProfileManager::AutoloadProfiles() {
   // If running in the background is disabled for the browser, do not autoload
   // any profiles.
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state->HasPrefPath(prefs::kBackgroundModeEnabled) ||
       !local_state->GetBoolean(prefs::kBackgroundModeEnabled)) {
     return;
   }
@@ skipping 621 matching lines @@
       // Not the last window for this profile.
       return;
   }
 
   // If the last browser of a profile that is scheduled for deletion is closed
   // do that now.
   base::FilePath path = profile->GetPath();
   if (profile->GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles) &&
       !IsProfileMarkedForDeletion(path)) {
     g_browser_process->profile_manager()->ScheduleProfileForDeletion(
-        path, ProfileManager::CreateCallback());
+        path, false /* suppress_profile_creation */,
+        ProfileManager::CreateCallback());
   }
 }
 
 void ProfileManager::BrowserListObserver::OnBrowserSetLastActive(
     Browser* browser) {
   // If all browsers are being closed (e.g. the user is in the process of
   // shutting down), this event will be fired after each browser is
   // closed. This does not represent a user intention to change the active
   // browser so is not handled here.
   if (profile_manager_->closing_all_browsers_)
@@ skipping 20 matching lines @@
          status != Profile::CREATE_STATUS_REMOTE_FAIL);
 
   // Only run the code if the profile initialization has finished completely.
   if (status != Profile::CREATE_STATUS_INITIALIZED)
     return;
 
   if (IsProfileMarkedForDeletion(new_active_profile_path)) {
     // If the profile we tried to load as the next active profile has been
     // deleted, then retry deleting this profile to redo the logic to load
     // the next available profile.
-    ScheduleProfileForDeletion(profile_to_delete_path, original_callback);
+    ScheduleProfileForDeletion(profile_to_delete_path,
+                               false /* suppress_profile_creation */,
+                               original_callback);
     return;
   }
 
   FinishDeletingProfile(profile_to_delete_path, new_active_profile_path);
   if (!original_callback.is_null())
     original_callback.Run(loaded_profile, status);
 }
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }