Only return fully initialized profiles in ProfileManager::GetProfileByPath.

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 <list>
@@ skipping 56 matching lines @@
   // Get the profile for the currently active user.
   // Note that in case of a guest account this will return a 'suitable' profile.
   // 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.
+  // 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();
 
   // Explicit asynchronous creation of a profile located at |profile_path|.
   // If the profile has already been created then callback is called
   // immediately. Should be called on the UI thread.
   void CreateProfileAsync(const base::FilePath& profile_path,
                           const CreateCallback& callback,
@@ skipping 19 matching lines @@
   base::FilePath GetLastUsedProfileDir(const base::FilePath& user_data_dir);
 
   // 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
   // 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 profiles. Note, profiles order is NOT guaranteed to be
-  // related with the creation order.
+  // 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,
-  // return a pointer to the corresponding Profile object;
-  // otherwise return NULL.
+  // If a profile with the given path is currently managed by this object and
+  // fully initialized, return a pointer to the corresponding Profile object;
+  // otherwise return null.
   Profile* GetProfileByPath(const base::FilePath& path) const;
 
   // Creates a new profile in the next available multiprofile directory.
   // Directories are named "profile_1", "profile_2", etc., in sequence of
   // creation. (Because directories can be removed, however, it may be the case
   // that at some point the list of numbered profiles is not continuous.)
   // |callback| may be invoked multiple times (for CREATE_STATUS_INITIALIZED
   // and CREATE_STATUS_CREATED) so binding parameters with bind::Passed() is
   // prohibited. Returns the file path to the profile that will be created
   // asynchronously.
@@ skipping 108 matching lines @@
    private:
     DISALLOW_COPY_AND_ASSIGN(ProfileInfo);
   };
 
   // Returns the profile of the active user and / or the off the record profile
   // if needed. This adds the profile to the ProfileManager if it doesn't
   // already exist. The method will return NULL if the profile doesn't exist
   // and we can't create it.
   // The profile used can be overridden by using --login-profile on cros.
   Profile* GetActiveUserOrOffTheRecordProfileFromPath(
-               const base::FilePath& user_data_dir);
+      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.
   Profile* CreateAndInitializeProfile(const base::FilePath& profile_dir);
 
   // Schedules the profile at the given path to be deleted on shutdown.
   void FinishDeletingProfile(const base::FilePath& profile_dir);
 
   // Registers profile with given info. Returns pointer to created ProfileInfo
   // entry.
   ProfileInfo* RegisterProfile(Profile* profile, bool created);
 
-  // Returns ProfileInfo associated with given |path|, registred earlier with
+  // Returns ProfileInfo associated with given |path|, registered earlier with
   // RegisterProfile.
   ProfileInfo* GetProfileInfoByPath(const base::FilePath& path) const;
 
+  // Returns a registered profile. In contrast to GetProfileByPath(), this will
+  // also return a profile that is not fully initialized yet, so this method
+  // should be used carefully.
+  Profile* GetProfileByPathInternal(const base::FilePath& path) const;
+
   // Adds |profile| to the profile info cache if it hasn't been added yet.
   void AddProfileToCache(Profile* profile);
 
   // Apply settings for (desktop) Guest User profile.
   void SetGuestProfilePrefs(Profile* profile);
 
   // For ChromeOS, determines if profile should be otr.
   bool ShouldGoOffTheRecord(Profile* profile);
 
   void RunCallbacks(const std::vector<CreateCallback>& callbacks,
@@ skipping 80 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_