chrome/browser/profiles/profile_manager_unittest.cc

   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.
   4
   5 #include <string>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_util.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/run_loop.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "build/build_config.h"
  14 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/chromeos/settings/cros_settings.h"
  18 #include "chrome/browser/history/history_service_factory.h"
  19 #include "chrome/browser/io_thread.h"
  20 #include "chrome/browser/prefs/browser_prefs.h"
  21 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
  24 #include "chrome/browser/profiles/profile_info_cache.h"
  25 #include "chrome/browser/profiles/profile_manager.h"
  26 #include "chrome/browser/profiles/profiles_state.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/grit/generated_resources.h"
  33 #include "chrome/test/base/scoped_testing_local_state.h"
  34 #include "chrome/test/base/test_browser_window.h"
  35 #include "chrome/test/base/testing_browser_process.h"
  36 #include "chrome/test/base/testing_profile.h"
  37 #include "components/history/core/browser/history_service.h"
  38 #include "components/signin/core/common/profile_management_switches.h"
  39 #include "content/public/browser/notification_service.h"
  40 #include "content/public/common/content_switches.h"
  41 #include "content/public/test/test_browser_thread_bundle.h"
  42 #include "testing/gmock/include/gmock/gmock.h"
  43 #include "testing/gtest/include/gtest/gtest.h"
  44 #include "ui/base/l10n/l10n_util.h"
  45
  46 #if defined(OS_CHROMEOS)
  47 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
  48 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
  49 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
  50 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
  51 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  52 #include "chrome/browser/chromeos/settings/cros_settings.h"
  53 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  54 #include "chromeos/chromeos_switches.h"
  55 #include "chromeos/login/user_names.h"
  56 #include "components/user_manager/user_manager.h"
  57 #endif  // defined(OS_CHROMEOS)
  58
  59 using base::ASCIIToUTF16;
  60 using content::BrowserThread;
  61
  62 namespace {
  63
  64 // This global variable is used to check that value returned to different
  65 // observers is the same.
  66 Profile* g_created_profile;
  67
  68 class UnittestProfileManager : public ::ProfileManagerWithoutInit {
  69  public:
  70   explicit UnittestProfileManager(const base::FilePath& user_data_dir)
  71       : ::ProfileManagerWithoutInit(user_data_dir) {}
  72
  73  protected:
  74   Profile* CreateProfileHelper(const base::FilePath& file_path) override {
  75     if (!base::PathExists(file_path)) {
  76       if (!base::CreateDirectory(file_path))
  77         return NULL;
  78     }
  79     return new TestingProfile(file_path, NULL);
  80   }
  81
  82   Profile* CreateProfileAsyncHelper(const base::FilePath& path,
  83                                     Delegate* delegate) override {
  84     // This is safe while all file operations are done on the FILE thread.
  85     BrowserThread::PostTask(
  86         BrowserThread::FILE, FROM_HERE,
  87         base::Bind(base::IgnoreResult(&base::CreateDirectory), path));
  88
  89     return new TestingProfile(path, this);
  90   }
  91 };
  92
  93 }  // namespace
  94
  95 class ProfileManagerTest : public testing::Test {
  96  protected:
  97   class MockObserver {
  98    public:
  99     MOCK_METHOD2(OnProfileCreated,
 100         void(Profile* profile, Profile::CreateStatus status));
 101   };
 102
 103   ProfileManagerTest()
 104       : local_state_(TestingBrowserProcess::GetGlobal()) {
 105   }
 106
 107   void SetUp() override {
 108     // Create a new temporary directory, and store the path
 109     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 110     TestingBrowserProcess::GetGlobal()->SetProfileManager(
 111         new UnittestProfileManager(temp_dir_.path()));
 112
 113 #if defined(OS_CHROMEOS)
 114     base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
 115     cl->AppendSwitch(switches::kTestType);
 116     chromeos::WallpaperManager::Initialize();
 117 #endif
 118   }
 119
 120   void TearDown() override {
 121     TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
 122     base::RunLoop().RunUntilIdle();
 123 #if defined(OS_CHROMEOS)
 124     chromeos::WallpaperManager::Shutdown();
 125 #endif
 126   }
 127
 128   // Helper function to create a profile with |name| for a profile |manager|.
 129   void CreateProfileAsync(ProfileManager* manager,
 130                           const std::string& name,
 131                           bool is_supervised,
 132                           MockObserver* mock_observer) {
 133     manager->CreateProfileAsync(
 134         temp_dir_.path().AppendASCII(name),
 135         base::Bind(&MockObserver::OnProfileCreated,
 136                    base::Unretained(mock_observer)),
 137         base::UTF8ToUTF16(name),
 138         base::UTF8ToUTF16(profiles::GetDefaultAvatarIconUrl(0)),
 139         is_supervised ? "Dummy ID" : std::string());
 140   }
 141
 142   // Helper function to add a profile with |profile_name| to
 143   // |profile_manager|'s ProfileInfoCache, and return the profile created.
 144   Profile* AddProfileToCache(ProfileManager* profile_manager,
 145                              const std::string& path_suffix,
 146                              const base::string16& profile_name) {
 147     ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 148     size_t num_profiles = cache.GetNumberOfProfiles();
 149     base::FilePath path = temp_dir_.path().AppendASCII(path_suffix);
 150     cache.AddProfileToCache(path, profile_name,
 151                             base::string16(), 0, std::string());
 152     EXPECT_EQ(num_profiles + 1, cache.GetNumberOfProfiles());
 153     return profile_manager->GetProfile(path);
 154   }
 155
 156 #if defined(OS_CHROMEOS)
 157   // Helper function to register an user with id |user_id| and create profile
 158   // with a correct path.
 159   void RegisterUser(const std::string& user_id) {
 160     chromeos::ProfileHelper* profile_helper = chromeos::ProfileHelper::Get();
 161     const std::string user_id_hash =
 162         profile_helper->GetUserIdHashByUserIdForTesting(user_id);
 163     user_manager::UserManager::Get()->UserLoggedIn(
 164         user_id, user_id_hash, false);
 165     g_browser_process->profile_manager()->GetProfile(
 166         profile_helper->GetProfilePathByUserIdHash(user_id_hash));
 167   }
 168
 169   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 170   chromeos::ScopedTestCrosSettings test_cros_settings_;
 171 #endif
 172
 173   // The path to temporary directory used to contain the test operations.
 174   base::ScopedTempDir temp_dir_;
 175   ScopedTestingLocalState local_state_;
 176
 177   content::TestBrowserThreadBundle thread_bundle_;
 178
 179 #if defined(OS_CHROMEOS)
 180   chromeos::ScopedTestUserManager test_user_manager_;
 181 #endif
 182
 183   DISALLOW_COPY_AND_ASSIGN(ProfileManagerTest);
 184 };
 185
 186 TEST_F(ProfileManagerTest, GetProfile) {
 187   base::FilePath dest_path = temp_dir_.path();
 188   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 189
 190   ProfileManager* profile_manager = g_browser_process->profile_manager();
 191
 192   // Successfully create a profile.
 193   Profile* profile = profile_manager->GetProfile(dest_path);
 194   EXPECT_TRUE(profile);
 195
 196   // The profile already exists when we call GetProfile. Just load it.
 197   EXPECT_EQ(profile, profile_manager->GetProfile(dest_path));
 198 }
 199
 200 TEST_F(ProfileManagerTest, DefaultProfileDir) {
 201   base::FilePath expected_default =
 202       base::FilePath().AppendASCII(chrome::kInitialProfile);
 203   EXPECT_EQ(
 204       expected_default.value(),
 205       g_browser_process->profile_manager()->GetInitialProfileDir().value());
 206 }
 207
 208 MATCHER(NotFail, "Profile creation failure status is not reported.") {
 209   return arg == Profile::CREATE_STATUS_CREATED ||
 210          arg == Profile::CREATE_STATUS_INITIALIZED;
 211 }
 212
 213 MATCHER(SameNotNull, "The same non-NULL value for all calls.") {
 214   if (!g_created_profile)
 215     g_created_profile = arg;
 216   return arg != NULL && arg == g_created_profile;
 217 }
 218
 219 #if defined(OS_CHROMEOS)
 220
 221 // This functionality only exists on Chrome OS.
 222 TEST_F(ProfileManagerTest, LoggedInProfileDir) {
 223   base::FilePath expected_default =
 224       base::FilePath().AppendASCII(chrome::kInitialProfile);
 225   ProfileManager* profile_manager = g_browser_process->profile_manager();
 226   EXPECT_EQ(expected_default.value(),
 227             profile_manager->GetInitialProfileDir().value());
 228
 229   const char kTestUserName[] = "test-user@example.com";
 230   chromeos::FakeChromeUserManager* user_manager =
 231       new chromeos::FakeChromeUserManager();
 232   chromeos::ScopedUserManagerEnabler enabler(user_manager);
 233
 234   const user_manager::User* active_user = user_manager->AddUser(kTestUserName);
 235   user_manager->LoginUser(kTestUserName);
 236   user_manager->SwitchActiveUser(kTestUserName);
 237
 238   profile_manager->Observe(
 239       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
 240       content::NotificationService::AllSources(),
 241       content::Details<const user_manager::User>(active_user));
 242   base::FilePath expected_logged_in(
 243       chromeos::ProfileHelper::GetUserProfileDir(active_user->username_hash()));
 244   EXPECT_EQ(expected_logged_in.value(),
 245             profile_manager->GetInitialProfileDir().value());
 246   VLOG(1) << temp_dir_.path().Append(
 247       profile_manager->GetInitialProfileDir()).value();
 248 }
 249
 250 #endif
 251
 252 TEST_F(ProfileManagerTest, CreateAndUseTwoProfiles) {
 253   base::FilePath dest_path1 = temp_dir_.path();
 254   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 255
 256   base::FilePath dest_path2 = temp_dir_.path();
 257   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 258
 259   ProfileManager* profile_manager = g_browser_process->profile_manager();
 260
 261   // Successfully create the profiles.
 262   TestingProfile* profile1 =
 263       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
 264   ASSERT_TRUE(profile1);
 265
 266   TestingProfile* profile2 =
 267       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
 268   ASSERT_TRUE(profile2);
 269
 270   // Force lazy-init of some profile services to simulate use.
 271   ASSERT_TRUE(profile1->CreateHistoryService(true, false));
 272   EXPECT_TRUE(HistoryServiceFactory::GetForProfile(
 273       profile1, ServiceAccessType::EXPLICIT_ACCESS));
 274   profile1->CreateBookmarkModel(true);
 275   EXPECT_TRUE(BookmarkModelFactory::GetForProfile(profile1));
 276   profile2->CreateBookmarkModel(true);
 277   EXPECT_TRUE(BookmarkModelFactory::GetForProfile(profile2));
 278   ASSERT_TRUE(profile2->CreateHistoryService(true, false));
 279   EXPECT_TRUE(HistoryServiceFactory::GetForProfile(
 280       profile2, ServiceAccessType::EXPLICIT_ACCESS));
 281
 282   // Make sure any pending tasks run before we destroy the profiles.
 283     base::RunLoop().RunUntilIdle();
 284
 285   TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
 286
 287   // Make sure history cleans up correctly.
 288   base::RunLoop().RunUntilIdle();
 289 }
 290
 291 TEST_F(ProfileManagerTest, CreateProfileAsyncMultipleRequests) {
 292   g_created_profile = NULL;
 293
 294   MockObserver mock_observer1;
 295   EXPECT_CALL(mock_observer1, OnProfileCreated(
 296       SameNotNull(), NotFail())).Times(testing::AtLeast(1));
 297   MockObserver mock_observer2;
 298   EXPECT_CALL(mock_observer2, OnProfileCreated(
 299       SameNotNull(), NotFail())).Times(testing::AtLeast(1));
 300   MockObserver mock_observer3;
 301   EXPECT_CALL(mock_observer3, OnProfileCreated(
 302       SameNotNull(), NotFail())).Times(testing::AtLeast(1));
 303
 304   ProfileManager* profile_manager = g_browser_process->profile_manager();
 305   const std::string profile_name = "New Profile";
 306   CreateProfileAsync(profile_manager, profile_name, false, &mock_observer1);
 307   CreateProfileAsync(profile_manager, profile_name, false, &mock_observer2);
 308   CreateProfileAsync(profile_manager, profile_name, false, &mock_observer3);
 309
 310   base::RunLoop().RunUntilIdle();
 311 }
 312
 313 TEST_F(ProfileManagerTest, CreateProfilesAsync) {
 314   const std::string profile_name1 = "New Profile 1";
 315   const std::string profile_name2 = "New Profile 2";
 316
 317   MockObserver mock_observer;
 318   EXPECT_CALL(mock_observer, OnProfileCreated(
 319       testing::NotNull(), NotFail())).Times(testing::AtLeast(3));
 320
 321   ProfileManager* profile_manager = g_browser_process->profile_manager();
 322
 323   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
 324   CreateProfileAsync(profile_manager, profile_name2, false, &mock_observer);
 325
 326   base::RunLoop().RunUntilIdle();
 327 }
 328
 329 TEST_F(ProfileManagerTest, CreateProfileAsyncCheckOmitted) {
 330   std::string name = "0 Supervised Profile";
 331
 332   MockObserver mock_observer;
 333   EXPECT_CALL(mock_observer, OnProfileCreated(
 334       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
 335
 336   ProfileManager* profile_manager = g_browser_process->profile_manager();
 337   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 338   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
 339
 340   CreateProfileAsync(profile_manager, name, true, &mock_observer);
 341   base::RunLoop().RunUntilIdle();
 342
 343   EXPECT_EQ(1u, cache.GetNumberOfProfiles());
 344   // Supervised profiles should start out omitted from the profile list.
 345   EXPECT_TRUE(cache.IsOmittedProfileAtIndex(0));
 346
 347   name = "1 Regular Profile";
 348   CreateProfileAsync(profile_manager, name, false, &mock_observer);
 349   base::RunLoop().RunUntilIdle();
 350
 351   EXPECT_EQ(2u, cache.GetNumberOfProfiles());
 352   // Non-supervised profiles should be included in the profile list.
 353   EXPECT_FALSE(cache.IsOmittedProfileAtIndex(1));
 354 }
 355
 356 TEST_F(ProfileManagerTest, AddProfileToCacheCheckOmitted) {
 357   ProfileManager* profile_manager = g_browser_process->profile_manager();
 358   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 359   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
 360
 361   const base::FilePath supervised_path =
 362       temp_dir_.path().AppendASCII("Supervised");
 363   TestingProfile* supervised_profile =
 364       new TestingProfile(supervised_path, NULL);
 365   supervised_profile->GetPrefs()->SetString(prefs::kSupervisedUserId, "An ID");
 366
 367   // RegisterTestingProfile adds the profile to the cache and takes ownership.
 368   profile_manager->RegisterTestingProfile(supervised_profile, true, false);
 369   EXPECT_EQ(1u, cache.GetNumberOfProfiles());
 370   EXPECT_TRUE(cache.IsOmittedProfileAtIndex(0));
 371
 372   const base::FilePath nonsupervised_path = temp_dir_.path().AppendASCII(
 373       "Non-Supervised");
 374   TestingProfile* nonsupervised_profile = new TestingProfile(nonsupervised_path,
 375                                                              NULL);
 376   profile_manager->RegisterTestingProfile(nonsupervised_profile, true, false);
 377
 378   EXPECT_EQ(2u, cache.GetNumberOfProfiles());
 379   size_t supervised_index = cache.GetIndexOfProfileWithPath(supervised_path);
 380   EXPECT_TRUE(cache.IsOmittedProfileAtIndex(supervised_index));
 381   size_t nonsupervised_index =
 382       cache.GetIndexOfProfileWithPath(nonsupervised_path);
 383   EXPECT_FALSE(cache.IsOmittedProfileAtIndex(nonsupervised_index));
 384 }
 385
 386 TEST_F(ProfileManagerTest, GetGuestProfilePath) {
 387   base::FilePath guest_path = ProfileManager::GetGuestProfilePath();
 388   base::FilePath expected_path = temp_dir_.path();
 389   expected_path = expected_path.Append(chrome::kGuestProfileDir);
 390   EXPECT_EQ(expected_path, guest_path);
 391 }
 392
 393 TEST_F(ProfileManagerTest, GetSystemProfilePath) {
 394   base::FilePath system_profile_path = ProfileManager::GetSystemProfilePath();
 395   base::FilePath expected_path = temp_dir_.path();
 396   expected_path = expected_path.Append(chrome::kSystemProfileDir);
 397   EXPECT_EQ(expected_path, system_profile_path);
 398 }
 399
 400 class UnittestGuestProfileManager : public UnittestProfileManager {
 401  public:
 402   explicit UnittestGuestProfileManager(const base::FilePath& user_data_dir)
 403       : UnittestProfileManager(user_data_dir) {}
 404
 405  protected:
 406   Profile* CreateProfileHelper(const base::FilePath& file_path) override {
 407     TestingProfile::Builder builder;
 408     builder.SetGuestSession();
 409     builder.SetPath(file_path);
 410     TestingProfile* testing_profile = builder.Build().release();
 411     return testing_profile;
 412   }
 413 };
 414
 415 class ProfileManagerGuestTest : public ProfileManagerTest  {
 416  protected:
 417   void SetUp() override {
 418     // Create a new temporary directory, and store the path
 419     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 420     TestingBrowserProcess::GetGlobal()->SetProfileManager(
 421         new UnittestGuestProfileManager(temp_dir_.path()));
 422
 423 #if defined(OS_CHROMEOS)
 424     base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
 425     // This switch is needed to skip non-test specific behavior in
 426     // ProfileManager (accessing DBusThreadManager).
 427     cl->AppendSwitch(switches::kTestType);
 428
 429     cl->AppendSwitch(chromeos::switches::kGuestSession);
 430     cl->AppendSwitch(::switches::kIncognito);
 431
 432     chromeos::WallpaperManager::Initialize();
 433     RegisterUser(chromeos::login::kGuestUserName);
 434 #endif
 435   }
 436 };
 437
 438 TEST_F(ProfileManagerGuestTest, GetLastUsedProfileAllowedByPolicy) {
 439   ProfileManager* profile_manager = g_browser_process->profile_manager();
 440   ASSERT_TRUE(profile_manager);
 441
 442   Profile* profile = profile_manager->GetLastUsedProfileAllowedByPolicy();
 443   ASSERT_TRUE(profile);
 444   EXPECT_TRUE(profile->IsOffTheRecord());
 445 }
 446
 447 #if defined(OS_CHROMEOS)
 448 TEST_F(ProfileManagerGuestTest, GuestProfileIngonito) {
 449   Profile* primary_profile = ProfileManager::GetPrimaryUserProfile();
 450   EXPECT_TRUE(primary_profile->IsOffTheRecord());
 451
 452   Profile* active_profile = ProfileManager::GetActiveUserProfile();
 453   EXPECT_TRUE(active_profile->IsOffTheRecord());
 454
 455   EXPECT_TRUE(active_profile->IsSameProfile(primary_profile));
 456
 457   Profile* last_used_profile = ProfileManager::GetLastUsedProfile();
 458   EXPECT_TRUE(last_used_profile->IsOffTheRecord());
 459
 460   EXPECT_TRUE(last_used_profile->IsSameProfile(active_profile));
 461 }
 462 #endif
 463
 464 TEST_F(ProfileManagerTest, AutoloadProfilesWithBackgroundApps) {
 465   ProfileManager* profile_manager = g_browser_process->profile_manager();
 466   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 467   local_state_.Get()->SetUserPref(prefs::kBackgroundModeEnabled,
 468                                   new base::FundamentalValue(true));
 469
 470   // Setting a pref which is not applicable to a system (i.e., Android in this
 471   // case) does not necessarily create it. Don't bother continuing with the
 472   // test if this pref doesn't exist because it will not load the profiles if
 473   // it cannot verify that the pref for background mode is enabled.
 474   if (!local_state_.Get()->HasPrefPath(prefs::kBackgroundModeEnabled))
 475     return;
 476
 477   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
 478   cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_1"),
 479                           ASCIIToUTF16("name_1"), base::string16(), 0,
 480                           std::string());
 481   cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_2"),
 482                           ASCIIToUTF16("name_2"), base::string16(), 0,
 483                           std::string());
 484   cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_3"),
 485                           ASCIIToUTF16("name_3"), base::string16(), 0,
 486                           std::string());
 487   cache.SetBackgroundStatusOfProfileAtIndex(0, true);
 488   cache.SetBackgroundStatusOfProfileAtIndex(2, true);
 489   EXPECT_EQ(3u, cache.GetNumberOfProfiles());
 490
 491   profile_manager->AutoloadProfiles();
 492
 493   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
 494 }
 495
 496 TEST_F(ProfileManagerTest, DoNotAutoloadProfilesIfBackgroundModeOff) {
 497   ProfileManager* profile_manager = g_browser_process->profile_manager();
 498   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 499   local_state_.Get()->SetUserPref(prefs::kBackgroundModeEnabled,
 500                                   new base::FundamentalValue(false));
 501
 502   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
 503   cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_1"),
 504                           ASCIIToUTF16("name_1"), base::string16(), 0,
 505                           std::string());
 506   cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_2"),
 507                           ASCIIToUTF16("name_2"), base::string16(), 0,
 508                           std::string());
 509   cache.SetBackgroundStatusOfProfileAtIndex(0, false);
 510   cache.SetBackgroundStatusOfProfileAtIndex(1, true);
 511   EXPECT_EQ(2u, cache.GetNumberOfProfiles());
 512
 513   profile_manager->AutoloadProfiles();
 514
 515   EXPECT_EQ(0u, profile_manager->GetLoadedProfiles().size());
 516 }
 517
 518 TEST_F(ProfileManagerTest, InitProfileUserPrefs) {
 519   base::FilePath dest_path = temp_dir_.path();
 520   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 521
 522   ProfileManager* profile_manager = g_browser_process->profile_manager();
 523
 524   Profile* profile;
 525
 526   // Successfully create the profile
 527   profile = profile_manager->GetProfile(dest_path);
 528   ASSERT_TRUE(profile);
 529
 530   // Check that the profile name is non empty
 531   std::string profile_name =
 532       profile->GetPrefs()->GetString(prefs::kProfileName);
 533   EXPECT_FALSE(profile_name.empty());
 534
 535   // Check that the profile avatar index is valid
 536   size_t avatar_index =
 537       profile->GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
 538   EXPECT_TRUE(profiles::IsDefaultAvatarIconIndex(
 539       avatar_index));
 540 }
 541
 542 // Tests that a new profile's entry in the profile info cache is setup with the
 543 // same values that are in the profile prefs.
 544 TEST_F(ProfileManagerTest, InitProfileInfoCacheForAProfile) {
 545   base::FilePath dest_path = temp_dir_.path();
 546   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 547
 548   ProfileManager* profile_manager = g_browser_process->profile_manager();
 549   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 550
 551   // Successfully create the profile
 552   Profile* profile = profile_manager->GetProfile(dest_path);
 553   ASSERT_TRUE(profile);
 554
 555   std::string profile_name =
 556       profile->GetPrefs()->GetString(prefs::kProfileName);
 557   size_t avatar_index =
 558       profile->GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
 559
 560   size_t profile_index = cache.GetIndexOfProfileWithPath(dest_path);
 561
 562   // Check if the profile prefs are the same as the cache prefs
 563   EXPECT_EQ(profile_name,
 564             base::UTF16ToUTF8(cache.GetNameOfProfileAtIndex(profile_index)));
 565   EXPECT_EQ(avatar_index,
 566             cache.GetAvatarIconIndexOfProfileAtIndex(profile_index));
 567 }
 568
 569 TEST_F(ProfileManagerTest, GetLastUsedProfileAllowedByPolicy) {
 570   ProfileManager* profile_manager = g_browser_process->profile_manager();
 571   ASSERT_TRUE(profile_manager);
 572
 573 #if defined(OS_CHROMEOS)
 574   // On CrOS, profile returned by GetLastUsedProfile is a singin profile that
 575   // is forced to be incognito. That's why we need to create at least one user
 576   // to get a regular profile.
 577   RegisterUser("test-user@example.com");
 578 #endif
 579
 580   Profile* profile = profile_manager->GetLastUsedProfileAllowedByPolicy();
 581   ASSERT_TRUE(profile);
 582   EXPECT_FALSE(profile->IsOffTheRecord());
 583   PrefService* prefs = profile->GetPrefs();
 584   EXPECT_EQ(IncognitoModePrefs::ENABLED,
 585             IncognitoModePrefs::GetAvailability(prefs));
 586
 587   ASSERT_TRUE(profile->GetOffTheRecordProfile());
 588
 589   IncognitoModePrefs::SetAvailability(prefs, IncognitoModePrefs::DISABLED);
 590   EXPECT_FALSE(
 591       profile_manager->GetLastUsedProfileAllowedByPolicy()->IsOffTheRecord());
 592
 593   // GetLastUsedProfileAllowedByPolicy() returns the incognito Profile when
 594   // incognito mode is forced.
 595   IncognitoModePrefs::SetAvailability(prefs, IncognitoModePrefs::FORCED);
 596   EXPECT_TRUE(
 597       profile_manager->GetLastUsedProfileAllowedByPolicy()->IsOffTheRecord());
 598 }
 599
 600 #if !defined(OS_ANDROID)
 601 // There's no Browser object on Android.
 602 TEST_F(ProfileManagerTest, LastOpenedProfiles) {
 603   base::FilePath dest_path1 = temp_dir_.path();
 604   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 605
 606   base::FilePath dest_path2 = temp_dir_.path();
 607   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 608
 609   ProfileManager* profile_manager = g_browser_process->profile_manager();
 610
 611   // Successfully create the profiles.
 612   TestingProfile* profile1 =
 613       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
 614   ASSERT_TRUE(profile1);
 615
 616   TestingProfile* profile2 =
 617       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
 618   ASSERT_TRUE(profile2);
 619
 620   std::vector<Profile*> last_opened_profiles =
 621       profile_manager->GetLastOpenedProfiles();
 622   ASSERT_EQ(0U, last_opened_profiles.size());
 623
 624   // Create a browser for profile1.
 625   Browser::CreateParams profile1_params(profile1, chrome::GetActiveDesktop());
 626   scoped_ptr<Browser> browser1a(
 627       chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
 628
 629   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 630   ASSERT_EQ(1U, last_opened_profiles.size());
 631   EXPECT_EQ(profile1, last_opened_profiles[0]);
 632
 633   // And for profile2.
 634   Browser::CreateParams profile2_params(profile2, chrome::GetActiveDesktop());
 635   scoped_ptr<Browser> browser2(
 636       chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
 637
 638   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 639   ASSERT_EQ(2U, last_opened_profiles.size());
 640   EXPECT_EQ(profile1, last_opened_profiles[0]);
 641   EXPECT_EQ(profile2, last_opened_profiles[1]);
 642
 643   // Adding more browsers doesn't change anything.
 644   scoped_ptr<Browser> browser1b(
 645       chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
 646   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 647   ASSERT_EQ(2U, last_opened_profiles.size());
 648   EXPECT_EQ(profile1, last_opened_profiles[0]);
 649   EXPECT_EQ(profile2, last_opened_profiles[1]);
 650
 651   // Close the browsers.
 652   browser1a.reset();
 653   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 654   ASSERT_EQ(2U, last_opened_profiles.size());
 655   EXPECT_EQ(profile1, last_opened_profiles[0]);
 656   EXPECT_EQ(profile2, last_opened_profiles[1]);
 657
 658   browser1b.reset();
 659   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 660   ASSERT_EQ(1U, last_opened_profiles.size());
 661   EXPECT_EQ(profile2, last_opened_profiles[0]);
 662
 663   browser2.reset();
 664   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 665   ASSERT_EQ(0U, last_opened_profiles.size());
 666 }
 667
 668 TEST_F(ProfileManagerTest, LastOpenedProfilesAtShutdown) {
 669   base::FilePath dest_path1 = temp_dir_.path();
 670   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 671
 672   base::FilePath dest_path2 = temp_dir_.path();
 673   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 674
 675   ProfileManager* profile_manager = g_browser_process->profile_manager();
 676
 677   // Successfully create the profiles.
 678   TestingProfile* profile1 =
 679       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
 680   ASSERT_TRUE(profile1);
 681
 682   TestingProfile* profile2 =
 683       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
 684   ASSERT_TRUE(profile2);
 685
 686   // Create a browser for profile1.
 687   Browser::CreateParams profile1_params(profile1, chrome::GetActiveDesktop());
 688   scoped_ptr<Browser> browser1(
 689       chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
 690
 691   // And for profile2.
 692   Browser::CreateParams profile2_params(profile2, chrome::GetActiveDesktop());
 693   scoped_ptr<Browser> browser2(
 694       chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
 695
 696   std::vector<Profile*> last_opened_profiles =
 697       profile_manager->GetLastOpenedProfiles();
 698   ASSERT_EQ(2U, last_opened_profiles.size());
 699   EXPECT_EQ(profile1, last_opened_profiles[0]);
 700   EXPECT_EQ(profile2, last_opened_profiles[1]);
 701
 702   // Simulate a shutdown.
 703   content::NotificationService::current()->Notify(
 704       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
 705       content::NotificationService::AllSources(),
 706       content::NotificationService::NoDetails());
 707
 708   // Even if the browsers are destructed during shutdown, the profiles stay
 709   // open.
 710   browser1.reset();
 711   browser2.reset();
 712
 713   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 714   ASSERT_EQ(2U, last_opened_profiles.size());
 715   EXPECT_EQ(profile1, last_opened_profiles[0]);
 716   EXPECT_EQ(profile2, last_opened_profiles[1]);
 717 }
 718
 719 TEST_F(ProfileManagerTest, LastOpenedProfilesDoesNotContainIncognito) {
 720   base::FilePath dest_path1 = temp_dir_.path();
 721   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 722   base::FilePath dest_path2 = temp_dir_.path();
 723   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 724
 725   ProfileManager* profile_manager = g_browser_process->profile_manager();
 726
 727   // Successfully create the profiles.
 728   TestingProfile* profile1 =
 729       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
 730   ASSERT_TRUE(profile1);
 731
 732   std::vector<Profile*> last_opened_profiles =
 733       profile_manager->GetLastOpenedProfiles();
 734   ASSERT_EQ(0U, last_opened_profiles.size());
 735
 736   // Create a browser for profile1.
 737   Browser::CreateParams profile1_params(profile1, chrome::GetActiveDesktop());
 738   scoped_ptr<Browser> browser1(
 739       chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
 740
 741   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 742   ASSERT_EQ(1U, last_opened_profiles.size());
 743   EXPECT_EQ(profile1, last_opened_profiles[0]);
 744
 745   // And for profile2.
 746   Browser::CreateParams profile2_params(profile1->GetOffTheRecordProfile(),
 747                                         chrome::GetActiveDesktop());
 748   scoped_ptr<Browser> browser2a(
 749       chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
 750
 751   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 752   ASSERT_EQ(1U, last_opened_profiles.size());
 753   EXPECT_EQ(profile1, last_opened_profiles[0]);
 754
 755   // Adding more browsers doesn't change anything.
 756   scoped_ptr<Browser> browser2b(
 757       chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
 758   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 759   ASSERT_EQ(1U, last_opened_profiles.size());
 760   EXPECT_EQ(profile1, last_opened_profiles[0]);
 761
 762   // Close the browsers.
 763   browser2a.reset();
 764   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 765   ASSERT_EQ(1U, last_opened_profiles.size());
 766   EXPECT_EQ(profile1, last_opened_profiles[0]);
 767
 768   browser2b.reset();
 769   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 770   ASSERT_EQ(1U, last_opened_profiles.size());
 771   EXPECT_EQ(profile1, last_opened_profiles[0]);
 772
 773   browser1.reset();
 774   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 775   ASSERT_EQ(0U, last_opened_profiles.size());
 776 }
 777 #endif  // !defined(OS_ANDROID)
 778
 779 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 780 // There's no Browser object on Android and there's no multi-profiles on Chrome.
 781 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastProfile) {
 782   base::FilePath dest_path = temp_dir_.path();
 783   dest_path = dest_path.Append(FILE_PATH_LITERAL("Ephemeral Profile"));
 784
 785   ProfileManager* profile_manager = g_browser_process->profile_manager();
 786
 787   TestingProfile* profile =
 788       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path));
 789   ASSERT_TRUE(profile);
 790   profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
 791
 792   // Here the last used profile is still the "Default" profile.
 793   Profile* last_used_profile = profile_manager->GetLastUsedProfile();
 794   EXPECT_NE(profile, last_used_profile);
 795
 796   // Create a browser for the profile.
 797   Browser::CreateParams profile_params(profile, chrome::GetActiveDesktop());
 798   scoped_ptr<Browser> browser(
 799       chrome::CreateBrowserWithTestWindowForParams(&profile_params));
 800   last_used_profile = profile_manager->GetLastUsedProfile();
 801   EXPECT_NE(profile, last_used_profile);
 802
 803   // Close the browser.
 804   browser.reset();
 805   last_used_profile = profile_manager->GetLastUsedProfile();
 806   EXPECT_NE(profile, last_used_profile);
 807 }
 808
 809 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastOpenedAtShutdown) {
 810   base::FilePath dest_path1 = temp_dir_.path();
 811   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("Normal Profile"));
 812
 813   base::FilePath dest_path2 = temp_dir_.path();
 814   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("Ephemeral Profile 1"));
 815
 816   base::FilePath dest_path3 = temp_dir_.path();
 817   dest_path3 = dest_path3.Append(FILE_PATH_LITERAL("Ephemeral Profile 2"));
 818
 819   ProfileManager* profile_manager = g_browser_process->profile_manager();
 820
 821   // Successfully create the profiles.
 822   TestingProfile* normal_profile =
 823       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
 824   ASSERT_TRUE(normal_profile);
 825
 826   // Add one ephemeral profile which should not end up in this list.
 827   TestingProfile* ephemeral_profile1 =
 828       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
 829   ASSERT_TRUE(ephemeral_profile1);
 830   ephemeral_profile1->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
 831                                              true);
 832
 833   // Add second ephemeral profile but don't mark it as such yet.
 834   TestingProfile* ephemeral_profile2 =
 835       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path3));
 836   ASSERT_TRUE(ephemeral_profile2);
 837
 838   // Create a browser for profile1.
 839   Browser::CreateParams profile1_params(normal_profile,
 840                                         chrome::GetActiveDesktop());
 841   scoped_ptr<Browser> browser1(
 842       chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
 843
 844   // Create browsers for the ephemeral profile.
 845   Browser::CreateParams profile2_params(ephemeral_profile1,
 846                                         chrome::GetActiveDesktop());
 847   scoped_ptr<Browser> browser2(
 848       chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
 849
 850   Browser::CreateParams profile3_params(ephemeral_profile2,
 851                                         chrome::GetActiveDesktop());
 852   scoped_ptr<Browser> browser3(
 853       chrome::CreateBrowserWithTestWindowForParams(&profile3_params));
 854
 855   std::vector<Profile*> last_opened_profiles =
 856       profile_manager->GetLastOpenedProfiles();
 857   ASSERT_EQ(2U, last_opened_profiles.size());
 858   EXPECT_EQ(normal_profile, last_opened_profiles[0]);
 859   EXPECT_EQ(ephemeral_profile2, last_opened_profiles[1]);
 860
 861   // Mark the second profile ephemeral.
 862   ephemeral_profile2->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
 863                                              true);
 864
 865   // Simulate a shutdown.
 866   content::NotificationService::current()->Notify(
 867       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
 868       content::NotificationService::AllSources(),
 869       content::NotificationService::NoDetails());
 870   browser1.reset();
 871   browser2.reset();
 872   browser3.reset();
 873
 874   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
 875   ASSERT_EQ(1U, last_opened_profiles.size());
 876   EXPECT_EQ(normal_profile, last_opened_profiles[0]);
 877 }
 878
 879 TEST_F(ProfileManagerTest, ActiveProfileDeleted) {
 880   ProfileManager* profile_manager = g_browser_process->profile_manager();
 881   ASSERT_TRUE(profile_manager);
 882
 883   // Create and load two profiles.
 884   const std::string profile_name1 = "New Profile 1";
 885   const std::string profile_name2 = "New Profile 2";
 886   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
 887   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 888
 889   MockObserver mock_observer;
 890   EXPECT_CALL(mock_observer, OnProfileCreated(
 891       testing::NotNull(), NotFail())).Times(testing::AtLeast(3));
 892
 893   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
 894   CreateProfileAsync(profile_manager, profile_name2, false, &mock_observer);
 895   base::RunLoop().RunUntilIdle();
 896
 897   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
 898   EXPECT_EQ(2u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
 899
 900   // Set the active profile.
 901   PrefService* local_state = g_browser_process->local_state();
 902   local_state->SetString(prefs::kProfileLastUsed, profile_name1);
 903
 904   // Delete the active profile.
 905   profile_manager->ScheduleProfileForDeletion(dest_path1,
 906                                               ProfileManager::CreateCallback());
 907   // Spin the message loop so that all the callbacks can finish running.
 908   base::RunLoop().RunUntilIdle();
 909
 910   EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
 911   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
 912 }
 913
 914 TEST_F(ProfileManagerTest, LastProfileDeleted) {
 915   ProfileManager* profile_manager = g_browser_process->profile_manager();
 916   ASSERT_TRUE(profile_manager);
 917
 918   // Create and load a profile.
 919   const std::string profile_name1 = "New Profile 1";
 920   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
 921
 922   MockObserver mock_observer;
 923   EXPECT_CALL(mock_observer, OnProfileCreated(
 924       testing::NotNull(), NotFail())).Times(testing::AtLeast(1));
 925
 926   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
 927   base::RunLoop().RunUntilIdle();
 928
 929   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
 930   EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
 931
 932   // Set it as the active profile.
 933   PrefService* local_state = g_browser_process->local_state();
 934   local_state->SetString(prefs::kProfileLastUsed, profile_name1);
 935
 936   // Delete the active profile.
 937   profile_manager->ScheduleProfileForDeletion(dest_path1,
 938                                               ProfileManager::CreateCallback());
 939   // Spin the message loop so that all the callbacks can finish running.
 940   base::RunLoop().RunUntilIdle();
 941
 942   // A new profile should have been created
 943   const std::string profile_name2 = "Profile 1";
 944   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 945
 946   EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
 947   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
 948   EXPECT_EQ(dest_path2,
 949       profile_manager->GetProfileInfoCache().GetPathOfProfileAtIndex(0));
 950 }
 951
 952 TEST_F(ProfileManagerTest, LastProfileDeletedWithGuestActiveProfile) {
 953   ProfileManager* profile_manager = g_browser_process->profile_manager();
 954   ASSERT_TRUE(profile_manager);
 955
 956   // Create and load a profile.
 957   const std::string profile_name1 = "New Profile 1";
 958   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
 959
 960   MockObserver mock_observer;
 961   EXPECT_CALL(mock_observer, OnProfileCreated(
 962       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
 963
 964   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
 965   base::RunLoop().RunUntilIdle();
 966
 967   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
 968   EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
 969
 970   // Create the profile and register it.
 971   const std::string guest_profile_name =
 972       ProfileManager::GetGuestProfilePath().BaseName().MaybeAsASCII();
 973
 974   TestingProfile::Builder builder;
 975   builder.SetGuestSession();
 976   builder.SetPath(ProfileManager::GetGuestProfilePath());
 977   TestingProfile* guest_profile = builder.Build().release();
 978   guest_profile->set_profile_name(guest_profile_name);
 979   // Registering the profile passes ownership to the ProfileManager.
 980   profile_manager->RegisterTestingProfile(guest_profile, false, false);
 981
 982   // The Guest profile does not get added to the ProfileInfoCache.
 983   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
 984   EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
 985
 986   // Set the Guest profile as the active profile.
 987   PrefService* local_state = g_browser_process->local_state();
 988   local_state->SetString(prefs::kProfileLastUsed, guest_profile_name);
 989
 990   // Delete the other profile.
 991   profile_manager->ScheduleProfileForDeletion(dest_path1,
 992                                               ProfileManager::CreateCallback());
 993   // Spin the message loop so that all the callbacks can finish running.
 994   base::RunLoop().RunUntilIdle();
 995
 996   // A new profile should have been created.
 997   const std::string profile_name2 = "Profile 1";
 998   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 999
1000   EXPECT_EQ(3u, profile_manager->GetLoadedProfiles().size());
1001   EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
1002   EXPECT_EQ(dest_path2,
1003       profile_manager->GetProfileInfoCache().GetPathOfProfileAtIndex(0));
1004 }
1005
1006 TEST_F(ProfileManagerTest, ProfileDisplayNameResetsDefaultName) {
1007   if (!profiles::IsMultipleProfilesEnabled())
1008     return;
1009
1010   // The command line is reset at the end of every test by the test suite.
1011   switches::EnableNewAvatarMenuForTesting(
1012       base::CommandLine::ForCurrentProcess());
1013
1014   ProfileManager* profile_manager = g_browser_process->profile_manager();
1015   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1016   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
1017
1018   // Only one local profile means we display IDS_SINGLE_PROFILE_DISPLAY_NAME.
1019   const base::string16 default_profile_name =
1020       l10n_util::GetStringUTF16(IDS_SINGLE_PROFILE_DISPLAY_NAME);
1021   const base::string16 profile_name1 = cache.ChooseNameForNewProfile(0);
1022   Profile* profile1 = AddProfileToCache(profile_manager,
1023                                         "path_1", profile_name1);
1024   EXPECT_EQ(default_profile_name,
1025             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1026
1027   // Multiple profiles means displaying the actual profile names.
1028   const base::string16 profile_name2 = cache.ChooseNameForNewProfile(1);
1029   Profile* profile2 = AddProfileToCache(profile_manager,
1030                                         "path_2", profile_name2);
1031   EXPECT_EQ(profile_name1,
1032             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1033   EXPECT_EQ(profile_name2,
1034             profiles::GetAvatarNameForProfile(profile2->GetPath()));
1035
1036   // Deleting a profile means returning to the default name.
1037   profile_manager->ScheduleProfileForDeletion(profile2->GetPath(),
1038                                               ProfileManager::CreateCallback());
1039   // Spin the message loop so that all the callbacks can finish running.
1040   base::RunLoop().RunUntilIdle();
1041   EXPECT_EQ(default_profile_name,
1042             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1043 }
1044
1045 TEST_F(ProfileManagerTest, ProfileDisplayNamePreservesCustomName) {
1046   if (!profiles::IsMultipleProfilesEnabled())
1047     return;
1048
1049   // The command line is reset at the end of every test by the test suite.
1050   switches::EnableNewAvatarMenuForTesting(
1051       base::CommandLine::ForCurrentProcess());
1052
1053   ProfileManager* profile_manager = g_browser_process->profile_manager();
1054   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1055   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
1056
1057   // Only one local profile means we display IDS_SINGLE_PROFILE_DISPLAY_NAME.
1058   const base::string16 default_profile_name =
1059       l10n_util::GetStringUTF16(IDS_SINGLE_PROFILE_DISPLAY_NAME);
1060   const base::string16 profile_name1 = cache.ChooseNameForNewProfile(0);
1061   Profile* profile1 = AddProfileToCache(profile_manager,
1062                                         "path_1", profile_name1);
1063   EXPECT_EQ(default_profile_name,
1064             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1065
1066   // We should display custom names for local profiles.
1067   const base::string16 custom_profile_name = ASCIIToUTF16("Batman");
1068   cache.SetNameOfProfileAtIndex(0, custom_profile_name);
1069   cache.SetProfileIsUsingDefaultNameAtIndex(0, false);
1070   EXPECT_EQ(custom_profile_name, cache.GetNameOfProfileAtIndex(0));
1071   EXPECT_EQ(custom_profile_name,
1072             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1073
1074   // Multiple profiles means displaying the actual profile names.
1075   const base::string16 profile_name2 = cache.ChooseNameForNewProfile(1);
1076   Profile* profile2 = AddProfileToCache(profile_manager,
1077                                         "path_2", profile_name2);
1078   EXPECT_EQ(custom_profile_name,
1079             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1080   EXPECT_EQ(profile_name2,
1081             profiles::GetAvatarNameForProfile(profile2->GetPath()));
1082
1083   // Deleting a profile means returning to the original, custom name.
1084   profile_manager->ScheduleProfileForDeletion(profile2->GetPath(),
1085                                               ProfileManager::CreateCallback());
1086   // Spin the message loop so that all the callbacks can finish running.
1087   base::RunLoop().RunUntilIdle();
1088   EXPECT_EQ(custom_profile_name,
1089             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1090 }
1091
1092 TEST_F(ProfileManagerTest, ProfileDisplayNamePreservesSignedInName) {
1093   if (!profiles::IsMultipleProfilesEnabled())
1094     return;
1095
1096   // The command line is reset at the end of every test by the test suite.
1097   switches::EnableNewAvatarMenuForTesting(
1098       base::CommandLine::ForCurrentProcess());
1099
1100   ProfileManager* profile_manager = g_browser_process->profile_manager();
1101   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1102   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
1103
1104   // Only one local profile means we display IDS_SINGLE_PROFILE_DISPLAY_NAME.
1105   const base::string16 default_profile_name =
1106       l10n_util::GetStringUTF16(IDS_SINGLE_PROFILE_DISPLAY_NAME);
1107   const base::string16 profile_name1 = cache.ChooseNameForNewProfile(0);
1108   Profile* profile1 = AddProfileToCache(profile_manager,
1109                                         "path_1", profile_name1);
1110   EXPECT_EQ(default_profile_name,
1111             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1112
1113   // For a signed in profile with a default name we still display
1114   // IDS_SINGLE_PROFILE_DISPLAY_NAME.
1115   cache.SetUserNameOfProfileAtIndex(0, ASCIIToUTF16("user@gmail.com"));
1116   EXPECT_EQ(profile_name1, cache.GetNameOfProfileAtIndex(0));
1117   EXPECT_EQ(default_profile_name,
1118             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1119
1120   // For a signed in profile with a non-default Gaia given name we display the
1121   // Gaia given name.
1122   cache.SetUserNameOfProfileAtIndex(0, ASCIIToUTF16("user@gmail.com"));
1123   const base::string16 gaia_given_name(ASCIIToUTF16("given name"));
1124   cache.SetGAIAGivenNameOfProfileAtIndex(0, gaia_given_name);
1125   EXPECT_EQ(gaia_given_name, cache.GetNameOfProfileAtIndex(0));
1126   EXPECT_EQ(gaia_given_name,
1127       profiles::GetAvatarNameForProfile(profile1->GetPath()));
1128
1129   // Multiple profiles means displaying the actual profile names.
1130   const base::string16 profile_name2 = cache.ChooseNameForNewProfile(1);
1131   Profile* profile2 = AddProfileToCache(profile_manager,
1132                                         "path_2", profile_name2);
1133   EXPECT_EQ(gaia_given_name,
1134             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1135   EXPECT_EQ(profile_name2,
1136             profiles::GetAvatarNameForProfile(profile2->GetPath()));
1137
1138   // Deleting a profile means returning to the original, actual profile name.
1139   profile_manager->ScheduleProfileForDeletion(profile2->GetPath(),
1140                                               ProfileManager::CreateCallback());
1141   // Spin the message loop so that all the callbacks can finish running.
1142   base::RunLoop().RunUntilIdle();
1143   EXPECT_EQ(gaia_given_name,
1144             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1145 }
1146
1147 TEST_F(ProfileManagerTest, ProfileDisplayNameIsEmailIfDefaultName) {
1148   if (!profiles::IsMultipleProfilesEnabled())
1149     return;
1150
1151   // The command line is reset at the end of every test by the test suite.
1152   switches::EnableNewAvatarMenuForTesting(
1153       base::CommandLine::ForCurrentProcess());
1154
1155   ProfileManager* profile_manager = g_browser_process->profile_manager();
1156   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1157   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
1158
1159   // Create two signed in profiles, with both new and legacy default names, and
1160   // a profile with a custom name.
1161   Profile* profile1 = AddProfileToCache(
1162       profile_manager, "path_1", ASCIIToUTF16("Person 1"));
1163   Profile* profile2 = AddProfileToCache(
1164       profile_manager, "path_2", ASCIIToUTF16("Default Profile"));
1165   const base::string16 profile_name3(ASCIIToUTF16("Batman"));
1166   Profile* profile3 = AddProfileToCache(
1167       profile_manager, "path_3", profile_name3);
1168   EXPECT_EQ(3u, cache.GetNumberOfProfiles());
1169
1170   // Sign in all profiles, and make sure they do not have a Gaia name set.
1171   const base::string16 email1(ASCIIToUTF16("user1@gmail.com"));
1172   const base::string16 email2(ASCIIToUTF16("user2@gmail.com"));
1173   const base::string16 email3(ASCIIToUTF16("user3@gmail.com"));
1174
1175   int index = cache.GetIndexOfProfileWithPath(profile1->GetPath());
1176   cache.SetUserNameOfProfileAtIndex(index, email1);
1177   cache.SetGAIAGivenNameOfProfileAtIndex(index, base::string16());
1178   cache.SetGAIANameOfProfileAtIndex(index, base::string16());
1179
1180   // This may resort the cache, so be extra cautious to use the right profile.
1181   index = cache.GetIndexOfProfileWithPath(profile2->GetPath());
1182   cache.SetUserNameOfProfileAtIndex(index, email2);
1183   cache.SetGAIAGivenNameOfProfileAtIndex(index, base::string16());
1184   cache.SetGAIANameOfProfileAtIndex(index, base::string16());
1185
1186   index = cache.GetIndexOfProfileWithPath(profile3->GetPath());
1187   cache.SetUserNameOfProfileAtIndex(index, email3);
1188   cache.SetGAIAGivenNameOfProfileAtIndex(index, base::string16());
1189   cache.SetGAIANameOfProfileAtIndex(index, base::string16());
1190
1191   // The profiles with default names should display the email address.
1192   EXPECT_EQ(email1, profiles::GetAvatarNameForProfile(profile1->GetPath()));
1193   EXPECT_EQ(email2, profiles::GetAvatarNameForProfile(profile2->GetPath()));
1194
1195   // The profile with the custom name should display that.
1196   EXPECT_EQ(profile_name3,
1197             profiles::GetAvatarNameForProfile(profile3->GetPath()));
1198
1199   // Adding a Gaia name to a profile that previously had a default name should
1200   // start displaying it.
1201   const base::string16 gaia_given_name(ASCIIToUTF16("Robin"));
1202   cache.SetGAIAGivenNameOfProfileAtIndex(
1203       cache.GetIndexOfProfileWithPath(profile1->GetPath()), gaia_given_name);
1204   EXPECT_EQ(gaia_given_name,
1205             profiles::GetAvatarNameForProfile(profile1->GetPath()));
1206 }
1207 #endif  // !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
1208
1209 #if defined(OS_MACOSX)
1210 // These tests are for a Mac-only code path that assumes the browser
1211 // process isn't killed when all browser windows are closed.
1212 TEST_F(ProfileManagerTest, ActiveProfileDeletedNeedsToLoadNextProfile) {
1213   ProfileManager* profile_manager = g_browser_process->profile_manager();
1214   ASSERT_TRUE(profile_manager);
1215
1216   // Create and load one profile, and just create a second profile.
1217   const std::string profile_name1 = "New Profile 1";
1218   const std::string profile_name2 = "New Profile 2";
1219   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
1220   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
1221
1222   MockObserver mock_observer;
1223   EXPECT_CALL(mock_observer, OnProfileCreated(
1224       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
1225   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
1226   base::RunLoop().RunUntilIdle();
1227
1228   // Track the profile, but don't load it.
1229   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1230   cache.AddProfileToCache(dest_path2, ASCIIToUTF16(profile_name2),
1231                           base::string16(), 0, std::string());
1232   base::RunLoop().RunUntilIdle();
1233
1234   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
1235   EXPECT_EQ(2u, cache.GetNumberOfProfiles());
1236
1237   // Set the active profile.
1238   PrefService* local_state = g_browser_process->local_state();
1239   local_state->SetString(prefs::kProfileLastUsed,
1240                          dest_path1.BaseName().MaybeAsASCII());
1241
1242   // Delete the active profile. This should switch and load the unloaded
1243   // profile.
1244   profile_manager->ScheduleProfileForDeletion(dest_path1,
1245                                               ProfileManager::CreateCallback());
1246
1247   // Spin the message loop so that all the callbacks can finish running.
1248   base::RunLoop().RunUntilIdle();
1249
1250   EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
1251   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
1252 }
1253
1254 // This tests the recursive call in ProfileManager::OnNewActiveProfileLoaded
1255 // by simulating a scenario in which the profile that is being loaded as
1256 // the next active profile has also been marked for deletion, so the
1257 // ProfileManager needs to recursively select a different next profile.
1258 TEST_F(ProfileManagerTest, ActiveProfileDeletedNextProfileDeletedToo) {
1259   ProfileManager* profile_manager = g_browser_process->profile_manager();
1260   ASSERT_TRUE(profile_manager);
1261
1262   // Create and load one profile, and create two more profiles.
1263   const std::string profile_name1 = "New Profile 1";
1264   const std::string profile_name2 = "New Profile 2";
1265   const std::string profile_name3 = "New Profile 3";
1266   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
1267   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
1268   base::FilePath dest_path3 = temp_dir_.path().AppendASCII(profile_name3);
1269
1270   MockObserver mock_observer;
1271   EXPECT_CALL(mock_observer, OnProfileCreated(
1272       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
1273   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
1274   base::RunLoop().RunUntilIdle();
1275
1276   // Create the other profiles, but don't load them. Assign a fake avatar icon
1277   // to ensure that profiles in the info cache are sorted by the profile name,
1278   // and not randomly by the avatar name.
1279   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1280   cache.AddProfileToCache(dest_path2, ASCIIToUTF16(profile_name2),
1281                           ASCIIToUTF16(profile_name2), 1, std::string());
1282   cache.AddProfileToCache(dest_path3, ASCIIToUTF16(profile_name3),
1283                           ASCIIToUTF16(profile_name3), 2, std::string());
1284
1285   base::RunLoop().RunUntilIdle();
1286
1287   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
1288   EXPECT_EQ(3u, cache.GetNumberOfProfiles());
1289
1290   // Set the active profile.
1291   PrefService* local_state = g_browser_process->local_state();
1292   local_state->SetString(prefs::kProfileLastUsed,
1293                          dest_path1.BaseName().MaybeAsASCII());
1294
1295   // Delete the active profile, Profile1.
1296   // This will post a CreateProfileAsync message, that tries to load Profile2,
1297   // which checks that the profile is not being deleted, and then calls back
1298   // FinishDeletingProfile for Profile1.
1299   // Try to break this flow by setting the active profile to Profile2 in the
1300   // middle (so after the first posted message), and trying to delete Profile2,
1301   // so that the ProfileManager has to look for a different profile to load.
1302   profile_manager->ScheduleProfileForDeletion(dest_path1,
1303                                               ProfileManager::CreateCallback());
1304   local_state->SetString(prefs::kProfileLastUsed,
1305                          dest_path2.BaseName().MaybeAsASCII());
1306   profile_manager->ScheduleProfileForDeletion(dest_path2,
1307                                               ProfileManager::CreateCallback());
1308   // Spin the message loop so that all the callbacks can finish running.
1309   base::RunLoop().RunUntilIdle();
1310
1311   EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
1312   EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
1313 }
1314 #endif  // !defined(OS_MACOSX)