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/chrome_switches.h"
  19 #include "chrome/common/pref_names.h"
  20 #include "chrome/test/base/in_process_browser_test.h"
  21 #include "chrome/test/base/test_switches.h"
  22 #include "chrome/test/base/testing_browser_process.h"
  23 #include "chrome/test/base/ui_test_utils.h"
  24
  25 #if defined(OS_CHROMEOS)
  26 #include "base/path_service.h"
  27 #include "chrome/common/chrome_constants.h"
  28 #include "chrome/common/chrome_paths.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 };
  97
  98 #if defined(OS_MACOSX)
  99
 100 // Delete single profile and make sure a new one is created.
 101 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DeleteSingletonProfile) {
 102   ProfileManager* profile_manager = g_browser_process->profile_manager();
 103   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 104   ProfileRemovalObserver observer;
 105
 106   // We should start out with 1 profile.
 107   ASSERT_EQ(cache.GetNumberOfProfiles(), 1U);
 108
 109   // Delete singleton profile.
 110   base::FilePath singleton_profile_path = cache.GetPathOfProfileAtIndex(0);
 111   EXPECT_FALSE(singleton_profile_path.empty());
 112   profile_manager->ScheduleProfileForDeletion(singleton_profile_path,
 113                                               ProfileManager::CreateCallback());
 114
 115   // Spin things till profile is actually deleted.
 116   content::RunAllPendingInMessageLoop();
 117
 118   // Make sure a new profile was created automatically.
 119   EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
 120   base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
 121   EXPECT_NE(new_profile_path, singleton_profile_path);
 122
 123   // Make sure that last used profile preference is set correctly.
 124   Profile* last_used = ProfileManager::GetLastUsedProfile();
 125   EXPECT_EQ(new_profile_path, last_used->GetPath());
 126
 127   // Make sure the last used profile was set correctly before the notification
 128   // was sent.
 129   std::string last_used_profile_name =
 130       last_used->GetPath().BaseName().MaybeAsASCII();
 131   EXPECT_EQ(last_used_profile_name, observer.last_used_profile_name());
 132 }
 133
 134 // Delete all profiles in a multi profile setup and make sure a new one is
 135 // created.
 136 // Crashes/CHECKs. See crbug.com/104851
 137 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DISABLED_DeleteAllProfiles) {
 138   ProfileManager* profile_manager = g_browser_process->profile_manager();
 139   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 140
 141   // Create an additional profile.
 142   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 143   profile_manager->CreateProfileAsync(new_path,
 144                                       base::Bind(&OnUnblockOnProfileCreation),
 145                                       base::string16(), base::string16(),
 146                                       std::string());
 147
 148   // Spin to allow profile creation to take place, loop is terminated
 149   // by OnUnblockOnProfileCreation when the profile is created.
 150   content::RunMessageLoop();
 151
 152   ASSERT_EQ(cache.GetNumberOfProfiles(), 2U);
 153
 154   // Delete all profiles.
 155   base::FilePath profile_path1 = cache.GetPathOfProfileAtIndex(0);
 156   base::FilePath profile_path2 = cache.GetPathOfProfileAtIndex(1);
 157   EXPECT_FALSE(profile_path1.empty());
 158   EXPECT_FALSE(profile_path2.empty());
 159   profile_manager->ScheduleProfileForDeletion(profile_path1,
 160                                               ProfileManager::CreateCallback());
 161   profile_manager->ScheduleProfileForDeletion(profile_path2,
 162                                               ProfileManager::CreateCallback());
 163
 164   // Spin things so deletion can take place.
 165   content::RunAllPendingInMessageLoop();
 166
 167   // Make sure a new profile was created automatically.
 168   EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
 169   base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
 170   EXPECT_NE(new_profile_path, profile_path1);
 171   EXPECT_NE(new_profile_path, profile_path2);
 172
 173   // Make sure that last used profile preference is set correctly.
 174   Profile* last_used = ProfileManager::GetLastUsedProfile();
 175   EXPECT_EQ(new_profile_path, last_used->GetPath());
 176 }
 177 #endif  // OS_MACOSX
 178
 179 #if defined(OS_CHROMEOS)
 180
 181 class ProfileManagerCrOSBrowserTest : public ProfileManagerBrowserTest,
 182                                       public testing::WithParamInterface<bool> {
 183  protected:
 184   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 185     if (GetParam())
 186       command_line->AppendSwitch(::switches::kMultiProfiles);
 187   }
 188 };
 189
 190 IN_PROC_BROWSER_TEST_P(ProfileManagerCrOSBrowserTest, GetLastUsedProfile) {
 191   // Make sure that last used profile is correct.
 192   Profile* last_used_profile = ProfileManager::GetLastUsedProfile();
 193   EXPECT_TRUE(last_used_profile != NULL);
 194
 195   base::FilePath profile_path;
 196   PathService::Get(chrome::DIR_USER_DATA, &profile_path);
 197
 198   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 199   if (command_line.HasSwitch(switches::kMultiProfiles)) {
 200     profile_path = profile_path.Append(base::FilePath(
 201         std::string(chrome::kProfileDirPrefix) + chrome::kTestUserProfileDir));
 202   } else {
 203     profile_path = profile_path.Append(
 204         base::FilePath(chrome::kTestUserProfileDir));
 205   }
 206   EXPECT_EQ(profile_path.value(), last_used_profile->GetPath().value());
 207 }
 208
 209 INSTANTIATE_TEST_CASE_P(ProfileManagerCrOSBrowserTestInstantiation,
 210                         ProfileManagerCrOSBrowserTest,
 211                         testing::Bool());
 212
 213 #endif  // OS_CHROMEOS
 214
 215 // Times out (http://crbug.com/159002)
 216 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest,
 217                        DISABLED_CreateProfileWithCallback) {
 218   ProfileManager* profile_manager = g_browser_process->profile_manager();
 219
 220   ASSERT_EQ(profile_manager->GetNumberOfProfiles(), 1U);
 221   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
 222
 223   // Create a profile, make sure callback is invoked before any callbacks are
 224   // invoked (so they can do things like sign in the profile, etc).
 225   ProfileManager::CreateMultiProfileAsync(
 226       base::string16(), // name
 227       base::string16(), // icon url
 228       base::Bind(ProfileCreationComplete),
 229       std::string());
 230   // Wait for profile to finish loading.
 231   content::RunMessageLoop();
 232   EXPECT_EQ(profile_manager->GetNumberOfProfiles(), 2U);
 233   EXPECT_EQ(chrome::GetTotalBrowserCount(), 2U);
 234
 235   // Now close all browser windows.
 236   std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
 237   for (std::vector<Profile*>::const_iterator it = profiles.begin();
 238        it != profiles.end(); ++it) {
 239     BrowserList::CloseAllBrowsersWithProfile(*it);
 240   }
 241 }
 242
 243 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest,
 244                        SwitchToProfile) {
 245 #if defined(OS_WIN) && defined(USE_ASH)
 246   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 247   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 248     return;
 249 #endif
 250
 251   // If multiprofile mode is not enabled, you can't switch between profiles.
 252   if (!profiles::IsMultipleProfilesEnabled())
 253     return;
 254
 255   ProfileManager* profile_manager = g_browser_process->profile_manager();
 256   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 257   base::FilePath path_profile1 = cache.GetPathOfProfileAtIndex(0);
 258
 259   ASSERT_EQ(profile_manager->GetNumberOfProfiles(), 1U);
 260   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
 261
 262   // Create an additional profile.
 263   base::FilePath path_profile2 =
 264       profile_manager->GenerateNextProfileDirectoryPath();
 265   profile_manager->CreateProfileAsync(path_profile2,
 266                                       base::Bind(&OnUnblockOnProfileCreation),
 267                                       base::string16(), base::string16(),
 268                                       std::string());
 269
 270   // Spin to allow profile creation to take place, loop is terminated
 271   // by OnUnblockOnProfileCreation when the profile is created.
 272   content::RunMessageLoop();
 273
 274   chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
 275   BrowserList* browser_list = BrowserList::GetInstance(desktop_type);
 276   ASSERT_EQ(cache.GetNumberOfProfiles(), 2U);
 277   EXPECT_EQ(1U, browser_list->size());
 278
 279   // Open a browser window for the first profile.
 280   profiles::SwitchToProfile(path_profile1, desktop_type, false,
 281                             kOnProfileSwitchDoNothing);
 282   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
 283   EXPECT_EQ(1U, browser_list->size());
 284   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 285
 286   // Open a browser window for the second profile.
 287   profiles::SwitchToProfile(path_profile2, desktop_type, false,
 288                             kOnProfileSwitchDoNothing);
 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   EXPECT_EQ(chrome::GetTotalBrowserCount(), 2U);
 297   EXPECT_EQ(2U, browser_list->size());
 298
 299   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 300   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 301 }
 302
 303 // This test used to be flakily timing out on Windows: http://crbug.com/314905.
 304 // If this happens again please make it a MAYBE_ test and reopen that bug.
 305 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, EphemeralProfile) {
 306 #if defined(OS_WIN) && defined(USE_ASH)
 307   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 308   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 309     return;
 310 #endif
 311
 312   // If multiprofile mode is not enabled, you can't switch between profiles.
 313   if (!profiles::IsMultipleProfilesEnabled())
 314     return;
 315
 316   ProfileManager* profile_manager = g_browser_process->profile_manager();
 317   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 318   base::FilePath path_profile1 = cache.GetPathOfProfileAtIndex(0);
 319
 320   ASSERT_EQ(1U, profile_manager->GetNumberOfProfiles());
 321   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
 322
 323   // Create an ephemeral profile.
 324   base::FilePath path_profile2 =
 325       profile_manager->GenerateNextProfileDirectoryPath();
 326   profile_manager->CreateProfileAsync(
 327       path_profile2,
 328       base::Bind(&EphemeralProfileCreationComplete),
 329       base::string16(), base::string16(), std::string());
 330
 331   // Spin to allow profile creation to take place.
 332   content::RunMessageLoop();
 333
 334   chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
 335   BrowserList* browser_list = BrowserList::GetInstance(desktop_type);
 336   ASSERT_EQ(2U, cache.GetNumberOfProfiles());
 337   EXPECT_EQ(1U, browser_list->size());
 338
 339   // Open a browser window for the second profile.
 340   profiles::SwitchToProfile(path_profile2, desktop_type, false,
 341                             kOnProfileSwitchDoNothing);
 342   EXPECT_EQ(2U, chrome::GetTotalBrowserCount());
 343   EXPECT_EQ(2U, browser_list->size());
 344   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 345
 346   // Create a second window for the ephemeral profile.
 347   profiles::SwitchToProfile(path_profile2, desktop_type, true,
 348                             kOnProfileSwitchDoNothing);
 349   EXPECT_EQ(3U, chrome::GetTotalBrowserCount());
 350   EXPECT_EQ(3U, browser_list->size());
 351
 352   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 353   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 354   EXPECT_EQ(path_profile2, browser_list->get(2)->profile()->GetPath());
 355
 356   // Closing the first window of the ephemeral profile should not delete it.
 357   browser_list->get(2)->window()->Close();
 358   content::RunAllPendingInMessageLoop();
 359   EXPECT_EQ(2U, browser_list->size());
 360   ASSERT_EQ(2U, cache.GetNumberOfProfiles());
 361
 362   // The second should though.
 363   browser_list->get(1)->window()->Close();
 364   content::RunAllPendingInMessageLoop();
 365   EXPECT_EQ(1U, browser_list->size());
 366   ASSERT_EQ(1U, cache.GetNumberOfProfiles());
 367 }