src/chrome/browser/chromeos/profiles/profile_helper.cc

   1 // Copyright (c) 2013 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/browser/chromeos/profiles/profile_helper.h"
   6
   7 #include "base/callback.h"
   8 #include "base/command_line.h"
   9 #include "chrome/browser/browser_process.h"
  10 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  11 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/profiles/profile_manager.h"
  14 #include "chrome/browser/profiles/profiles_state.h"
  15 #include "chrome/common/chrome_constants.h"
  16 #include "chrome/common/chrome_switches.h"
  17 #include "chromeos/chromeos_switches.h"
  18 #include "components/user_manager/user.h"
  19 #include "components/user_manager/user_manager.h"
  20 #include "content/public/browser/browser_thread.h"
  21
  22 namespace chromeos {
  23
  24 namespace {
  25
  26 // As defined in /chromeos/dbus/cryptohome_client.cc.
  27 static const char kUserIdHashSuffix[] = "-hash";
  28
  29 bool ShouldAddProfileDirPrefix(const std::string& user_id_hash) {
  30   // Do not add profile dir prefix for legacy profile dir and test
  31   // user profile. The reason of not adding prefix for test user profile
  32   // is to keep the promise that TestingProfile::kTestUserProfileDir and
  33   // chrome::kTestUserProfileDir are always in sync. Otherwise,
  34   // TestingProfile::kTestUserProfileDir needs to be dynamically calculated
  35   // based on whether multi profile is enabled or not.
  36   return user_id_hash != chrome::kLegacyProfileDir &&
  37       user_id_hash != chrome::kTestUserProfileDir;
  38 }
  39
  40 class UsernameHashMatcher {
  41  public:
  42   explicit UsernameHashMatcher(const std::string& h) : username_hash(h) {}
  43   bool operator()(const user_manager::User* user) const {
  44     return user->username_hash() == username_hash;
  45   }
  46
  47  private:
  48   const std::string& username_hash;
  49 };
  50
  51 }  // anonymous namespace
  52
  53 // static
  54 bool ProfileHelper::enable_profile_to_user_testing = false;
  55 bool ProfileHelper::always_return_primary_user_for_testing = false;
  56
  57 ////////////////////////////////////////////////////////////////////////////////
  58 // ProfileHelper, public
  59
  60 ProfileHelper::ProfileHelper()
  61     : signin_profile_clear_requested_(false) {
  62 }
  63
  64 ProfileHelper::~ProfileHelper() {
  65   // Checking whether UserManager is initialized covers case
  66   // when ScopedTestUserManager is used.
  67   if (user_manager::UserManager::IsInitialized())
  68     user_manager::UserManager::Get()->RemoveSessionStateObserver(this);
  69 }
  70
  71 // static
  72 ProfileHelper* ProfileHelper::Get() {
  73   return g_browser_process->platform_part()->profile_helper();
  74 }
  75
  76 // static
  77 Profile* ProfileHelper::GetProfileByUserIdHash(
  78     const std::string& user_id_hash) {
  79   ProfileManager* profile_manager = g_browser_process->profile_manager();
  80   return profile_manager->GetProfile(GetProfilePathByUserIdHash(user_id_hash));
  81 }
  82
  83 // static
  84 base::FilePath ProfileHelper::GetProfilePathByUserIdHash(
  85     const std::string& user_id_hash) {
  86   // Fails for KioskTest.InstallAndLaunchApp test - crbug.com/238985
  87   // Will probably fail for Guest session / restart after a crash -
  88   // crbug.com/238998
  89   // TODO(nkostylev): Remove this check once these bugs are fixed.
  90   DCHECK(!user_id_hash.empty());
  91   ProfileManager* profile_manager = g_browser_process->profile_manager();
  92   base::FilePath profile_path = profile_manager->user_data_dir();
  93
  94   return profile_path.Append(GetUserProfileDir(user_id_hash));
  95 }
  96
  97 // static
  98 base::FilePath ProfileHelper::GetSigninProfileDir() {
  99   ProfileManager* profile_manager = g_browser_process->profile_manager();
 100   base::FilePath user_data_dir = profile_manager->user_data_dir();
 101   return user_data_dir.AppendASCII(chrome::kInitialProfile);
 102 }
 103
 104 // static
 105 Profile* ProfileHelper::GetSigninProfile() {
 106   ProfileManager* profile_manager = g_browser_process->profile_manager();
 107   return profile_manager->GetProfile(GetSigninProfileDir())->
 108       GetOffTheRecordProfile();
 109 }
 110
 111 // static
 112 std::string ProfileHelper::GetUserIdHashFromProfile(Profile* profile) {
 113   if (!profile)
 114     return std::string();
 115
 116   std::string profile_dir = profile->GetPath().BaseName().value();
 117
 118   // Don't strip prefix if the dir is not supposed to be prefixed.
 119   if (!ShouldAddProfileDirPrefix(profile_dir))
 120     return profile_dir;
 121
 122   // Check that profile directory starts with the correct prefix.
 123   std::string prefix(chrome::kProfileDirPrefix);
 124   if (profile_dir.find(prefix) != 0) {
 125     // This happens when creating a TestingProfile in browser tests.
 126     return std::string();
 127   }
 128
 129   return profile_dir.substr(prefix.length(),
 130                             profile_dir.length() - prefix.length());
 131 }
 132
 133 // static
 134 base::FilePath ProfileHelper::GetUserProfileDir(
 135     const std::string& user_id_hash) {
 136   CHECK(!user_id_hash.empty());
 137   return ShouldAddProfileDirPrefix(user_id_hash)
 138              ? base::FilePath(chrome::kProfileDirPrefix + user_id_hash)
 139              : base::FilePath(user_id_hash);
 140 }
 141
 142 // static
 143 bool ProfileHelper::IsSigninProfile(Profile* profile) {
 144   return profile->GetPath().BaseName().value() == chrome::kInitialProfile;
 145 }
 146
 147 // static
 148 bool ProfileHelper::IsOwnerProfile(Profile* profile) {
 149   if (!profile)
 150     return false;
 151   user_manager::User* user = ProfileHelper::Get()->GetUserByProfile(profile);
 152   if (!user)
 153     return false;
 154
 155   return user->email() == user_manager::UserManager::Get()->GetOwnerEmail();
 156 }
 157
 158 // static
 159 bool ProfileHelper::IsPrimaryProfile(Profile* profile) {
 160   if (!profile)
 161     return false;
 162   user_manager::User* user = ProfileHelper::Get()->GetUserByProfile(profile);
 163   if (!user)
 164     return false;
 165   return user == user_manager::UserManager::Get()->GetPrimaryUser();
 166 }
 167
 168 void ProfileHelper::ProfileStartup(Profile* profile, bool process_startup) {
 169   // Initialize Chrome OS preferences like touch pad sensitivity. For the
 170   // preferences to work in the guest mode, the initialization has to be
 171   // done after |profile| is switched to the incognito profile (which
 172   // is actually GuestSessionProfile in the guest mode). See the
 173   // GetOffTheRecordProfile() call above.
 174   profile->InitChromeOSPreferences();
 175
 176   // Add observer so we can see when the first profile's session restore is
 177   // completed. After that, we won't need the default profile anymore.
 178   if (!IsSigninProfile(profile) &&
 179       user_manager::UserManager::Get()->IsLoggedInAsRegularUser() &&
 180       !user_manager::UserManager::Get()->IsLoggedInAsStub()) {
 181     chromeos::OAuth2LoginManager* login_manager =
 182         chromeos::OAuth2LoginManagerFactory::GetInstance()->GetForProfile(
 183             profile);
 184     if (login_manager)
 185       login_manager->AddObserver(this);
 186   }
 187 }
 188
 189 base::FilePath ProfileHelper::GetActiveUserProfileDir() {
 190   return ProfileHelper::GetUserProfileDir(active_user_id_hash_);
 191 }
 192
 193 void ProfileHelper::Initialize() {
 194   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 195 }
 196
 197 void ProfileHelper::ClearSigninProfile(const base::Closure& on_clear_callback) {
 198   on_clear_callbacks_.push_back(on_clear_callback);
 199   if (signin_profile_clear_requested_)
 200     return;
 201   ProfileManager* profile_manager = g_browser_process->profile_manager();
 202   // Check if signin profile was loaded.
 203   if (!profile_manager->GetProfileByPath(GetSigninProfileDir())) {
 204     OnBrowsingDataRemoverDone();
 205     return;
 206   }
 207   signin_profile_clear_requested_ = true;
 208   BrowsingDataRemover* remover =
 209       BrowsingDataRemover::CreateForUnboundedRange(GetSigninProfile());
 210   remover->AddObserver(this);
 211   remover->Remove(BrowsingDataRemover::REMOVE_SITE_DATA,
 212                   BrowsingDataHelper::ALL);
 213 }
 214
 215 Profile* ProfileHelper::GetProfileByUser(const user_manager::User* user) {
 216   // This map is non-empty only in tests.
 217   if (!user_to_profile_for_testing_.empty()) {
 218     std::map<const user_manager::User*, Profile*>::const_iterator it =
 219         user_to_profile_for_testing_.find(user);
 220     return it == user_to_profile_for_testing_.end() ? NULL : it->second;
 221   }
 222
 223   if (!user->is_profile_created())
 224     return NULL;
 225   Profile* profile =
 226       ProfileHelper::GetProfileByUserIdHash(user->username_hash());
 227
 228   // GetActiveUserProfile() or GetProfileByUserIdHash() returns a new instance
 229   // of ProfileImpl(), but actually its OffTheRecordProfile() should be used.
 230   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
 231     profile = profile->GetOffTheRecordProfile();
 232
 233   return profile;
 234 }
 235
 236 Profile* ProfileHelper::GetProfileByUserUnsafe(const user_manager::User* user) {
 237   // This map is non-empty only in tests.
 238   if (!user_to_profile_for_testing_.empty()) {
 239     std::map<const user_manager::User*, Profile*>::const_iterator it =
 240         user_to_profile_for_testing_.find(user);
 241     return it == user_to_profile_for_testing_.end() ? NULL : it->second;
 242   }
 243
 244   Profile* profile = NULL;
 245   if (user->is_profile_created()) {
 246     profile = ProfileHelper::GetProfileByUserIdHash(user->username_hash());
 247   } else {
 248     LOG(WARNING) << "ProfileHelper::GetProfileByUserUnsafe is called when "
 249                     "|user|'s profile is not created. It probably means that "
 250                     "something is wrong with a calling code. Please report in "
 251                     "http://crbug.com/361528 if you see this message. user_id: "
 252                  << user->email();
 253     profile = ProfileManager::GetActiveUserProfile();
 254   }
 255
 256   // GetActiveUserProfile() or GetProfileByUserIdHash() returns a new instance
 257   // of ProfileImpl(), but actually its OffTheRecordProfile() should be used.
 258   if (profile && user_manager::UserManager::Get()->IsLoggedInAsGuest())
 259     profile = profile->GetOffTheRecordProfile();
 260   return profile;
 261 }
 262
 263 user_manager::User* ProfileHelper::GetUserByProfile(Profile* profile) {
 264   // This map is non-empty only in tests.
 265   if (enable_profile_to_user_testing || !user_list_for_testing_.empty()) {
 266     if (always_return_primary_user_for_testing)
 267       return const_cast<user_manager::User*>(
 268           user_manager::UserManager::Get()->GetPrimaryUser());
 269
 270     const std::string& user_name = profile->GetProfileName();
 271     for (user_manager::UserList::const_iterator it =
 272              user_list_for_testing_.begin();
 273          it != user_list_for_testing_.end();
 274          ++it) {
 275       if ((*it)->email() == user_name)
 276         return *it;
 277     }
 278
 279     // In case of test setup we should always default to primary user.
 280     return const_cast<user_manager::User*>(
 281         user_manager::UserManager::Get()->GetPrimaryUser());
 282   }
 283
 284   DCHECK(!content::BrowserThread::IsThreadInitialized(
 285              content::BrowserThread::UI) ||
 286          content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 287   if (ProfileHelper::IsSigninProfile(profile))
 288     return NULL;
 289
 290   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 291
 292   // Special case for non-CrOS tests that do create several profiles
 293   // and don't really care about mapping to the real user.
 294   // Without multi-profiles on Chrome OS such tests always got active_user_.
 295   // Now these tests will specify special flag to continue working.
 296   // In future those tests can get a proper CrOS configuration i.e. register
 297   // and login several users if they want to work with an additional profile.
 298   if (CommandLine::ForCurrentProcess()->HasSwitch(
 299           switches::kIgnoreUserProfileMappingForTests)) {
 300     return user_manager->GetActiveUser();
 301   }
 302
 303   const std::string username_hash =
 304       ProfileHelper::GetUserIdHashFromProfile(profile);
 305   const user_manager::UserList& users = user_manager->GetUsers();
 306   const user_manager::UserList::const_iterator pos = std::find_if(
 307       users.begin(), users.end(), UsernameHashMatcher(username_hash));
 308   if (pos != users.end())
 309     return *pos;
 310
 311   // Many tests do not have their users registered with UserManager and
 312   // runs here. If |active_user_| matches |profile|, returns it.
 313   const user_manager::User* active_user = user_manager->GetActiveUser();
 314   return active_user &&
 315                  ProfileHelper::GetProfilePathByUserIdHash(
 316                      active_user->username_hash()) == profile->GetPath()
 317              ? const_cast<user_manager::User*>(active_user)
 318              : NULL;
 319 }
 320
 321 ////////////////////////////////////////////////////////////////////////////////
 322 // ProfileHelper, BrowsingDataRemover::Observer implementation:
 323
 324 void ProfileHelper::OnBrowsingDataRemoverDone() {
 325   signin_profile_clear_requested_ = false;
 326   for (size_t i = 0; i < on_clear_callbacks_.size(); ++i) {
 327     if (!on_clear_callbacks_[i].is_null())
 328       on_clear_callbacks_[i].Run();
 329   }
 330   on_clear_callbacks_.clear();
 331 }
 332
 333 ////////////////////////////////////////////////////////////////////////////////
 334 // ProfileHelper, OAuth2LoginManager::Observer implementation:
 335
 336 void ProfileHelper::OnSessionRestoreStateChanged(
 337     Profile* user_profile,
 338     OAuth2LoginManager::SessionRestoreState state) {
 339   if (state == OAuth2LoginManager::SESSION_RESTORE_DONE ||
 340       state == OAuth2LoginManager::SESSION_RESTORE_FAILED ||
 341       state == OAuth2LoginManager::SESSION_RESTORE_CONNECTION_FAILED) {
 342     chromeos::OAuth2LoginManager* login_manager =
 343         chromeos::OAuth2LoginManagerFactory::GetInstance()->
 344             GetForProfile(user_profile);
 345     login_manager->RemoveObserver(this);
 346     ClearSigninProfile(base::Closure());
 347   }
 348 }
 349
 350 ////////////////////////////////////////////////////////////////////////////////
 351 // ProfileHelper, UserManager::UserSessionStateObserver implementation:
 352
 353 void ProfileHelper::ActiveUserHashChanged(const std::string& hash) {
 354   active_user_id_hash_ = hash;
 355 }
 356
 357 void ProfileHelper::SetProfileToUserMappingForTesting(
 358     user_manager::User* user) {
 359   user_list_for_testing_.push_back(user);
 360 }
 361
 362 // static
 363 void ProfileHelper::SetProfileToUserForTestingEnabled(bool enabled) {
 364   enable_profile_to_user_testing = enabled;
 365 }
 366
 367 // static
 368 void ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(bool value) {
 369   always_return_primary_user_for_testing = true;
 370   ProfileHelper::SetProfileToUserForTestingEnabled(true);
 371 }
 372
 373 void ProfileHelper::SetUserToProfileMappingForTesting(
 374     const user_manager::User* user,
 375     Profile* profile) {
 376   user_to_profile_for_testing_[user] = profile;
 377 }
 378
 379 // static
 380 std::string ProfileHelper::GetUserIdHashByUserIdForTesting(
 381     const std::string& user_id) {
 382   return user_id + kUserIdHashSuffix;
 383 }
 384
 385 }  // namespace chromeos