Restructure user-creation flow and surface errors

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 145 matching lines @@
 
   // Count number of extensions in this profile, if we know.
   if (extension_count != -1)
     UMA_HISTOGRAM_COUNTS_10000("Profile.AppCount", extension_count);
 }
 
 void QueueProfileDirectoryForDeletion(const base::FilePath& path) {
   ProfilesToDelete().push_back(path);
 }
 
-// Called upon completion of profile creation. This function takes care of
-// launching a new browser window and signing the user in to their Google
-// account.
-void OnOpenWindowForNewProfile(
-    chrome::HostDesktopType desktop_type,
-    const ProfileManager::CreateCallback& callback,
-    Profile* profile,
-    Profile::CreateStatus status) {
-  // Invoke the callback before we open a window for this new profile, so the
-  // callback has a chance to update the profile state first (to do things like
-  // sign in the profile).
-  if (!callback.is_null())
-    callback.Run(profile, status);
-
-  if (status == Profile::CREATE_STATUS_INITIALIZED) {
-
-    ProfileManager::FindOrCreateNewWindowForProfile(
-        profile,
-        chrome::startup::IS_PROCESS_STARTUP,
-        chrome::startup::IS_FIRST_RUN,
-        desktop_type,
-        false);
-  }
-}
-
 #if defined(OS_CHROMEOS)
 void CheckCryptohomeIsMounted(chromeos::DBusMethodCallStatus call_status,
                               bool is_mounted) {
   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
     LOG(ERROR) << "IsMounted call failed.";
     return;
   }
   if (!is_mounted)
     LOG(ERROR) << "Cryptohome is not mounted.";
 }
@@ skipping 284 matching lines @@
     const base::FilePath& profile_path,
     const CreateCallback& callback,
     const string16& name,
     const string16& icon_url,
     bool is_managed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure that this profile is not pending deletion.
   if (std::find(ProfilesToDelete().begin(), ProfilesToDelete().end(),
       profile_path) != ProfilesToDelete().end()) {
-    callback.Run(NULL, Profile::CREATE_STATUS_FAIL);
+    if (!callback.is_null())
+      callback.Run(NULL, Profile::CREATE_STATUS_FAIL);
     return;
   }
 
+  // Create the profile if needed and collect its ProfileInfo.
   ProfilesInfoMap::iterator iter = profiles_info_.find(profile_path);
+  ProfileInfo* info = NULL;
+
   if (iter != profiles_info_.end()) {
-    ProfileInfo* info = iter->second.get();
-    if (info->created) {
-      // Profile has already been created. Run callback immediately.
-      callback.Run(info->profile.get(), Profile::CREATE_STATUS_INITIALIZED);
-    } else {
-      // Profile is being created. Add callback to list.
-      info->callbacks.push_back(callback);
-    }
+    info = iter->second.get();
   } else {
     // Initiate asynchronous creation process.
-    ProfileInfo* info =
-        RegisterProfile(CreateProfileAsyncHelper(profile_path, this), false);
+    info = RegisterProfile(CreateProfileAsyncHelper(profile_path, this), false);
     ProfileInfoCache& cache = GetProfileInfoCache();
     // Get the icon index from the user's icon url
     size_t icon_index;
     std::string icon_url_std = UTF16ToASCII(icon_url);
     if (cache.IsDefaultAvatarIconUrl(icon_url_std, &icon_index)) {
       // add profile to cache with user selected name and avatar
       cache.AddProfileToCache(profile_path, name, string16(), icon_index,
                               is_managed);
     }
-    info->callbacks.push_back(callback);
 
     if (is_managed) {
       content::RecordAction(
           UserMetricsAction("ManagedMode_LocallyManagedUserCreated"));
     }
   }
