chrome/browser/profiles/profile_manager_browsertest.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 "base/bind.h"
   6 #include "base/command_line.h"
   7 #include "base/prefs/pref_service.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/profiles/profile_info_cache.h"
  10 #include "chrome/browser/profiles/profile_info_cache_observer.h"
  11 #include "chrome/browser/profiles/profile_manager.h"
  12 #include "chrome/browser/profiles/profile_window.h"
  13 #include "chrome/browser/profiles/profiles_state.h"
  14 #include "chrome/browser/ui/browser_finder.h"
  15 #include "chrome/browser/ui/browser_list.h"
  16 #include "chrome/browser/ui/browser_window.h"
  17 #include "chrome/browser/ui/host_desktop.h"
  18 #include "chrome/common/pref_names.h"
  19 #include "chrome/test/base/in_process_browser_test.h"
  20 #include "chrome/test/base/test_switches.h"
  21 #include "chrome/test/base/testing_browser_process.h"
  22 #include "chrome/test/base/ui_test_utils.h"
  23
  24 #if defined(OS_CHROMEOS)
  25 #include "base/path_service.h"
  26 #include "chrome/common/chrome_constants.h"
  27 #include "chrome/common/chrome_paths.h"
  28 #include "chromeos/chromeos_switches.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30 #endif
  31
  32 namespace {
  33
  34 const profiles::ProfileSwitchingDoneCallback kOnProfileSwitchDoNothing;
  35
  36 // An observer that returns back to test code after a new profile is
  37 // initialized.
  38 void OnUnblockOnProfileCreation(Profile* profile,
  39                                 Profile::CreateStatus status) {
  40   if (status == Profile::CREATE_STATUS_INITIALIZED)
  41     base::MessageLoop::current()->Quit();
  42 }
  43
  44 void ProfileCreationComplete(Profile* profile, Profile::CreateStatus status) {
  45   ASSERT_NE(status, Profile::CREATE_STATUS_LOCAL_FAIL);
  46   ASSERT_NE(status, Profile::CREATE_STATUS_REMOTE_FAIL);
  47   // No browser should have been created for this profile yet.
  48   EXPECT_EQ(chrome::GetTotalBrowserCountForProfile(profile), 0U);
  49   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
  50   if (status == Profile::CREATE_STATUS_INITIALIZED)
  51     base::MessageLoop::current()->Quit();
  52 }
  53
  54 void EphemeralProfileCreationComplete(Profile* profile,
  55                                       Profile::CreateStatus status) {
  56   if (status == Profile::CREATE_STATUS_INITIALIZED)
  57     profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
  58   ProfileCreationComplete(profile, status);
  59 }
  60
  61 class ProfileRemovalObserver : public ProfileInfoCacheObserver {
  62  public:
  63   ProfileRemovalObserver() {
  64     g_browser_process->profile_manager()->GetProfileInfoCache().AddObserver(
  65         this);
  66   }
  67
  68   virtual ~ProfileRemovalObserver() {
  69     g_browser_process->profile_manager()->GetProfileInfoCache().RemoveObserver(
  70         this);
  71   }
  72
  73   std::string last_used_profile_name() { return last_used_profile_name_; }
  74
  75   // ProfileInfoCacheObserver overrides:
  76   virtual void OnProfileWillBeRemoved(
  77       const base::FilePath& profile_path) OVERRIDE {
  78     last_used_profile_name_ = g_browser_process->local_state()->GetString(
  79         prefs::kProfileLastUsed);
  80   }
  81
  82  private:
  83   std::string last_used_profile_name_;
  84
  85   DISALLOW_COPY_AND_ASSIGN(ProfileRemovalObserver);
  86 };
  87
  88 } // namespace
  89
  90 // This file contains tests for the ProfileManager that require a heavyweight
  91 // InProcessBrowserTest.  These include tests involving profile deletion.
  92
  93 // TODO(jeremy): crbug.com/103355 - These tests should be enabled on all
  94 // platforms.
  95 class ProfileManagerBrowserTest : public InProcessBrowserTest {
  96  protected:
  97   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  98 #if defined(OS_CHROMEOS)
  99     command_line->AppendSwitch(
 100         chromeos::switches::kIgnoreUserProfileMappingForTests);
 101 #endif
 102   }
 103 };
 104
 105 #if defined(OS_MACOSX)
 106
 107 // Delete single profile and make sure a new one is created.
 108 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DeleteSingletonProfile) {
 109   ProfileManager* profile_manager = g_browser_process->profile_manager();
 110   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 111   ProfileRemovalObserver observer;
 112
 113   // We should start out with 1 profile.
 114   ASSERT_EQ(cache.GetNumberOfProfiles(), 1U);
 115
 116   // Delete singleton profile.
 117   base::FilePath singleton_profile_path = cache.GetPathOfProfileAtIndex(0);
 118   EXPECT_FALSE(singleton_profile_path.empty());
 119   profile_manager->ScheduleProfileForDeletion(singleton_profile_path,
 120                                               ProfileManager::CreateCallback());
 121
 122   // Spin things till profile is actually deleted.
 123   content::RunAllPendingInMessageLoop();
 124
 125   // Make sure a new profile was created automatically.
 126   EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
 127   base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
 128   EXPECT_NE(new_profile_path, singleton_profile_path);
 129
 130   // Make sure that last used profile preference is set correctly.
 131   Profile* last_used = ProfileManager::GetLastUsedProfile();
 132   EXPECT_EQ(new_profile_path, last_used->GetPath());
 133
 134   // Make sure the last used profile was set correctly before the notification
 135   // was sent.
 136   std::string last_used_profile_name =
 137       last_used->GetPath().BaseName().MaybeAsASCII();
 138   EXPECT_EQ(last_used_profile_name, observer.last_used_profile_name());
 139 }
 140
 141 // Delete all profiles in a multi profile setup and make sure a new one is
 142 // created.
 143 // Crashes/CHECKs. See crbug.com/104851
 144 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DISABLED_DeleteAllProfiles) {
 145   ProfileManager* profile_manager = g_browser_process->profile_manager();
 146   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 147
 148   // Create an additional profile.
 149   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 150   profile_manager->CreateProfileAsync(new_path,
 151                                       base::Bind(&OnUnblockOnProfileCreation),
 152                                       base::string16(), base::string16(),
 153                                       std::string());
 154
 155   // Spin to allow profile creation to take place, loop is terminated
 156   // by OnUnblockOnProfileCreation when the profile is created.
 157   content::RunMessageLoop();
 158
 159   ASSERT_EQ(cache.GetNumberOfProfiles(), 2U);
 160
 161   // Delete all profiles.
 162   base::FilePath profile_path1 = cache.GetPathOfProfileAtIndex(0);
 163   base::FilePath profile_path2 = cache.GetPathOfProfileAtIndex(1);
 164   EXPECT_FALSE(profile_path1.empty());
 165   EXPECT_FALSE(profile_path2.empty());
 166   profile_manager->ScheduleProfileForDeletion(profile_path1,
 167                                               ProfileManager::CreateCallback());
 168   profile_manager->ScheduleProfileForDeletion(profile_path2,
 169                                               ProfileManager::CreateCallback());
 170
 171   // Spin things so deletion can take place.
 172   content::RunAllPendingInMessageLoop();
 173
 174   // Make sure a new profile was created automatically.
 175   EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
 176   base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
 177   EXPECT_NE(new_profile_path, profile_path1);
 178   EXPECT_NE(new_profile_path, profile_path2);
 179
 180   // Make sure that last used profile preference is set correctly.
 181   Profile* last_used = ProfileManager::GetLastUsedProfile();
 182   EXPECT_EQ(new_profile_path, last_used->GetPath());
 183 }
 184 #endif  // OS_MACOSX
 185
 186 #if defined(OS_CHROMEOS)
 187
 188 class ProfileManagerCrOSBrowserTest : public ProfileManagerBrowserTest {
 189  protected:
 190   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 191     // Use a user hash other than the default chrome::kTestUserProfileDir
 192     // so that the prefix case is tested.
 193     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile,
 194                                     "test-user-hash");
 195   }
 196 };
 197
 198 IN_PROC_BROWSER_TEST_F(ProfileManagerCrOSBrowserTest, GetLastUsedProfile) {
 199   // Make sure that last used profile is correct.
 200   Profile* last_used_profile = ProfileManager::GetLastUsedProfile();
 201   EXPECT_TRUE(last_used_profile != NULL);
 202
 203   base::FilePath profile_path;
 204   PathService::Get(chrome::DIR_USER_DATA, &profile_path);
 205
 206   profile_path = profile_path.AppendASCII(
 207       std::string(chrome::kProfileDirPrefix) + "test-user-hash");
 208   EXPECT_EQ(profile_path.value(), last_used_profile->GetPath().value());
 209 }
 210
 211 #endif  // OS_CHROMEOS
 212
 213 // Times out (http://crbug.com/159002)
 214 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest,
 215                        DISABLED_CreateProfileWithCallback) {
 216   ProfileManager* profile_manager = g_browser_process->profile_manager();
 217
 218   ASSERT_EQ(profile_manager->GetNumberOfProfiles(), 1U);
 219   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
 220
 221   // Create a profile, make sure callback is invoked before any callbacks are
 222   // invoked (so they can do things like sign in the profile, etc).
 223   ProfileManager::CreateMultiProfileAsync(
 224       base::string16(), // name
 225       base::string16(), // icon url
 226       base::Bind(ProfileCreationComplete),
 227       std::string());
 228   // Wait for profile to finish loading.
 229   content::RunMessageLoop();
 230   EXPECT_EQ(profile_manager->GetNumberOfProfiles(), 2U);
 231   EXPECT_EQ(chrome::GetTotalBrowserCount(), 2U);
 232
 233   // Now close all browser windows.
 234   std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
 235   for (std::vector<Profile*>::const_iterator it = profiles.begin();
 236        it != profiles.end(); ++it) {
 237     BrowserList::CloseAllBrowsersWithProfile(*it);
 238   }
 239 }
 240
 241 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest,
 242                        SwitchToProfile) {
 243 #if defined(OS_WIN) && defined(USE_ASH)
 244   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 245   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 246     return;
 247 #endif
 248
 249   // If multiprofile mode is not enabled, you can't switch between profiles.
 250   if (!profiles::IsMultipleProfilesEnabled())
 251     return;
 252
 253   ProfileManager* profile_manager = g_browser_process->profile_manager();
 254   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 255   base::FilePath path_profile1 = cache.GetPathOfProfileAtIndex(0);
 256
 257   ASSERT_EQ(profile_manager->GetNumberOfProfiles(), 1U);
 258   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
 259
 260   // Create an additional profile.
 261   base::FilePath path_profile2 =
 262       profile_manager->GenerateNextProfileDirectoryPath();
 263   profile_manager->CreateProfileAsync(path_profile2,
 264                                       base::Bind(&OnUnblockOnProfileCreation),
 265                                       base::string16(), base::string16(),
 266                                       std::string());
 267
 268   // Spin to allow profile creation to take place, loop is terminated
 269   // by OnUnblockOnProfileCreation when the profile is created.
 270   content::RunMessageLoop();
 271
 272   chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
 273   BrowserList* browser_list = BrowserList::GetInstance(desktop_type);
 274   ASSERT_EQ(cache.GetNumberOfProfiles(), 2U);
 275   EXPECT_EQ(1U, browser_list->size());
 276
 277   // Open a browser window for the first profile.
 278   profiles::SwitchToProfile(path_profile1, desktop_type, false,
 279                             kOnProfileSwitchDoNothing,
 280                             ProfileMetrics::SWITCH_PROFILE_ICON);
 281   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
 282   EXPECT_EQ(1U, browser_list->size());
 283   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 284
 285   // Open a browser window for the second profile.
 286   profiles::SwitchToProfile(path_profile2, desktop_type, false,
 287                             kOnProfileSwitchDoNothing,
 288                             ProfileMetrics::SWITCH_PROFILE_ICON);
 289   EXPECT_EQ(chrome::GetTotalBrowserCount(), 2U);
 290   EXPECT_EQ(2U, browser_list->size());
 291   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 292
 293   // Switch to the first profile without opening a new window.
 294   profiles::SwitchToProfile(path_profile1, desktop_type, false,
 295                             kOnProfileSwitchDoNothing,
 296                             ProfileMetrics::SWITCH_PROFILE_ICON);
 297   EXPECT_EQ(chrome::GetTotalBrowserCount(), 2U);
 298   EXPECT_EQ(2U, browser_list->size());
 299
 300   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 301   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 302 }
 303
 304 // This test used to be flakily timing out on Windows: http://crbug.com/314905.
 305 // If this happens again please make it a MAYBE_ test and reopen that bug.
 306 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, EphemeralProfile) {
 307 #if defined(OS_WIN) && defined(USE_ASH)
 308   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 309   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 310     return;
 311 #endif
 312
 313   // If multiprofile mode is not enabled, you can't switch between profiles.
 314   if (!profiles::IsMultipleProfilesEnabled())
 315     return;
 316
 317   ProfileManager* profile_manager = g_browser_process->profile_manager();
 318   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 319   base::FilePath path_profile1 = cache.GetPathOfProfileAtIndex(0);
 320
 321   ASSERT_EQ(1U, profile_manager->GetNumberOfProfiles());
 322   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
 323
 324   // Create an ephemeral profile.
 325   base::FilePath path_profile2 =
 326       profile_manager->GenerateNextProfileDirectoryPath();
 327   profile_manager->CreateProfileAsync(
 328       path_profile2,
 329       base::Bind(&EphemeralProfileCreationComplete),
 330       base::string16(), base::string16(), std::string());
 331
 332   // Spin to allow profile creation to take place.
 333   content::RunMessageLoop();
 334
 335   chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
 336   BrowserList* browser_list = BrowserList::GetInstance(desktop_type);
 337   ASSERT_EQ(2U, cache.GetNumberOfProfiles());
 338   EXPECT_EQ(1U, browser_list->size());
 339
 340   // Open a browser window for the second profile.
 341   profiles::SwitchToProfile(path_profile2, desktop_type, false,
 342                             kOnProfileSwitchDoNothing,
 343                             ProfileMetrics::SWITCH_PROFILE_ICON);
 344   EXPECT_EQ(2U, chrome::GetTotalBrowserCount());
 345   EXPECT_EQ(2U, browser_list->size());
 346   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 347
 348   // Create a second window for the ephemeral profile.
 349   profiles::SwitchToProfile(path_profile2, desktop_type, true,
 350                             kOnProfileSwitchDoNothing,
 351                             ProfileMetrics::SWITCH_PROFILE_ICON);
 352   EXPECT_EQ(3U, chrome::GetTotalBrowserCount());
 353   EXPECT_EQ(3U, browser_list->size());
 354
 355   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 356   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 357   EXPECT_EQ(path_profile2, browser_list->get(2)->profile()->GetPath());
 358
 359   // Closing the first window of the ephemeral profile should not delete it.
 360   browser_list->get(2)->window()->Close();
 361   content::RunAllPendingInMessageLoop();
 362   EXPECT_EQ(2U, browser_list->size());
 363   ASSERT_EQ(2U, cache.GetNumberOfProfiles());
 364
 365   // The second should though.
 366   browser_list->get(1)->window()->Close();
 367   content::RunAllPendingInMessageLoop();
 368   EXPECT_EQ(1U, browser_list->size());
 369   ASSERT_EQ(1U, cache.GetNumberOfProfiles());
 370 }
 371