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.
7 #include "base/command_line.h"
8 #include "base/file_util.h"
9 #include "base/files/scoped_temp_dir.h"
10 #include "base/path_service.h"
11 #include "base/run_loop.h"
12 #include "base/strings/utf_string_conversions.h"
13 #include "base/values.h"
14 #include "build/build_config.h"
15 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
16 #include "chrome/browser/browser_process.h"
17 #include "chrome/browser/chrome_notification_types.h"
18 #include "chrome/browser/chromeos/settings/cros_settings.h"
19 #include "chrome/browser/history/history_service.h"
20 #include "chrome/browser/history/history_service_factory.h"
21 #include "chrome/browser/io_thread.h"
22 #include "chrome/browser/prefs/browser_prefs.h"
23 #include "chrome/browser/prefs/incognito_mode_prefs.h"
24 #include "chrome/browser/profiles/profile.h"
25 #include "chrome/browser/profiles/profile_info_cache.h"
26 #include "chrome/browser/profiles/profile_manager.h"
27 #include "chrome/browser/ui/browser.h"
28 #include "chrome/common/chrome_constants.h"
29 #include "chrome/common/chrome_paths.h"
30 #include "chrome/common/chrome_switches.h"
31 #include "chrome/common/pref_names.h"
32 #include "chrome/test/base/scoped_testing_local_state.h"
33 #include "chrome/test/base/test_browser_window.h"
34 #include "chrome/test/base/testing_browser_process.h"
35 #include "chrome/test/base/testing_profile.h"
36 #include "content/public/browser/notification_service.h"
37 #include "content/public/test/test_browser_thread_bundle.h"
38 #include "testing/gmock/include/gmock/gmock.h"
39 #include "testing/gtest/include/gtest/gtest.h"
41 #if defined(OS_CHROMEOS)
42 #include "chrome/browser/chromeos/login/mock_user_manager.h"
43 #include "chrome/browser/chromeos/login/user_manager.h"
44 #include "chrome/browser/chromeos/settings/cros_settings.h"
45 #include "chrome/browser/chromeos/settings/device_settings_service.h"
46 #include "chromeos/chromeos_switches.h"
49 using content::BrowserThread;
53 // This global variable is used to check that value returned to different
54 // observers is the same.
55 Profile* g_created_profile;
57 class UnittestProfileManager : public ::ProfileManagerWithoutInit {
59 explicit UnittestProfileManager(const base::FilePath& user_data_dir)
60 : ::ProfileManagerWithoutInit(user_data_dir) {}
63 virtual Profile* CreateProfileHelper(
64 const base::FilePath& file_path) OVERRIDE {
65 if (!base::PathExists(file_path)) {
66 if (!file_util::CreateDirectory(file_path))
69 return new TestingProfile(file_path, NULL);
72 virtual Profile* CreateProfileAsyncHelper(const base::FilePath& path,
73 Delegate* delegate) OVERRIDE {
74 // This is safe while all file operations are done on the FILE thread.
75 BrowserThread::PostTask(
76 BrowserThread::FILE, FROM_HERE,
77 base::Bind(base::IgnoreResult(&file_util::CreateDirectory), path));
79 return new TestingProfile(path, this);
85 class ProfileManagerTest : public testing::Test {
89 MOCK_METHOD2(OnProfileCreated,
90 void(Profile* profile, Profile::CreateStatus status));
94 : local_state_(TestingBrowserProcess::GetGlobal()) {
97 virtual void SetUp() {
98 // Create a new temporary directory, and store the path
99 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
100 TestingBrowserProcess::GetGlobal()->SetProfileManager(
101 new UnittestProfileManager(temp_dir_.path()));
103 #if defined(OS_CHROMEOS)
104 CommandLine* cl = CommandLine::ForCurrentProcess();
105 cl->AppendSwitch(switches::kTestType);
109 virtual void TearDown() {
110 TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
111 base::RunLoop().RunUntilIdle();
114 // Helper function to create a profile with |name| for a profile |manager|.
115 void CreateProfileAsync(ProfileManager* manager,
116 const std::string& name,
117 MockObserver* mock_observer) {
118 manager->CreateProfileAsync(
119 temp_dir_.path().AppendASCII(name),
120 base::Bind(&MockObserver::OnProfileCreated,
121 base::Unretained(mock_observer)),
127 #if defined(OS_CHROMEOS)
128 chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
129 chromeos::ScopedTestCrosSettings test_cros_settings_;
132 // The path to temporary directory used to contain the test operations.
133 base::ScopedTempDir temp_dir_;
134 ScopedTestingLocalState local_state_;
136 content::TestBrowserThreadBundle thread_bundle_;
138 #if defined(OS_CHROMEOS)
139 chromeos::ScopedTestUserManager test_user_manager_;
143 TEST_F(ProfileManagerTest, GetProfile) {
144 base::FilePath dest_path = temp_dir_.path();
145 dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
147 ProfileManager* profile_manager = g_browser_process->profile_manager();
149 // Successfully create a profile.
150 Profile* profile = profile_manager->GetProfile(dest_path);
151 EXPECT_TRUE(profile);
153 // The profile already exists when we call GetProfile. Just load it.
154 EXPECT_EQ(profile, profile_manager->GetProfile(dest_path));
157 TEST_F(ProfileManagerTest, DefaultProfileDir) {
158 base::FilePath expected_default =
159 base::FilePath().AppendASCII(chrome::kInitialProfile);
161 expected_default.value(),
162 g_browser_process->profile_manager()->GetInitialProfileDir().value());
165 #if defined(OS_CHROMEOS)
166 // This functionality only exists on Chrome OS.
167 TEST_F(ProfileManagerTest, LoggedInProfileDir) {
168 CommandLine *cl = CommandLine::ForCurrentProcess();
169 std::string profile_dir(chrome::kTestUserProfileDir);
171 cl->AppendSwitchASCII(chromeos::switches::kLoginProfile, profile_dir);
173 base::FilePath expected_default =
174 base::FilePath().AppendASCII(chrome::kInitialProfile);
175 ProfileManager* profile_manager = g_browser_process->profile_manager();
176 EXPECT_EQ(expected_default.value(),
177 profile_manager->GetInitialProfileDir().value());
179 scoped_ptr<chromeos::MockUserManager> mock_user_manager;
180 mock_user_manager.reset(new chromeos::MockUserManager());
181 mock_user_manager->SetActiveUser("user@gmail.com");
182 chromeos::User* active_user = mock_user_manager->GetActiveUser();
183 profile_manager->Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
184 content::NotificationService::AllSources(),
185 content::Details<const chromeos::User>(active_user));
186 base::FilePath expected_logged_in(profile_dir);
187 EXPECT_EQ(expected_logged_in.value(),
188 profile_manager->GetInitialProfileDir().value());
189 VLOG(1) << temp_dir_.path().Append(
190 profile_manager->GetInitialProfileDir()).value();
195 TEST_F(ProfileManagerTest, CreateAndUseTwoProfiles) {
196 base::FilePath dest_path1 = temp_dir_.path();
197 dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
199 base::FilePath dest_path2 = temp_dir_.path();
200 dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
202 ProfileManager* profile_manager = g_browser_process->profile_manager();
204 // Successfully create the profiles.
205 TestingProfile* profile1 =
206 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
207 ASSERT_TRUE(profile1);
209 TestingProfile* profile2 =
210 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
211 ASSERT_TRUE(profile2);
213 // Force lazy-init of some profile services to simulate use.
214 ASSERT_TRUE(profile1->CreateHistoryService(true, false));
215 EXPECT_TRUE(HistoryServiceFactory::GetForProfile(profile1,
216 Profile::EXPLICIT_ACCESS));
217 profile1->CreateBookmarkModel(true);
218 EXPECT_TRUE(BookmarkModelFactory::GetForProfile(profile1));
219 profile2->CreateBookmarkModel(true);
220 EXPECT_TRUE(BookmarkModelFactory::GetForProfile(profile2));
221 ASSERT_TRUE(profile2->CreateHistoryService(true, false));
222 EXPECT_TRUE(HistoryServiceFactory::GetForProfile(profile2,
223 Profile::EXPLICIT_ACCESS));
225 // Make sure any pending tasks run before we destroy the profiles.
226 base::RunLoop().RunUntilIdle();
228 TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
230 // Make sure history cleans up correctly.
231 base::RunLoop().RunUntilIdle();
234 MATCHER(NotFail, "Profile creation failure status is not reported.") {
235 return arg == Profile::CREATE_STATUS_CREATED ||
236 arg == Profile::CREATE_STATUS_INITIALIZED;
239 // Tests asynchronous profile creation mechanism.
240 // Crashes: http://crbug.com/89421
241 TEST_F(ProfileManagerTest, DISABLED_CreateProfileAsync) {
242 MockObserver mock_observer;
243 EXPECT_CALL(mock_observer, OnProfileCreated(
244 testing::NotNull(), NotFail())).Times(testing::AtLeast(1));
246 CreateProfileAsync(g_browser_process->profile_manager(),
247 "New Profile", &mock_observer);
249 base::RunLoop().RunUntilIdle();
252 MATCHER(SameNotNull, "The same non-NULL value for all calls.") {
253 if (!g_created_profile)
254 g_created_profile = arg;
255 return arg != NULL && arg == g_created_profile;
258 TEST_F(ProfileManagerTest, CreateProfileAsyncMultipleRequests) {
259 g_created_profile = NULL;
261 MockObserver mock_observer1;
262 EXPECT_CALL(mock_observer1, OnProfileCreated(
263 SameNotNull(), NotFail())).Times(testing::AtLeast(1));
264 MockObserver mock_observer2;
265 EXPECT_CALL(mock_observer2, OnProfileCreated(
266 SameNotNull(), NotFail())).Times(testing::AtLeast(1));
267 MockObserver mock_observer3;
268 EXPECT_CALL(mock_observer3, OnProfileCreated(
269 SameNotNull(), NotFail())).Times(testing::AtLeast(1));
271 ProfileManager* profile_manager = g_browser_process->profile_manager();
272 const std::string profile_name = "New Profile";
273 CreateProfileAsync(profile_manager, profile_name, &mock_observer1);
274 CreateProfileAsync(profile_manager, profile_name, &mock_observer2);
275 CreateProfileAsync(profile_manager, profile_name, &mock_observer3);
277 base::RunLoop().RunUntilIdle();
280 TEST_F(ProfileManagerTest, CreateProfilesAsync) {
281 const std::string profile_name1 = "New Profile 1";
282 const std::string profile_name2 = "New Profile 2";
284 MockObserver mock_observer;
285 EXPECT_CALL(mock_observer, OnProfileCreated(
286 testing::NotNull(), NotFail())).Times(testing::AtLeast(3));
288 ProfileManager* profile_manager = g_browser_process->profile_manager();
290 CreateProfileAsync(profile_manager, profile_name1, &mock_observer);
291 CreateProfileAsync(profile_manager, profile_name2, &mock_observer);
293 base::RunLoop().RunUntilIdle();
296 TEST_F(ProfileManagerTest, GetGuestProfilePath) {
297 base::FilePath guest_path = ProfileManager::GetGuestProfilePath();
298 base::FilePath expected_path = temp_dir_.path();
299 expected_path = expected_path.Append(chrome::kGuestProfileDir);
300 EXPECT_EQ(expected_path, guest_path);
303 TEST_F(ProfileManagerTest, AutoloadProfilesWithBackgroundApps) {
304 ProfileManager* profile_manager = g_browser_process->profile_manager();
305 ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
306 local_state_.Get()->SetUserPref(prefs::kBackgroundModeEnabled,
307 Value::CreateBooleanValue(true));
309 // Setting a pref which is not applicable to a system (i.e., Android in this
310 // case) does not necessarily create it. Don't bother continuing with the
311 // test if this pref doesn't exist because it will not load the profiles if
312 // it cannot verify that the pref for background mode is enabled.
313 if (!local_state_.Get()->HasPrefPath(prefs::kBackgroundModeEnabled))
316 EXPECT_EQ(0u, cache.GetNumberOfProfiles());
317 cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_1"),
318 ASCIIToUTF16("name_1"), string16(), 0, std::string());
319 cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_2"),
320 ASCIIToUTF16("name_2"), string16(), 0, std::string());
321 cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_3"),
322 ASCIIToUTF16("name_3"), string16(), 0, std::string());
323 cache.SetBackgroundStatusOfProfileAtIndex(0, true);
324 cache.SetBackgroundStatusOfProfileAtIndex(2, true);
325 EXPECT_EQ(3u, cache.GetNumberOfProfiles());
327 profile_manager->AutoloadProfiles();
329 EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
332 TEST_F(ProfileManagerTest, DoNotAutoloadProfilesIfBackgroundModeOff) {
333 ProfileManager* profile_manager = g_browser_process->profile_manager();
334 ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
335 local_state_.Get()->SetUserPref(prefs::kBackgroundModeEnabled,
336 Value::CreateBooleanValue(false));
338 EXPECT_EQ(0u, cache.GetNumberOfProfiles());
339 cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_1"),
340 ASCIIToUTF16("name_1"), string16(), 0, std::string());
341 cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_2"),
342 ASCIIToUTF16("name_2"), string16(), 0, std::string());
343 cache.SetBackgroundStatusOfProfileAtIndex(0, false);
344 cache.SetBackgroundStatusOfProfileAtIndex(1, true);
345 EXPECT_EQ(2u, cache.GetNumberOfProfiles());
347 profile_manager->AutoloadProfiles();
349 EXPECT_EQ(0u, profile_manager->GetLoadedProfiles().size());
352 TEST_F(ProfileManagerTest, InitProfileUserPrefs) {
353 base::FilePath dest_path = temp_dir_.path();
354 dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
356 ProfileManager* profile_manager = g_browser_process->profile_manager();
360 // Successfully create the profile
361 profile = profile_manager->GetProfile(dest_path);
362 ASSERT_TRUE(profile);
364 // Check that the profile name is non empty
365 std::string profile_name =
366 profile->GetPrefs()->GetString(prefs::kProfileName);
367 EXPECT_FALSE(profile_name.empty());
369 // Check that the profile avatar index is valid
370 size_t avatar_index =
371 profile->GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
372 EXPECT_TRUE(profile_manager->GetProfileInfoCache().IsDefaultAvatarIconIndex(
376 // Tests that a new profile's entry in the profile info cache is setup with the
377 // same values that are in the profile prefs.
378 TEST_F(ProfileManagerTest, InitProfileInfoCacheForAProfile) {
379 base::FilePath dest_path = temp_dir_.path();
380 dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
382 ProfileManager* profile_manager = g_browser_process->profile_manager();
383 ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
385 // Successfully create the profile
386 Profile* profile = profile_manager->GetProfile(dest_path);
387 ASSERT_TRUE(profile);
389 std::string profile_name =
390 profile->GetPrefs()->GetString(prefs::kProfileName);
391 size_t avatar_index =
392 profile->GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
394 size_t profile_index = cache.GetIndexOfProfileWithPath(dest_path);
396 // Check if the profile prefs are the same as the cache prefs
397 EXPECT_EQ(profile_name,
398 UTF16ToUTF8(cache.GetNameOfProfileAtIndex(profile_index)));
399 EXPECT_EQ(avatar_index,
400 cache.GetAvatarIconIndexOfProfileAtIndex(profile_index));
403 TEST_F(ProfileManagerTest, GetLastUsedProfileAllowedByPolicy) {
404 ProfileManager* profile_manager = g_browser_process->profile_manager();
405 ASSERT_TRUE(profile_manager);
407 Profile* profile = profile_manager->GetLastUsedProfileAllowedByPolicy();
408 ASSERT_TRUE(profile);
409 EXPECT_FALSE(profile->IsOffTheRecord());
410 PrefService* prefs = profile->GetPrefs();
411 EXPECT_EQ(IncognitoModePrefs::ENABLED,
412 IncognitoModePrefs::GetAvailability(prefs));
414 // Attach an incognito Profile to the TestingProfile.
415 ASSERT_FALSE(profile->GetOffTheRecordProfile());
416 TestingProfile::Builder builder;
417 builder.SetIncognito();
418 scoped_ptr<TestingProfile> incognito_profile = builder.Build();
419 EXPECT_TRUE(incognito_profile->IsOffTheRecord());
420 TestingProfile* testing_profile = static_cast<TestingProfile*>(profile);
421 testing_profile->SetOffTheRecordProfile(incognito_profile.PassAs<Profile>());
422 ASSERT_TRUE(profile->GetOffTheRecordProfile());
424 IncognitoModePrefs::SetAvailability(prefs, IncognitoModePrefs::DISABLED);
426 profile_manager->GetLastUsedProfileAllowedByPolicy()->IsOffTheRecord());
428 // GetLastUsedProfileAllowedByPolicy() returns the incognito Profile when
429 // incognito mode is forced.
430 IncognitoModePrefs::SetAvailability(prefs, IncognitoModePrefs::FORCED);
432 profile_manager->GetLastUsedProfileAllowedByPolicy()->IsOffTheRecord());
435 #if !defined(OS_ANDROID)
436 // There's no Browser object on Android.
437 TEST_F(ProfileManagerTest, LastOpenedProfiles) {
438 base::FilePath dest_path1 = temp_dir_.path();
439 dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
441 base::FilePath dest_path2 = temp_dir_.path();
442 dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
444 ProfileManager* profile_manager = g_browser_process->profile_manager();
446 // Successfully create the profiles.
447 TestingProfile* profile1 =
448 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
449 ASSERT_TRUE(profile1);
451 TestingProfile* profile2 =
452 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
453 ASSERT_TRUE(profile2);
455 std::vector<Profile*> last_opened_profiles =
456 profile_manager->GetLastOpenedProfiles();
457 ASSERT_EQ(0U, last_opened_profiles.size());
459 // Create a browser for profile1.
460 Browser::CreateParams profile1_params(profile1, chrome::GetActiveDesktop());
461 scoped_ptr<Browser> browser1a(
462 chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
464 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
465 ASSERT_EQ(1U, last_opened_profiles.size());
466 EXPECT_EQ(profile1, last_opened_profiles[0]);
469 Browser::CreateParams profile2_params(profile2, chrome::GetActiveDesktop());
470 scoped_ptr<Browser> browser2(
471 chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
473 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
474 ASSERT_EQ(2U, last_opened_profiles.size());
475 EXPECT_EQ(profile1, last_opened_profiles[0]);
476 EXPECT_EQ(profile2, last_opened_profiles[1]);
478 // Adding more browsers doesn't change anything.
479 scoped_ptr<Browser> browser1b(
480 chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
481 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
482 ASSERT_EQ(2U, last_opened_profiles.size());
483 EXPECT_EQ(profile1, last_opened_profiles[0]);
484 EXPECT_EQ(profile2, last_opened_profiles[1]);
486 // Close the browsers.
488 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
489 ASSERT_EQ(2U, last_opened_profiles.size());
490 EXPECT_EQ(profile1, last_opened_profiles[0]);
491 EXPECT_EQ(profile2, last_opened_profiles[1]);
494 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
495 ASSERT_EQ(1U, last_opened_profiles.size());
496 EXPECT_EQ(profile2, last_opened_profiles[0]);
499 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
500 ASSERT_EQ(0U, last_opened_profiles.size());
503 TEST_F(ProfileManagerTest, LastOpenedProfilesAtShutdown) {
504 base::FilePath dest_path1 = temp_dir_.path();
505 dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
507 base::FilePath dest_path2 = temp_dir_.path();
508 dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
510 ProfileManager* profile_manager = g_browser_process->profile_manager();
512 // Successfully create the profiles.
513 TestingProfile* profile1 =
514 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
515 ASSERT_TRUE(profile1);
517 TestingProfile* profile2 =
518 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
519 ASSERT_TRUE(profile2);
521 // Create a browser for profile1.
522 Browser::CreateParams profile1_params(profile1, chrome::GetActiveDesktop());
523 scoped_ptr<Browser> browser1(
524 chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
527 Browser::CreateParams profile2_params(profile2, chrome::GetActiveDesktop());
528 scoped_ptr<Browser> browser2(
529 chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
531 std::vector<Profile*> last_opened_profiles =
532 profile_manager->GetLastOpenedProfiles();
533 ASSERT_EQ(2U, last_opened_profiles.size());
534 EXPECT_EQ(profile1, last_opened_profiles[0]);
535 EXPECT_EQ(profile2, last_opened_profiles[1]);
537 // Simulate a shutdown.
538 content::NotificationService::current()->Notify(
539 chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
540 content::NotificationService::AllSources(),
541 content::NotificationService::NoDetails());
543 // Even if the browsers are destructed during shutdown, the profiles stay
548 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
549 ASSERT_EQ(2U, last_opened_profiles.size());
550 EXPECT_EQ(profile1, last_opened_profiles[0]);
551 EXPECT_EQ(profile2, last_opened_profiles[1]);
554 TEST_F(ProfileManagerTest, LastOpenedProfilesDoesNotContainIncognito) {
555 base::FilePath dest_path1 = temp_dir_.path();
556 dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
557 base::FilePath dest_path2 = temp_dir_.path();
558 dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
560 ProfileManager* profile_manager = g_browser_process->profile_manager();
562 // Successfully create the profiles.
563 TestingProfile* profile1 =
564 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
565 ASSERT_TRUE(profile1);
567 // incognito profiles should not be managed by the profile manager but by the
569 TestingProfile::Builder builder;
570 builder.SetIncognito();
571 scoped_ptr<TestingProfile> profile2 = builder.Build();
572 profile1->SetOffTheRecordProfile(profile2.PassAs<Profile>());
574 std::vector<Profile*> last_opened_profiles =
575 profile_manager->GetLastOpenedProfiles();
576 ASSERT_EQ(0U, last_opened_profiles.size());
578 // Create a browser for profile1.
579 Browser::CreateParams profile1_params(profile1, chrome::GetActiveDesktop());
580 scoped_ptr<Browser> browser1(
581 chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
583 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
584 ASSERT_EQ(1U, last_opened_profiles.size());
585 EXPECT_EQ(profile1, last_opened_profiles[0]);
588 Browser::CreateParams profile2_params(profile1->GetOffTheRecordProfile(),
589 chrome::GetActiveDesktop());
590 scoped_ptr<Browser> browser2a(
591 chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
593 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
594 ASSERT_EQ(1U, last_opened_profiles.size());
595 EXPECT_EQ(profile1, last_opened_profiles[0]);
597 // Adding more browsers doesn't change anything.
598 scoped_ptr<Browser> browser2b(
599 chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
600 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
601 ASSERT_EQ(1U, last_opened_profiles.size());
602 EXPECT_EQ(profile1, last_opened_profiles[0]);
604 // Close the browsers.
606 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
607 ASSERT_EQ(1U, last_opened_profiles.size());
608 EXPECT_EQ(profile1, last_opened_profiles[0]);
611 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
612 ASSERT_EQ(1U, last_opened_profiles.size());
613 EXPECT_EQ(profile1, last_opened_profiles[0]);
616 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
617 ASSERT_EQ(0U, last_opened_profiles.size());
619 #endif // !defined(OS_ANDROID)
621 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
622 // There's no Browser object on Android and there's no multi-profiles on Chrome.
623 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastProfile) {
624 base::FilePath dest_path = temp_dir_.path();
625 dest_path = dest_path.Append(FILE_PATH_LITERAL("Ephemeral Profile"));
627 ProfileManager* profile_manager = g_browser_process->profile_manager();
629 TestingProfile* profile =
630 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path));
631 ASSERT_TRUE(profile);
632 profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
634 // Here the last used profile is still the "Default" profile.
635 Profile* last_used_profile = profile_manager->GetLastUsedProfile();
636 EXPECT_NE(profile, last_used_profile);
638 // Create a browser for the profile.
639 Browser::CreateParams profile_params(profile, chrome::GetActiveDesktop());
640 scoped_ptr<Browser> browser(
641 chrome::CreateBrowserWithTestWindowForParams(&profile_params));
642 last_used_profile = profile_manager->GetLastUsedProfile();
643 EXPECT_NE(profile, last_used_profile);
645 // Close the browser.
647 last_used_profile = profile_manager->GetLastUsedProfile();
648 EXPECT_NE(profile, last_used_profile);
651 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastOpenedAtShutdown) {
652 base::FilePath dest_path1 = temp_dir_.path();
653 dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("Normal Profile"));
655 base::FilePath dest_path2 = temp_dir_.path();
656 dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("Ephemeral Profile 1"));
658 base::FilePath dest_path3 = temp_dir_.path();
659 dest_path3 = dest_path3.Append(FILE_PATH_LITERAL("Ephemeral Profile 2"));
661 ProfileManager* profile_manager = g_browser_process->profile_manager();
663 // Successfully create the profiles.
664 TestingProfile* normal_profile =
665 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
666 ASSERT_TRUE(normal_profile);
668 // Add one ephemeral profile which should not end up in this list.
669 TestingProfile* ephemeral_profile1 =
670 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
671 ASSERT_TRUE(ephemeral_profile1);
672 ephemeral_profile1->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
675 // Add second ephemeral profile but don't mark it as such yet.
676 TestingProfile* ephemeral_profile2 =
677 static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path3));
678 ASSERT_TRUE(ephemeral_profile2);
680 // Create a browser for profile1.
681 Browser::CreateParams profile1_params(normal_profile,
682 chrome::GetActiveDesktop());
683 scoped_ptr<Browser> browser1(
684 chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
686 // Create browsers for the ephemeral profile.
687 Browser::CreateParams profile2_params(ephemeral_profile1,
688 chrome::GetActiveDesktop());
689 scoped_ptr<Browser> browser2(
690 chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
692 Browser::CreateParams profile3_params(ephemeral_profile2,
693 chrome::GetActiveDesktop());
694 scoped_ptr<Browser> browser3(
695 chrome::CreateBrowserWithTestWindowForParams(&profile3_params));
697 std::vector<Profile*> last_opened_profiles =
698 profile_manager->GetLastOpenedProfiles();
699 ASSERT_EQ(2U, last_opened_profiles.size());
700 EXPECT_EQ(normal_profile, last_opened_profiles[0]);
701 EXPECT_EQ(ephemeral_profile2, last_opened_profiles[1]);
703 // Mark the second profile ephemeral.
704 ephemeral_profile2->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
707 // Simulate a shutdown.
708 content::NotificationService::current()->Notify(
709 chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
710 content::NotificationService::AllSources(),
711 content::NotificationService::NoDetails());
716 last_opened_profiles = profile_manager->GetLastOpenedProfiles();
717 ASSERT_EQ(1U, last_opened_profiles.size());
718 EXPECT_EQ(normal_profile, last_opened_profiles[0]);
721 TEST_F(ProfileManagerTest, ActiveProfileDeleted) {
722 ProfileManager* profile_manager = g_browser_process->profile_manager();
723 ASSERT_TRUE(profile_manager);
725 // Create and load two profiles.
726 const std::string profile_name1 = "New Profile 1";
727 const std::string profile_name2 = "New Profile 2";
728 base::FilePath dest_path1 =
729 temp_dir_.path().AppendASCII(profile_name1);
730 base::FilePath dest_path2 =
731 temp_dir_.path().AppendASCII(profile_name2);
733 MockObserver mock_observer;
734 EXPECT_CALL(mock_observer, OnProfileCreated(
735 testing::NotNull(), NotFail())).Times(testing::AtLeast(3));
737 CreateProfileAsync(profile_manager, profile_name1, &mock_observer);
738 CreateProfileAsync(profile_manager, profile_name2, &mock_observer);
739 base::RunLoop().RunUntilIdle();
741 EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
742 EXPECT_EQ(2u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
744 // Set the active profile.
745 PrefService* local_state = g_browser_process->local_state();
746 local_state->SetString(prefs::kProfileLastUsed, profile_name1);
748 // Delete the active profile.
749 profile_manager->ScheduleProfileForDeletion(dest_path1,
750 ProfileManager::CreateCallback());
751 // Spin the message loop so that all the callbacks can finish running.
752 base::RunLoop().RunUntilIdle();
754 EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
755 EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
757 #endif // !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
759 #if defined(OS_MACOSX)
760 // These tests are for a Mac-only code path that assumes the browser
761 // process isn't killed when all browser windows are closed.
762 TEST_F(ProfileManagerTest, ActiveProfileDeletedNeedsToLoadNextProfile) {
763 ProfileManager* profile_manager = g_browser_process->profile_manager();
764 ASSERT_TRUE(profile_manager);
766 // Create and load one profile, and just create a second profile.
767 const std::string profile_name1 = "New Profile 1";
768 const std::string profile_name2 = "New Profile 2";
769 base::FilePath dest_path1 =
770 temp_dir_.path().AppendASCII(profile_name1);
771 base::FilePath dest_path2 =
772 temp_dir_.path().AppendASCII(profile_name2);
774 MockObserver mock_observer;
775 EXPECT_CALL(mock_observer, OnProfileCreated(
776 testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
777 CreateProfileAsync(profile_manager, profile_name1, &mock_observer);
778 base::RunLoop().RunUntilIdle();
780 // Track the profile, but don't load it.
781 ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
782 cache.AddProfileToCache(dest_path2, ASCIIToUTF16(profile_name2),
783 string16(), 0, std::string());
784 base::RunLoop().RunUntilIdle();
786 EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
787 EXPECT_EQ(2u, cache.GetNumberOfProfiles());
789 // Set the active profile.
790 PrefService* local_state = g_browser_process->local_state();
791 local_state->SetString(prefs::kProfileLastUsed,
792 dest_path1.BaseName().MaybeAsASCII());
794 // Delete the active profile. This should switch and load the unloaded
796 profile_manager->ScheduleProfileForDeletion(dest_path1,
797 ProfileManager::CreateCallback());
799 // Spin the message loop so that all the callbacks can finish running.
800 base::RunLoop().RunUntilIdle();
802 EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
803 EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
806 // This tests the recursive call in ProfileManager::OnNewActiveProfileLoaded
807 // by simulating a scenario in which the profile that is being loaded as
808 // the next active profile has also been marked for deletion, so the
809 // ProfileManager needs to recursively select a different next profile.
810 TEST_F(ProfileManagerTest, ActiveProfileDeletedNextProfileDeletedToo) {
811 ProfileManager* profile_manager = g_browser_process->profile_manager();
812 ASSERT_TRUE(profile_manager);
814 // Create and load one profile, and create two more profiles.
815 const std::string profile_name1 = "New Profile 1";
816 const std::string profile_name2 = "New Profile 2";
817 const std::string profile_name3 = "New Profile 3";
818 base::FilePath dest_path1 =
819 temp_dir_.path().AppendASCII(profile_name1);
820 base::FilePath dest_path2 =
821 temp_dir_.path().AppendASCII(profile_name2);
822 base::FilePath dest_path3 =
823 temp_dir_.path().AppendASCII(profile_name3);
825 MockObserver mock_observer;
826 EXPECT_CALL(mock_observer, OnProfileCreated(
827 testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
828 CreateProfileAsync(profile_manager, profile_name1, &mock_observer);
829 base::RunLoop().RunUntilIdle();
831 // Create the other profiles, but don't load them. Assign a fake avatar icon
832 // to ensure that profiles in the info cache are sorted by the profile name,
833 // and not randomly by the avatar name.
834 ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
835 cache.AddProfileToCache(dest_path2, ASCIIToUTF16(profile_name2),
836 ASCIIToUTF16(profile_name2), 1, std::string());
837 cache.AddProfileToCache(dest_path3, ASCIIToUTF16(profile_name3),
838 ASCIIToUTF16(profile_name3), 2, std::string());
840 base::RunLoop().RunUntilIdle();
842 EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
843 EXPECT_EQ(3u, cache.GetNumberOfProfiles());
845 // Set the active profile.
846 PrefService* local_state = g_browser_process->local_state();
847 local_state->SetString(prefs::kProfileLastUsed,
848 dest_path1.BaseName().MaybeAsASCII());
850 // Delete the active profile, Profile1.
851 // This will post a CreateProfileAsync message, that tries to load Profile2,
852 // which checks that the profile is not being deleted, and then calls back
853 // FinishDeletingProfile for Profile1.
854 // Try to break this flow by setting the active profile to Profile2 in the
855 // middle (so after the first posted message), and trying to delete Profile2,
856 // so that the ProfileManager has to look for a different profile to load.
857 profile_manager->ScheduleProfileForDeletion(dest_path1,
858 ProfileManager::CreateCallback());
859 local_state->SetString(prefs::kProfileLastUsed,
860 dest_path2.BaseName().MaybeAsASCII());
861 profile_manager->ScheduleProfileForDeletion(dest_path2,
862 ProfileManager::CreateCallback());
863 // Spin the message loop so that all the callbacks can finish running.
864 base::RunLoop().RunUntilIdle();
866 EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
867 EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
869 #endif // !defined(OS_MACOSX)