+
+  // Call or enqueue the callback.
+  if (!callback.is_null()) {
+    if (iter != profiles_info_.end() && info->created) {
+        // Profile has already been created. Run callback immediately.
+        callback.Run(info->profile.get(), Profile::CREATE_STATUS_INITIALIZED);
+    } else {
+      // Profile is either already in the process of being created, or new.
+      // Add callback to the list.
+      info->callbacks.push_back(callback);
+    }
+  }
 }
 
 // static
 void ProfileManager::CreateDefaultProfileAsync(const CreateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath default_profile_dir = profile_manager->user_data_dir_;
   // TODO(mirandac): current directory will not always be default in the future
   default_profile_dir = default_profile_dir.Append(
@@ skipping 347 matching lines @@
   base::FilePath new_path = user_data_dir_;
 #if defined(OS_WIN)
   new_path = new_path.Append(ASCIIToUTF16(profile_name));
 #else
   new_path = new_path.Append(profile_name);
 #endif
   local_state->SetInteger(prefs::kProfilesNumCreated, ++next_directory);
   return new_path;
 }
 
-// TODO(robertshield): ProfileManager should not be opening windows and should
-// not have to care about HostDesktopType. See http://crbug.com/153864
 // static
 void ProfileManager::CreateMultiProfileAsync(
     const string16& name,
     const string16& icon_url,
     const CreateCallback& callback,
-    chrome::HostDesktopType desktop_type,
     bool is_managed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 
   profile_manager->CreateProfileAsync(new_path,
-                                      base::Bind(&OnOpenWindowForNewProfile,
-                                                 desktop_type,
-                                                 callback),
+                                      callback,
                                       name,
                                       icon_url,
                                       is_managed);
 }
 
 // static
 void ProfileManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kProfileLastUsed, std::string());
   registry->RegisterIntegerPref(prefs::kProfilesNumCreated, 1);
   registry->RegisterListPref(prefs::kProfilesLastActive);
@@ skipping 99 matching lines @@
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (!logged_in_ &&
       (!command_line.HasSwitch(switches::kTestType) ||
        command_line.HasSwitch(chromeos::switches::kLoginProfile))) {
     go_off_the_record = true;
   }
 #endif
   return go_off_the_record;
 }
 
-// TODO(robertshield): ProfileManager should not be opening windows and should
-// not have to care about HostDesktopType. See http://crbug.com/153864
 void ProfileManager::ScheduleProfileForDeletion(
     const base::FilePath& profile_dir,
-    chrome::HostDesktopType desktop_type) {
+    const CreateCallback& callback) {
   DCHECK(IsMultipleProfilesEnabled());
 
   PrefService* local_state = g_browser_process->local_state();
   ProfileInfoCache& cache = GetProfileInfoCache();
   if (profile_dir.BaseName().MaybeAsASCII() ==
       local_state->GetString(prefs::kProfileLastUsed)) {
     // Update the last used profile pref before closing browser windows. This
     // way the correct last used profile is set for any notification observers.
     std::string last_non_managed_profile;
     for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
       base::FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
       if (cur_path != profile_dir && !cache.ProfileIsManagedAtIndex(i)) {
         last_non_managed_profile = cur_path.BaseName().MaybeAsASCII();
         break;
       }
     }
     // If we're deleting the last (non-managed) profile, then create a new
     // profile in its place.
     if (last_non_managed_profile.empty()) {
       base::FilePath new_path = GenerateNextProfileDirectoryPath();
       // Make sure the last used profile path is pointing at it. This way the
       // correct last used profile is set for any notification observers.
       local_state->SetString(prefs::kProfileLastUsed,
                              new_path.BaseName().MaybeAsASCII());
-      // TODO(robertshield): This desktop type needs to come from the invoker,
-      // currently that involves plumbing this through web UI.
-      chrome::HostDesktopType desktop_type = chrome::HOST_DESKTOP_TYPE_NATIVE;
       CreateProfileAsync(new_path,
-                         base::Bind(&OnOpenWindowForNewProfile,
-                                    desktop_type,
-                                    CreateCallback()),
+                         callback,
                          string16(),
                          string16(),
                          false);
     } else {
       local_state->SetString(prefs::kProfileLastUsed, last_non_managed_profile);
     }
   }
 
   // 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.
@@ skipping 75 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }