1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 // This class keeps track of the currently-active profiles in the runtime.
7 #ifndef CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_
8 #define CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_
13 #include "base/basictypes.h"
14 #include "base/containers/hash_tables.h"
15 #include "base/files/file_path.h"
16 #include "base/gtest_prod_util.h"
17 #include "base/memory/linked_ptr.h"
18 #include "base/memory/scoped_ptr.h"
19 #include "base/message_loop/message_loop.h"
20 #include "base/threading/non_thread_safe.h"
21 #include "chrome/browser/profiles/profile.h"
22 #include "chrome/browser/profiles/profile_shortcut_manager.h"
23 #include "chrome/browser/ui/browser_list_observer.h"
24 #include "content/public/browser/notification_observer.h"
25 #include "content/public/browser/notification_registrar.h"
28 class NewProfileLauncher
;
29 class ProfileInfoCache
;
31 class ProfileManager
: public base::NonThreadSafe
,
32 public content::NotificationObserver
,
33 public Profile::Delegate
{
35 typedef base::Callback
<void(Profile
*, Profile::CreateStatus
)> CreateCallback
;
37 explicit ProfileManager(const base::FilePath
& user_data_dir
);
38 virtual ~ProfileManager();
40 #if defined(ENABLE_SESSION_SERVICE)
41 // Invokes SessionServiceFactory::ShutdownForProfile() for all profiles.
42 static void ShutdownSessionServices();
45 // Physically remove deleted profile directories from disk.
46 static void NukeDeletedProfilesFromDisk();
48 // The following DEPRECATED functions should be removed: crbug.com/83792.
50 // DEPRECATED: DO NOT USE unless in ChromeOS.
51 // Returns the default profile. This adds the profile to the
52 // ProfileManager if it doesn't already exist. This method returns NULL if
53 // the profile doesn't exist and we can't create it.
54 // The profile used can be overridden by using --login-profile on cros.
55 Profile
* GetDefaultProfile(const base::FilePath
& user_data_dir
);
57 // DEPRECATED: Temporary measure to ensure that GetDefaultProfile() is not
58 // called before CreateProfile() is called in chrome_browser_main.cc.
59 // If GetDefaultProfile() or GetDefaultProfileOrOffTheRecord() is called
60 // before this, a CHECK will be triggered.
61 static void AllowGetDefaultProfile();
62 static bool IsGetDefaultProfileAllowed();
64 // DEPRECATED: DO NOT USE unless in ChromeOS.
65 // Same as instance method but provides the default user_data_dir as well.
66 static Profile
* GetDefaultProfile();
68 // DEPRECATED: DO NOT USE unless in ChromeOS.
69 // Same as GetDefaultProfile() but returns OffTheRecord profile
71 static Profile
* GetDefaultProfileOrOffTheRecord();
73 // Returns a profile for a specific profile directory within the user data
74 // dir. This will return an existing profile it had already been created,
75 // otherwise it will create and manage it.
76 Profile
* GetProfile(const base::FilePath
& profile_dir
);
78 // Returns total number of profiles available on this machine.
79 size_t GetNumberOfProfiles();
81 // Explicit asynchronous creation of a profile located at |profile_path|.
82 // If the profile has already been created then callback is called
83 // immediately. Should be called on the UI thread.
84 void CreateProfileAsync(const base::FilePath
& profile_path
,
85 const CreateCallback
& callback
,
87 const string16
& icon_url
,
88 const std::string
& managed_user_id
);
90 // Returns true if the profile pointer is known to point to an existing
92 bool IsValidProfile(Profile
* profile
);
94 // Returns the directory where the first created profile is stored,
95 // relative to the user data directory currently in use..
96 base::FilePath
GetInitialProfileDir();
98 // Get the Profile last used (the Profile to which owns the most recently
99 // focused window) with this Chrome build. If no signed profile has been
100 // stored in Local State, hand back the Default profile.
101 Profile
* GetLastUsedProfile(const base::FilePath
& user_data_dir
);
103 // Same as instance method but provides the default user_data_dir as well.
104 // If the Profile is going to be used to open a new window then consider using
105 // GetLastUsedProfileAllowedByPolicy() instead.
106 static Profile
* GetLastUsedProfile();
108 // Same as GetLastUsedProfile() but returns the incognito Profile if
109 // incognito mode is forced. This should be used if the last used Profile
110 // will be used to open new browser windows.
111 static Profile
* GetLastUsedProfileAllowedByPolicy();
113 // Get the path of the last used profile, or if that's undefined, the default
115 base::FilePath
GetLastUsedProfileDir(const base::FilePath
& user_data_dir
);
117 // Get the Profiles which are currently open, i.e., have open browsers, or
118 // were open the last time Chrome was running. The Profiles appear in the
119 // order they were opened. The last used profile will be on the list, but its
120 // index on the list will depend on when it was opened (it is not necessarily
122 std::vector
<Profile
*> GetLastOpenedProfiles(
123 const base::FilePath
& user_data_dir
);
125 // Same as instance method but provides the default user_data_dir as well.
126 static std::vector
<Profile
*> GetLastOpenedProfiles();
128 // Returns created profiles. Note, profiles order is NOT guaranteed to be
129 // related with the creation order.
130 std::vector
<Profile
*> GetLoadedProfiles() const;
132 // content::NotificationObserver implementation.
133 virtual void Observe(int type
,
134 const content::NotificationSource
& source
,
135 const content::NotificationDetails
& details
) OVERRIDE
;
137 // If a profile with the given path is currently managed by this object,
138 // return a pointer to the corresponding Profile object;
139 // otherwise return NULL.
140 Profile
* GetProfileByPath(const base::FilePath
& path
) const;
142 // Profile::Delegate implementation:
143 virtual void OnProfileCreated(Profile
* profile
,
145 bool is_new_profile
) OVERRIDE
;
147 // Add or remove a profile launcher to/from the list of launchers waiting for
148 // new profiles to be created from the multi-profile menu.
149 void AddProfileLauncher(NewProfileLauncher
* profile_launcher
);
150 void RemoveProfileLauncher(NewProfileLauncher
* profile_launcher
);
152 // Creates a new profile in the next available multiprofile directory.
153 // Directories are named "profile_1", "profile_2", etc., in sequence of
154 // creation. (Because directories can be removed, however, it may be the case
155 // that at some point the list of numbered profiles is not continuous.)
156 // |callback| may be invoked multiple times (for CREATE_STATUS_INITIALIZED
157 // and CREATE_STATUS_CREATED) so binding parameters with bind::Passed() is
158 // prohibited. Returns the file path to the profile that will be created
160 static base::FilePath
CreateMultiProfileAsync(
161 const string16
& name
,
162 const string16
& icon_url
,
163 const CreateCallback
& callback
,
164 const std::string
& managed_user_id
);
166 // Returns the full path to be used for guest profiles.
167 static base::FilePath
GetGuestProfilePath();
169 // Returns a ProfileInfoCache object which can be used to get information
170 // about profiles without having to load them from disk.
171 ProfileInfoCache
& GetProfileInfoCache();
173 // Returns a ProfileShortcut Manager that enables the caller to create
174 // profile specfic desktop shortcuts.
175 ProfileShortcutManager
* profile_shortcut_manager();
177 // Schedules the profile at the given path to be deleted on shutdown. If we're
178 // deleting the last profile, a new one will be created in its place, and in
179 // that case the callback will be called when profile creation is complete.
180 void ScheduleProfileForDeletion(const base::FilePath
& profile_dir
,
181 const CreateCallback
& callback
);
183 // Autoloads profiles if they are running background apps.
184 void AutoloadProfiles();
186 // Sign-Out a profile against use until re-authentication.
187 void SignOutProfile(Profile
* profile
);
189 // Register and add testing profile to the ProfileManager. Use ONLY in tests.
190 // This allows the creation of Profiles outside of the standard creation path
191 // for testing. If |addToCache|, adds to ProfileInfoCache as well.
192 // If |start_deferred_task_runners|, starts the deferred task runners.
193 // Use ONLY in tests.
194 void RegisterTestingProfile(Profile
* profile
,
196 bool start_deferred_task_runners
);
198 const base::FilePath
& user_data_dir() const { return user_data_dir_
; }
200 // For ChromeOS, determines if the user has logged in to a real profile.
201 bool IsLoggedIn() const { return logged_in_
; }
204 // Does final initial actions.
205 virtual void DoFinalInit(Profile
* profile
, bool go_off_the_record
);
206 virtual void DoFinalInitForServices(Profile
* profile
, bool go_off_the_record
);
207 virtual void DoFinalInitLogging(Profile
* profile
);
209 // Creates a new profile by calling into the profile's profile creation
210 // method. Virtual so that unittests can return a TestingProfile instead
211 // of the Profile's result.
212 virtual Profile
* CreateProfileHelper(const base::FilePath
& path
);
214 // Creates a new profile asynchronously by calling into the profile's
215 // asynchronous profile creation method. Virtual so that unittests can return
216 // a TestingProfile instead of the Profile's result.
217 virtual Profile
* CreateProfileAsyncHelper(const base::FilePath
& path
,
221 friend class TestingProfileManager
;
222 FRIEND_TEST_ALL_PREFIXES(ProfileManagerBrowserTest
, DeleteAllProfiles
);
223 FRIEND_TEST_ALL_PREFIXES(ProfileManagerBrowserTest
, SwitchToProfile
);
225 // This struct contains information about profiles which are being loaded or
228 ProfileInfo(Profile
* profile
, bool created
);
232 scoped_ptr
<Profile
> profile
;
233 // Whether profile has been fully loaded (created and initialized).
235 // Whether or not this profile should have a shortcut.
236 bool create_shortcut
;
237 // List of callbacks to run when profile initialization is done. Note, when
238 // profile is fully loaded this vector will be empty.
239 std::vector
<CreateCallback
> callbacks
;
242 DISALLOW_COPY_AND_ASSIGN(ProfileInfo
);
245 // Adds a pre-existing Profile object to the set managed by this
246 // ProfileManager. This ProfileManager takes ownership of the Profile.
247 // The Profile should not already be managed by this ProfileManager.
248 // Returns true if the profile was added, false otherwise.
249 bool AddProfile(Profile
* profile
);
251 // Schedules the profile at the given path to be deleted on shutdown.
252 void FinishDeletingProfile(const base::FilePath
& profile_dir
);
254 // Registers profile with given info. Returns pointer to created ProfileInfo
256 ProfileInfo
* RegisterProfile(Profile
* profile
, bool created
);
258 // Returns ProfileInfo associated with given |path|, registred earlier with
260 ProfileInfo
* GetProfileInfoByPath(const base::FilePath
& path
) const;
262 typedef std::pair
<base::FilePath
, string16
> ProfilePathAndName
;
263 typedef std::vector
<ProfilePathAndName
> ProfilePathAndNames
;
264 ProfilePathAndNames
GetSortedProfilesFromDirectoryMap();
266 static bool CompareProfilePathAndName(
267 const ProfileManager::ProfilePathAndName
& pair1
,
268 const ProfileManager::ProfilePathAndName
& pair2
);
270 // Adds |profile| to the profile info cache if it hasn't been added yet.
271 void AddProfileToCache(Profile
* profile
);
273 // Initializes user prefs of |profile|. This includes profile name and
275 void InitProfileUserPrefs(Profile
* profile
);
277 // For ChromeOS, determines if profile should be otr.
278 bool ShouldGoOffTheRecord(Profile
* profile
);
280 // Get the path of the next profile directory and increment the internal
282 // Lack of side effects:
283 // This function doesn't actually create the directory or touch the file
285 base::FilePath
GenerateNextProfileDirectoryPath();
287 void RunCallbacks(const std::vector
<CreateCallback
>& callbacks
,
289 Profile::CreateStatus status
);
291 // If the |loaded_profile| has been loaded succesfully (according to |status|)
292 // and isn't already scheduled for deletion, then finishes adding
293 // |profile_to_delete_dir| to the queue of profiles to be deleted, and updates
294 // the kProfileLastUsed preference based on |last_non_managed_profile_path|.
295 void OnNewActiveProfileLoaded(
296 const base::FilePath
& profile_to_delete_path
,
297 const base::FilePath
& last_non_managed_profile_path
,
298 const CreateCallback
& original_callback
,
299 Profile
* loaded_profile
,
300 Profile::CreateStatus status
);
302 content::NotificationRegistrar registrar_
;
304 // The path to the user data directory (DIR_USER_DATA).
305 const base::FilePath user_data_dir_
;
307 // Indicates that a user has logged in and that the profile specified
308 // in the --login-profile command line argument should be used as the
312 // Maps profile path to ProfileInfo (if profile has been created). Use
313 // RegisterProfile() to add into this map. This map owns all loaded profile
314 // objects in a running instance of Chrome.
315 typedef std::map
<base::FilePath
, linked_ptr
<ProfileInfo
> > ProfilesInfoMap
;
316 ProfilesInfoMap profiles_info_
;
318 // Object to cache various information about profiles. Contains information
319 // about every profile which has been created for this instance of Chrome,
320 // if it has not been explicitly deleted.
321 scoped_ptr
<ProfileInfoCache
> profile_info_cache_
;
323 // Manages the process of creating, deleteing and updating Desktop shortcuts.
324 scoped_ptr
<ProfileShortcutManager
> profile_shortcut_manager_
;
326 #if !defined(OS_ANDROID) && !defined(OS_IOS)
327 class BrowserListObserver
: public chrome::BrowserListObserver
{
329 explicit BrowserListObserver(ProfileManager
* manager
);
330 virtual ~BrowserListObserver();
332 // chrome::BrowserListObserver implementation.
333 virtual void OnBrowserAdded(Browser
* browser
) OVERRIDE
;
334 virtual void OnBrowserRemoved(Browser
* browser
) OVERRIDE
;
335 virtual void OnBrowserSetLastActive(Browser
* browser
) OVERRIDE
;
338 ProfileManager
* profile_manager_
;
339 DISALLOW_COPY_AND_ASSIGN(BrowserListObserver
);
342 BrowserListObserver browser_list_observer_
;
343 #endif // !defined(OS_ANDROID) && !defined(OS_IOS)
345 // For keeping track of the last active profiles.
346 std::map
<Profile
*, int> browser_counts_
;
347 // On startup we launch the active profiles in the order they became active
348 // during the last run. This is why they are kept in a list, not in a set.
349 std::vector
<Profile
*> active_profiles_
;
350 bool closing_all_browsers_
;
352 DISALLOW_COPY_AND_ASSIGN(ProfileManager
);
355 // Same as the ProfileManager, but doesn't initialize some services of the
356 // profile. This one is useful in unittests.
357 class ProfileManagerWithoutInit
: public ProfileManager
{
359 explicit ProfileManagerWithoutInit(const base::FilePath
& user_data_dir
);
362 virtual void DoFinalInitForServices(Profile
*, bool) OVERRIDE
{}
363 virtual void DoFinalInitLogging(Profile
*) OVERRIDE
{}
366 #endif // CHROME_BROWSER_PROFILES_PROFILE_MANAGER_H_