Add fallback behavior if the last used profile cannot initialize

chrome/browser/ui/startup/startup_browser_creator.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/startup/startup_browser_creator.h"
 
 #include <stddef.h>
 
 #include <algorithm>  // For max().
 #include <memory>
@@ skipping 866 matching lines @@
 #if defined(ENABLE_APP_LIST)
   // If we are showing the app list then chrome isn't shown so load the app
   // list's profile rather than chrome's.
   if (command_line.HasSwitch(switches::kShowAppList))
     return AppListService::Get()->GetProfilePath(user_data_dir);
 #endif
 
   return g_browser_process->profile_manager()->GetLastUsedProfileDir(
       user_data_dir);
 }
+
+#if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
+Profile* GetStartupProfile(const base::FilePath& user_data_dir,
+                           const base::CommandLine& command_line) {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+
+  base::FilePath profile_path =
+      GetStartupProfilePath(user_data_dir, command_line);
+  Profile* profile = profile_manager->GetProfile(profile_path);
+
+  // If we're using the --new-profile-management flag and this profile is
+  // locked, then we should show the user manager instead. This is done by
+  // returning the guest profile. The initialization of guest profile is
+  // possible to fail.

[Peter Kasting, 2016/07/11 02:58:59]

Nit: Let's try to keep the bits about the guest profile and it failing init only
in the comment on the next block.  Here I would just say:

If there is no entry in profile attributes storage, the profile is deleted, and
we should show the user manager.  Also, when using --new-profile-management, if
the profile is locked we should show the user manager as well.  When neither of
these is true, we can safely start up with |profile|.

[WC Leung, 2016/07/18 17:56:18]

Sounds good.

+  // If there is no entry in profile attributes storage, it means the profile is
+  // deleted. In this case we should show the user manager.
+  auto& storage = profile_manager->GetProfileAttributesStorage();
+  ProfileAttributesEntry* entry;
+  bool has_entry = storage.GetProfileAttributesWithPath(profile_path, &entry);
+  if (has_entry && (!switches::IsNewProfileManagement() ||
+                    !entry->IsSigninRequired() || !profile)) {
+    return profile;
+  }
+
+  // To show the user manager, return the guest profile. However, we also
+  // need to know that the system profile (where the user manager lives in)
+  // exists or is creatable. If either profile is failing, return null to
+  // denote failure.

[Peter Kasting, 2016/07/11 02:58:59]

Nit: How about:

We want the caller to show the user manager.  To indicate this, return the guest
profile.  However, we can only do this if the system profile (where the user
manager lives) also exists (or is creatable).

[WC Leung, 2016/07/18 17:56:18]

Sounds good. Thanks.

+  return profile_manager->GetProfile(ProfileManager::GetSystemProfilePath()) ?
+         profile_manager->GetProfile(ProfileManager::GetGuestProfilePath()) :
+         nullptr;
+}
+
+Profile* GetFallbackStartupProfile() {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  // The only known reason for profiles to fail initialization is unable to
+  // create the profile directory. This has already happened in the last used
+  // profile before calling this function. Therefore, creation of all new
+  // profiles is expected to fail. So only existing profiles are attempted for
+  // fallback.
+
+  // If the last used profile is unable to initialize, see if any of other last
+  // opened profiles can initialize successfully.
+  std::vector<Profile*> last_opened_profiles =
+      ProfileManager::GetLastOpenedProfiles();
+  auto& storage = profile_manager->GetProfileAttributesStorage();
+  for (Profile* last_opened_profile : last_opened_profiles) {
+    // Return any profile that is not signed out.
+    ProfileAttributesEntry* entry;
+    bool has_entry = storage.GetProfileAttributesWithPath(
+                         last_opened_profile->GetPath(), &entry);
+    if (!has_entry || !entry->IsSigninRequired())
+      return last_opened_profile;
+  }
+
+  // If it still fails, try to initialize a guest profile and a system profile.
+  // Show the user manager if this is successful.
+  Profile* guest_profile =
+      profile_manager->GetProfile(ProfileManager::GetGuestProfilePath());
+  Profile* system_profile =
+      profile_manager->GetProfile(ProfileManager::GetSystemProfilePath());
+  if (guest_profile && system_profile)
+    return guest_profile;
+
+  // If still fails, try to open any profile that is not signed out.
+  std::vector<ProfileAttributesEntry*> entries =
+      storage.GetAllProfilesAttributes();
+  for (ProfileAttributesEntry* entry : entries) {
+    if (!entry->IsSigninRequired()) {
+      Profile* profile = profile_manager->GetProfile(entry->GetPath());
+      if (profile)
+        return profile;
+    }
+  }
+
+  return nullptr;
+}
+#endif  // !defined(OS_CHROMEOS) && !defined(OS_ANDROID)