Getting rid of GetDefaultProfile(), clean up of ProfileManager (which was in a serious mess)

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 27 matching lines @@
   virtual ~ProfileManager();
 
 #if defined(ENABLE_SESSION_SERVICE)
   // Invokes SessionServiceFactory::ShutdownForProfile() for all profiles.
   static void ShutdownSessionServices();
 #endif
 
   // Physically remove deleted profile directories from disk.
   static void NukeDeletedProfilesFromDisk();
 
-  // Only to be used in ChromeOS:
-  // This is a temporary solution to get rid of the DEPRICATED GetDefaultProfile
-  // functions below. Going forward we will do architectural changes to reduce
-  // the Profile to get the browser context instead and by moving it into ash,
-  // but for the short time fix we add these two functions here, enabling us to
-  // get rid of GetDefaultProfile as a first step.
-  // TODO(skuhne): Move into ash's new user management function.
+  // Same as instance method but provides the default user_data_dir as well.
+  // If the Profile is going to be used to open a new window then consider using
+  // GetLastUsedProfileAllowedByPolicy() instead.
+  static Profile* GetLastUsedProfile();
+
+  // Same as GetLastUsedProfile() but returns the incognito Profile if
+  // incognito mode is forced. This should be used if the last used Profile
+  // will be used to open new browser windows.
+  static Profile* GetLastUsedProfileAllowedByPolicy();
+
+  // Same as instance method but provides the default user_data_dir as well.
+  static std::vector<Profile*> GetLastOpenedProfiles();
 
   // Get the profile for the user which created the current session.
   // 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* GetPrimaryUserProfile();
 
   // 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();
 
-  // DEPRECATED: DO NOT USE. Function will be removed soon (crbug.com/322682).
-  // Use GetPrimaryUserProfile or GetActiveUserProfile instead.
-  // Returns the default profile. This adds the profile to the
-  // ProfileManager if it doesn't already exist. This method returns 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.
-  // Note that in case of a guest account this will return a 'suitable' profile.
-  static Profile* GetDefaultProfile();
-
   // 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.
   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
@@ skipping 10 matching lines @@
 
   // Returns the directory where the first created profile is stored,
   // relative to the user data directory currently in use..
   base::FilePath GetInitialProfileDir();
 
   // Get the Profile last used (the Profile to which owns the most recently
   // focused window) with this Chrome build. If no signed profile has been
   // stored in Local State, hand back the Default profile.
   Profile* GetLastUsedProfile(const base::FilePath& user_data_dir);
 
-  // Same as instance method but provides the default user_data_dir as well.
-  // If the Profile is going to be used to open a new window then consider using
-  // GetLastUsedProfileAllowedByPolicy() instead.
-  static Profile* GetLastUsedProfile();
-
-  // Same as GetLastUsedProfile() but returns the incognito Profile if
-  // incognito mode is forced. This should be used if the last used Profile
-  // will be used to open new browser windows.
-  static Profile* GetLastUsedProfileAllowedByPolicy();
-
   // 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 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);
 
-  // Same as instance method but provides the default user_data_dir as well.
-  static std::vector<Profile*> GetLastOpenedProfiles();
-
   // Returns created profiles. Note, profiles order is NOT guaranteed to be
   // related with the creation order.
   std::vector<Profile*> GetLoadedProfiles() const;
 
-  // content::NotificationObserver implementation.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
-
   // If a profile with the given path is currently managed by this object,
   // return a pointer to the corresponding Profile object;
   // otherwise return NULL.
   Profile* GetProfileByPath(const base::FilePath& path) const;
 
