chrome/test/base/testing_profile_manager.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 "chrome/test/base/testing_profile_manager.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/prefs/pref_service_syncable.h"
  10 #include "chrome/browser/profiles/profile_info_cache.h"
  11 #include "chrome/browser/profiles/profile_manager.h"
  12 #include "chrome/common/chrome_constants.h"
  13 #include "chrome/test/base/testing_browser_process.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 #if defined(OS_CHROMEOS)
  17 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  18 #endif
  19
  20 const char kGuestProfileName[] = "Guest";
  21 const char kSystemProfileName[] = "System";
  22
  23 namespace testing {
  24
  25 class ProfileManager : public ::ProfileManagerWithoutInit {
  26  public:
  27   explicit ProfileManager(const base::FilePath& user_data_dir)
  28       : ::ProfileManagerWithoutInit(user_data_dir) {}
  29
  30  protected:
  31   Profile* CreateProfileHelper(const base::FilePath& file_path) override {
  32     return new TestingProfile(file_path);
  33   }
  34 };
  35
  36 }  // namespace testing
  37
  38 TestingProfileManager::TestingProfileManager(TestingBrowserProcess* process)
  39     : called_set_up_(false),
  40       browser_process_(process),
  41       local_state_(process),
  42       profile_manager_(NULL) {
  43 }
  44
  45 TestingProfileManager::~TestingProfileManager() {
  46   // Destroying this class also destroys the LocalState, so make sure the
  47   // associated ProfileManager is also destroyed.
  48   browser_process_->SetProfileManager(NULL);
  49 }
  50
  51 bool TestingProfileManager::SetUp() {
  52   SetUpInternal();
  53   return called_set_up_;
  54 }
  55
  56 TestingProfile* TestingProfileManager::CreateTestingProfile(
  57     const std::string& profile_name,
  58     scoped_ptr<PrefServiceSyncable> prefs,
  59     const base::string16& user_name,
  60     int avatar_id,
  61     const std::string& supervised_user_id,
  62     const TestingProfile::TestingFactories& factories) {
  63   DCHECK(called_set_up_);
  64
  65   // Create a path for the profile based on the name.
  66   base::FilePath profile_path(profiles_dir_.path());
  67 #if defined(OS_CHROMEOS)
  68   if (profile_name != chrome::kInitialProfile) {
  69     profile_path =
  70         profile_path.Append(chromeos::ProfileHelper::Get()->GetUserProfileDir(
  71             chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
  72                 profile_name)));
  73   } else {
  74     profile_path = profile_path.AppendASCII(profile_name);
  75   }
  76 #else
  77   profile_path = profile_path.AppendASCII(profile_name);
  78 #endif
  79
  80   // Create the profile and register it.
  81   TestingProfile::Builder builder;
  82   builder.SetPath(profile_path);
  83   builder.SetPrefService(prefs.Pass());
  84   builder.SetSupervisedUserId(supervised_user_id);
  85
  86   for (TestingProfile::TestingFactories::const_iterator it = factories.begin();
  87        it != factories.end(); ++it) {
  88     builder.AddTestingFactory(it->first, it->second);
  89   }
  90
  91   TestingProfile* profile = builder.Build().release();
  92   profile->set_profile_name(profile_name);
  93   profile_manager_->AddProfile(profile);  // Takes ownership.
  94
  95   // Update the user metadata.
  96   ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
  97   size_t index = cache.GetIndexOfProfileWithPath(profile_path);
  98   cache.SetAvatarIconOfProfileAtIndex(index, avatar_id);
  99   cache.SetSupervisedUserIdOfProfileAtIndex(index, supervised_user_id);
 100   // SetNameOfProfileAtIndex may reshuffle the list of profiles, so we do it
 101   // last.
 102   cache.SetNameOfProfileAtIndex(index, user_name);
 103
 104   testing_profiles_.insert(std::make_pair(profile_name, profile));
 105
 106   return profile;
 107 }
 108
 109 TestingProfile* TestingProfileManager::CreateTestingProfile(
 110     const std::string& name) {
 111   DCHECK(called_set_up_);
 112   return CreateTestingProfile(name, scoped_ptr<PrefServiceSyncable>(),
 113                               base::UTF8ToUTF16(name), 0, std::string(),
 114                               TestingProfile::TestingFactories());
 115 }
 116
 117 TestingProfile* TestingProfileManager::CreateGuestProfile() {
 118   DCHECK(called_set_up_);
 119
 120   // Create the profile and register it.
 121   TestingProfile::Builder builder;
 122   builder.SetGuestSession();
 123   builder.SetPath(ProfileManager::GetGuestProfilePath());
 124
 125   // Add the guest profile to the profile manager, but not to the info cache.
 126   TestingProfile* profile = builder.Build().release();
 127   profile->set_profile_name(kGuestProfileName);
 128
 129   // Set up a profile with an off the record profile.
 130   TestingProfile::Builder().BuildIncognito(profile);
 131
 132   profile_manager_->AddProfile(profile);  // Takes ownership.
 133   profile_manager_->SetGuestProfilePrefs(profile);
 134
 135   testing_profiles_.insert(std::make_pair(kGuestProfileName, profile));
 136
 137   return profile;
 138 }
 139
 140 TestingProfile* TestingProfileManager::CreateSystemProfile() {
 141   DCHECK(called_set_up_);
 142
 143   // Create the profile and register it.
 144   TestingProfile::Builder builder;
 145   builder.SetPath(ProfileManager::GetSystemProfilePath());
 146
 147   // Add the system profile to the profile manager, but not to the info cache.
 148   TestingProfile* profile = builder.Build().release();
 149   profile->set_profile_name(kSystemProfileName);
 150
 151   profile_manager_->AddProfile(profile);  // Takes ownership.
 152
 153   testing_profiles_.insert(std::make_pair(kSystemProfileName, profile));
 154
 155   return profile;
 156 }
 157
 158 void TestingProfileManager::DeleteTestingProfile(const std::string& name) {
 159   DCHECK(called_set_up_);
 160
 161   TestingProfilesMap::iterator it = testing_profiles_.find(name);
 162   DCHECK(it != testing_profiles_.end());
 163
 164   TestingProfile* profile = it->second;
 165
 166   ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
 167   cache.DeleteProfileFromCache(profile->GetPath());
 168
 169   profile_manager_->profiles_info_.erase(profile->GetPath());
 170
 171   testing_profiles_.erase(it);
 172 }
 173
 174 void TestingProfileManager::DeleteAllTestingProfiles() {
 175   for (TestingProfilesMap::iterator it = testing_profiles_.begin();
 176        it != testing_profiles_.end(); ++it) {
 177     TestingProfile* profile = it->second;
 178     ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
 179     cache.DeleteProfileFromCache(profile->GetPath());
 180   }
 181   testing_profiles_.clear();
 182 }
 183
 184
 185 void TestingProfileManager::DeleteGuestProfile() {
 186   DCHECK(called_set_up_);
 187
 188   TestingProfilesMap::iterator it = testing_profiles_.find(kGuestProfileName);
 189   DCHECK(it != testing_profiles_.end());
 190
 191   profile_manager_->profiles_info_.erase(ProfileManager::GetGuestProfilePath());
 192 }
 193
 194 void TestingProfileManager::DeleteSystemProfile() {
 195   DCHECK(called_set_up_);
 196
 197   TestingProfilesMap::iterator it = testing_profiles_.find(kSystemProfileName);
 198   DCHECK(it != testing_profiles_.end());
 199
 200   profile_manager_->profiles_info_.erase(
 201       ProfileManager::GetSystemProfilePath());
 202 }
 203
 204 void TestingProfileManager::DeleteProfileInfoCache() {
 205   profile_manager_->profile_info_cache_.reset(NULL);
 206 }
 207
 208 void TestingProfileManager::SetLoggedIn(bool logged_in) {
 209   profile_manager_->logged_in_ = logged_in;
 210 }
 211
 212 void TestingProfileManager::UpdateLastUser(Profile* last_active) {
 213 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 214   profile_manager_->UpdateLastUser(last_active);
 215 #endif
 216 }
 217
 218 const base::FilePath& TestingProfileManager::profiles_dir() {
 219   DCHECK(called_set_up_);
 220   return profiles_dir_.path();
 221 }
 222
 223 ProfileManager* TestingProfileManager::profile_manager() {
 224   DCHECK(called_set_up_);
 225   return profile_manager_;
 226 }
 227
 228 ProfileInfoCache* TestingProfileManager::profile_info_cache() {
 229   DCHECK(called_set_up_);
 230   return &profile_manager_->GetProfileInfoCache();
 231 }
 232
 233 void TestingProfileManager::SetUpInternal() {
 234   ASSERT_FALSE(browser_process_->profile_manager())
 235       << "ProfileManager already exists";
 236
 237   // Set up the directory for profiles.
 238   ASSERT_TRUE(profiles_dir_.CreateUniqueTempDir());
 239
 240   profile_manager_ = new testing::ProfileManager(profiles_dir_.path());
 241   browser_process_->SetProfileManager(profile_manager_);  // Takes ownership.
 242
 243   called_set_up_ = true;
 244 }