Skip profiles in GetLastOpenedProfiles that fail to initialize

chrome/browser/profiles/profile_manager.h

 // 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.
 
 // This class keeps track of the currently-active profiles in the runtime.
 
 #ifndef CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_
 #define CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_
 
 #include <stddef.h>
@@ skipping 68 matching lines @@
   // This function is temporary and will soon be moved to ash. As such avoid
   // using it at all cost.
   // TODO(skuhne): Move into ash's new user management function.
   static Profile* GetActiveUserProfile();
 
   // Returns a profile for a specific profile directory within the user data
   // dir. This will return an existing profile it had already been created,
   // otherwise it will create and manage it.
   // Because this method might synchronously create a new profile, it should
   // only be called for the initial profile or in tests, where blocking is
-  // acceptable.
+  // acceptable. Returns null if creation of the new profile fails.
   // TODO(bauerb): Migrate calls from other code to GetProfileByPath(), then
   // make this method private.
   Profile* GetProfile(const base::FilePath& profile_dir);
 
   // Returns total number of profiles available on this machine.
   size_t GetNumberOfProfiles();
 
   // Asynchronously loads an existing profile given its |profile_name| within
   // the user data directory, optionally in |incognito| mode. The |callback|
   // will be called with the Profile when it has been loaded, or with a nullptr
@@ skipping 29 matching lines @@
   Profile* GetLastUsedProfile(const base::FilePath& user_data_dir);
 
   // Get the path of the last used profile, or if that's undefined, the default
   // profile.
   base::FilePath GetLastUsedProfileDir(const base::FilePath& user_data_dir);
 
   // Get the name of the last used profile, or if that's undefined, the default
   // profile.
   std::string GetLastUsedProfileName();
 
-  // Get the Profiles which are currently open, i.e., have open browsers, or
-  // were open the last time Chrome was running. The Profiles appear in the
-  // order they were opened. The last used profile will be on the list, but its
+  // Get the Profiles which are currently open, i.e. have open browsers or were
+  // open the last time Chrome was running. Profiles that fail to initialize are
+  // skipped. The Profiles appear in the order they were opened. The last used
+  // profile will be on the list if it is initialized successfully, but its
   // index on the list will depend on when it was opened (it is not necessarily
   // the last one).
   std::vector<Profile*> GetLastOpenedProfiles(
       const base::FilePath& user_data_dir);
 
   // Returns created and fully initialized profiles. Note, profiles order is NOT
   // guaranteed to be related with the creation order.
   std::vector<Profile*> GetLoadedProfiles() const;
 
   // If a profile with the given path is currently managed by this object and
@@ skipping 88 matching lines @@
                         bool is_new_profile) override;
 
  protected:
   // Does final initial actions.
   virtual void DoFinalInit(Profile* profile, bool go_off_the_record);
   virtual void DoFinalInitForServices(Profile* profile, bool go_off_the_record);
   virtual void DoFinalInitLogging(Profile* profile);
 
   // Creates a new profile by calling into the profile's profile creation
   // method. Virtual so that unittests can return a TestingProfile instead
-  // of the Profile's result.
+  // of the Profile's result. Returns null if creation fails.
   virtual Profile* CreateProfileHelper(const base::FilePath& path);
 
   // Creates a new profile asynchronously by calling into the profile's
   // asynchronous profile creation method. Virtual so that unittests can return
   // a TestingProfile instead of the Profile's result.
   virtual Profile* CreateProfileAsyncHelper(const base::FilePath& path,
                                             Delegate* delegate);
 
  private:
   friend class TestingProfileManager;
@@ skipping 26 matching lines @@
   Profile* GetActiveUserOrOffTheRecordProfileFromPath(
       const base::FilePath& user_data_dir);
 
   // Adds a pre-existing Profile object to the set managed by this
   // ProfileManager. This ProfileManager takes ownership of the Profile.
   // The Profile should not already be managed by this ProfileManager.
   // Returns true if the profile was added, false otherwise.
   bool AddProfile(Profile* profile);
 
   // Synchronously creates and returns a profile. This handles both the full
-  // creation and adds it to the set managed by this ProfileManager.
+  // creation and adds it to the set managed by this ProfileManager. Returns
+  // null if fails.

[Peter Kasting, 2016/06/01 19:36:17]

Nit: "if creation fails" (it is the creation stage that would fail, right?)

[WC Leung, 2016/06/03 20:08:42]

Done.

   Profile* CreateAndInitializeProfile(const base::FilePath& profile_dir);
 
 #if !defined(OS_ANDROID)
   // Schedules the profile at the given path to be deleted on shutdown,
   // and marks the new profile as active.
   void FinishDeletingProfile(const base::FilePath& profile_dir,
                              const base::FilePath& new_active_profile_dir);
 #endif
 
   // Registers profile with given info. Returns pointer to created ProfileInfo
@@ skipping 109 matching lines @@
 class ProfileManagerWithoutInit : public ProfileManager {
  public:
   explicit ProfileManagerWithoutInit(const base::FilePath& user_data_dir);
 
  protected:
   void DoFinalInitForServices(Profile*, bool) override {}
   void DoFinalInitLogging(Profile*) override {}
 };
 
 #endif  // CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_