-  // Profile::Delegate implementation:
-  virtual void OnProfileCreated(Profile* profile,
-                                bool success,
-                                bool is_new_profile) OVERRIDE;
-
-  // Add or remove a profile launcher to/from the list of launchers waiting for
-  // new profiles to be created from the multi-profile menu.
-  void AddProfileLauncher(NewProfileLauncher* profile_launcher);
-  void RemoveProfileLauncher(NewProfileLauncher* profile_launcher);
-
   // 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.
   static base::FilePath CreateMultiProfileAsync(
       const base::string16& name,
@@ skipping 27 matching lines @@
 
   // Called on start-up if there are any stale ephemeral profiles to be deleted.
   // This can be the case if the browser has crashed and the clean-up code had
   // no chance to run then.
   static void CleanUpStaleProfiles(
       const std::vector<base::FilePath>& profile_paths);
 
   // Autoloads profiles if they are running background apps.
   void AutoloadProfiles();
 
-  // Sign-Out a profile against use until re-authentication.
-  void SignOutProfile(Profile* profile);
-
   // Initializes user prefs of |profile|. This includes profile name and
   // avatar values.
   void InitProfileUserPrefs(Profile* profile);
 
   // Register and add testing profile to the ProfileManager. Use ONLY in tests.
   // This allows the creation of Profiles outside of the standard creation path
   // for testing. If |addToCache|, adds to ProfileInfoCache as well.
   // If |start_deferred_task_runners|, starts the deferred task runners.
   // Use ONLY in tests.
   void RegisterTestingProfile(Profile* profile,
                               bool addToCache,
                               bool start_deferred_task_runners);
 
   const base::FilePath& user_data_dir() const { return user_data_dir_; }
 
   // For ChromeOS, determines if the user has logged in to a real profile.
   bool IsLoggedIn() const { return logged_in_; }
 
+  // content::NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  // Profile::Delegate implementation:
+  virtual void OnProfileCreated(Profile* profile,
+                                bool success,
+                                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.
   virtual Profile* CreateProfileHelper(const base::FilePath& path);
@@ skipping 47 matching lines @@
   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
   // RegisterProfile.
   ProfileInfo* GetProfileInfoByPath(const base::FilePath& path) const;
 
-  typedef std::pair<base::FilePath, base::string16> ProfilePathAndName;
-  typedef std::vector<ProfilePathAndName> ProfilePathAndNames;
-  ProfilePathAndNames GetSortedProfilesFromDirectoryMap();
-
-  static bool CompareProfilePathAndName(
-      const ProfileManager::ProfilePathAndName& pair1,
-      const ProfileManager::ProfilePathAndName& pair2);
-
   // 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,
                     Profile* profile,
                     Profile::CreateStatus status);
 
-  // If the |loaded_profile| has been loaded succesfully (according to |status|)
-  // and isn't already scheduled for deletion, then finishes adding
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
+  class BrowserListObserver : public chrome::BrowserListObserver {
+   public:
+    explicit BrowserListObserver(ProfileManager* manager);
+    virtual ~BrowserListObserver();
+
+    // chrome::BrowserListObserver implementation.
+    virtual void OnBrowserAdded(Browser* browser) OVERRIDE;
+    virtual void OnBrowserRemoved(Browser* browser) OVERRIDE;
+    virtual void OnBrowserSetLastActive(Browser* browser) OVERRIDE;
+
+   private:
+    ProfileManager* profile_manager_;
+    DISALLOW_COPY_AND_ASSIGN(BrowserListObserver);
+  };
+#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
+
+#if defined(OS_MACOSX)
+  // If the |loaded_profile| has been loaded successfully (according to
+  // |status|) and isn't already scheduled for deletion, then finishes adding
   // |profile_to_delete_dir| to the queue of profiles to be deleted, and updates
   // the kProfileLastUsed preference based on |last_non_managed_profile_path|.
   void OnNewActiveProfileLoaded(
       const base::FilePath& profile_to_delete_path,
       const base::FilePath& last_non_managed_profile_path,
       const CreateCallback& original_callback,
       Profile* loaded_profile,
       Profile::CreateStatus status);
+#endif
 
   content::NotificationRegistrar registrar_;
 
   // The path to the user data directory (DIR_USER_DATA).
   const base::FilePath user_data_dir_;
 
   // Indicates that a user has logged in and that the profile specified
   // in the --login-profile command line argument should be used as the
   // default.
   bool logged_in_;
 
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
+  BrowserListObserver browser_list_observer_;
+#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
+
   // Maps profile path to ProfileInfo (if profile has been created). Use
   // RegisterProfile() to add into this map. This map owns all loaded profile
   // objects in a running instance of Chrome.
   typedef std::map<base::FilePath, linked_ptr<ProfileInfo> > ProfilesInfoMap;
   ProfilesInfoMap profiles_info_;
 
   // Object to cache various information about profiles. Contains information
   // about every profile which has been created for this instance of Chrome,
   // if it has not been explicitly deleted.
   scoped_ptr<ProfileInfoCache> profile_info_cache_;
 
   // Manages the process of creating, deleteing and updating Desktop shortcuts.
   scoped_ptr<ProfileShortcutManager> profile_shortcut_manager_;
 
-#if !defined(OS_ANDROID) && !defined(OS_IOS)
-  class BrowserListObserver : public chrome::BrowserListObserver {
-   public:
-    explicit BrowserListObserver(ProfileManager* manager);
-    virtual ~BrowserListObserver();
-
-    // chrome::BrowserListObserver implementation.
-    virtual void OnBrowserAdded(Browser* browser) OVERRIDE;
-    virtual void OnBrowserRemoved(Browser* browser) OVERRIDE;
-    virtual void OnBrowserSetLastActive(Browser* browser) OVERRIDE;
-
-   private:
-    ProfileManager* profile_manager_;
-    DISALLOW_COPY_AND_ASSIGN(BrowserListObserver);
-  };
-
-  BrowserListObserver browser_list_observer_;
-#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
-
   // For keeping track of the last active profiles.
   std::map<Profile*, int> browser_counts_;
   // On startup we launch the active profiles in the order they became active
   // during the last run. This is why they are kept in a list, not in a set.
   std::vector<Profile*> active_profiles_;
   bool closing_all_browsers_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileManager);
 };
 
 // Same as the ProfileManager, but doesn't initialize some services of the
 // profile. This one is useful in unittests.
 class ProfileManagerWithoutInit : public ProfileManager {
  public:
   explicit ProfileManagerWithoutInit(const base::FilePath& user_data_dir);
 
  protected:
   virtual void DoFinalInitForServices(Profile*, bool) OVERRIDE {}
   virtual void DoFinalInitLogging(Profile*) OVERRIDE {}
 };
 
 #endif  // CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_