Revert of Wait until a new profile has been created before deleting the active profile.

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 540 matching lines @@
 Profile* ProfileManager::GetProfileByPathInternal(
     const base::FilePath& path) const {
   TRACE_EVENT0("browser", "ProfileManager::GetProfileByPathInternal");
   ProfileInfo* profile_info = GetProfileInfoByPath(path);
   return profile_info ? profile_info->profile.get() : nullptr;
 }
 
 Profile* ProfileManager::GetProfileByPath(const base::FilePath& path) const {
   TRACE_EVENT0("browser", "ProfileManager::GetProfileByPath");
   ProfileInfo* profile_info = GetProfileInfoByPath(path);
-  return (profile_info && profile_info->created) ? profile_info->profile.get()
-                                                 : nullptr;
+  return profile_info && profile_info->created ? profile_info->profile.get()
+                                               : nullptr;
 }
 
 // static
 base::FilePath ProfileManager::CreateMultiProfileAsync(
     const base::string16& name,
     const base::string16& icon_url,
     const CreateCallback& callback,
     const std::string& supervised_user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 70 matching lines @@
   // 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);
     service->CancelDownloads();
   }
 
+  PrefService* local_state = g_browser_process->local_state();
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   // If we're deleting the last (non-legacy-supervised) profile, then create a
   // new profile in its place.
   base::FilePath last_non_supervised_profile_path;
   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
     base::FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
     // Make sure that this profile is not pending deletion, and is not
     // legacy-supervised.
     if (cur_path != profile_dir &&
@@ skipping 11 matching lines @@
     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();
 
     new_path = GenerateNextProfileDirectoryPath();
     CreateProfileAsync(new_path,
-                       base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
-                                  base::Unretained(this),
-                                  profile_dir,
-                                  new_path,
-                                  callback),
+                       callback,
                        new_profile_name,
                        new_avatar_url,
                        std::string());
 
     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.
+  // Update the last used profile pref before closing browser windows. This
+  // way the correct last used profile is set for any notification observers.
   const std::string last_used_profile =
-      g_browser_process->local_state()->GetString(prefs::kProfileLastUsed);
+      local_state->GetString(prefs::kProfileLastUsed);
   if (last_used_profile == profile_dir.BaseName().MaybeAsASCII() ||
       last_used_profile == GetGuestProfilePath().BaseName().MaybeAsASCII()) {
-    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;
+    const std::string last_non_supervised_profile =
+        last_non_supervised_profile_path.BaseName().MaybeAsASCII();
+    if (last_non_supervised_profile.empty()) {
+      DCHECK(!new_path.empty());
+      local_state->SetString(prefs::kProfileLastUsed,
+                             new_path.BaseName().MaybeAsASCII());
+    } else {
+      // 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.
+#if defined(OS_MACOSX)
+      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;
+#else
+      // For OS_MACOSX the pref is updated in the callback to make sure that
+      // it isn't used before the profile is actually loaded.
+      local_state->SetString(prefs::kProfileLastUsed,
+                             last_non_supervised_profile);
+#endif
+    }
   }
-#endif  // defined(OS_MACOSX)
-
-  FinishDeletingProfile(profile_dir, last_non_supervised_profile_path);
+  FinishDeletingProfile(profile_dir);
 }
 
 // static
 void ProfileManager::CleanUpStaleProfiles(
     const std::vector<base::FilePath>& profile_paths) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   for (std::vector<base::FilePath>::const_iterator it = profile_paths.begin();
        it != profile_paths.end(); ++it) {
     NukeProfileFromDisk(*it);
@@ skipping 413 matching lines @@
   CHECK(!GetProfileByPathInternal(profile_dir));
   Profile* profile = CreateProfileHelper(profile_dir);
   DCHECK(profile);
   if (profile) {
     bool result = AddProfile(profile);
     DCHECK(result);
   }
   return profile;
 }
 
-void ProfileManager::FinishDeletingProfile(
-    const base::FilePath& profile_dir,
-    const base::FilePath& new_active_profile_dir) {
-  // Update the last used profile pref before closing browser windows. This
-  // way the correct last used profile is set for any notification observers.
-  g_browser_process->local_state()->SetString(
-      prefs::kProfileLastUsed,
-      new_active_profile_dir.BaseName().MaybeAsASCII());
-
+void ProfileManager::FinishDeletingProfile(const base::FilePath& profile_dir) {
   ProfileInfoCache& cache = GetProfileInfoCache();
   // TODO(sail): Due to bug 88586 we don't delete the profile instance. Once we
   // start deleting the profile instance we need to close background apps too.
   Profile* profile = GetProfileByPath(profile_dir);
 
   if (profile) {
     // TODO: Migrate additional code in this block to observe this notification
     // instead of being implemented here.
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
@@ skipping 191 matching lines @@
 
   // Don't remember ephemeral profiles as last because they are not going to
   // persist after restart.
   if (last_active->GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles))
     return;
 
   profile_manager_->UpdateLastUser(last_active);
 }
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
+#if defined(OS_MACOSX)
 void ProfileManager::OnNewActiveProfileLoaded(
     const base::FilePath& profile_to_delete_path,
-    const base::FilePath& new_active_profile_path,
+    const base::FilePath& last_non_supervised_profile_path,
     const CreateCallback& original_callback,
     Profile* loaded_profile,
     Profile::CreateStatus status) {
   DCHECK(status != Profile::CREATE_STATUS_LOCAL_FAIL &&
          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);
-    return;
+  if (status == Profile::CREATE_STATUS_INITIALIZED) {
+    if (IsProfileMarkedForDeletion(last_non_supervised_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);
+    } else {
+      // Update the local state as promised in the ScheduleProfileForDeletion.
+      g_browser_process->local_state()->SetString(
+          prefs::kProfileLastUsed,
+          last_non_supervised_profile_path.BaseName().MaybeAsASCII());
+      FinishDeletingProfile(profile_to_delete_path);
+    }
   }
-
-  FinishDeletingProfile(profile_to_delete_path, new_active_profile_path);
-  if (!original_callback.is_null())
-    original_callback.Run(loaded_profile, status);
 }
+#endif
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }