ChromeOS user_manager: move all KnownUser code to separate file.

components/user_manager/user_manager_base.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/user_manager/user_manager_base.h"
 
 #include <cstddef>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/login/user_names.h"
 #include "components/session_manager/core/session_manager.h"
+#include "components/user_manager/known_user.h"
 #include "components/user_manager/remove_user_delegate.h"
 #include "components/user_manager/user_type.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace user_manager {
 namespace {
 
 // A vector pref of the the regular users known on this device, arranged in LRU
 // order.
@@ skipping 21 matching lines @@
 // A string pref containing the ID of the last user who logged in if it was
 // a user with gaia account (regular) or an empty string if it was another type
 // of user (guest, kiosk, public account, etc.).
 const char kLastLoggedInGaiaUser[] = "LastLoggedInRegularUser";
 
 // A string pref containing the ID of the last active user.
 // In case of browser crash, this pref will be used to set active user after
 // session restore.
 const char kLastActiveUser[] = "LastActiveUser";
 
-// A vector pref of preferences of known users. All new preferences should be
-// placed in this list.
-const char kKnownUsers[] = "KnownUsers";
-
-// Known user preferences keys (stored in Local State).
-
-// Key of canonical e-mail value.
-const char kCanonicalEmail[] = "email";
-
-// Key of obfuscated GAIA id value.
-const char kGAIAIdKey[] = "gaia_id";
-
-// Key of whether this user ID refers to a SAML user.
-const char kUsingSAMLKey[] = "using_saml";
-
-// Key of Device Id.
-const char kDeviceId[] = "device_id";
-
-// Key of GAPS cookie.
-const char kGAPSCookie[] = "gaps_cookie";
-
-// Key of the reason for re-auth.
-const char kReauthReasonKey[] = "reauth_reason";
-
 // Upper bound for a histogram metric reporting the amount of time between
 // one regular user logging out and a different regular user logging in.
 const int kLogoutToLoginDelayMaxSec = 1800;
 
 // Callback that is called after user removal is complete.
 void OnRemoveUserComplete(const AccountId& account_id,
                           bool success,
                           cryptohome::MountError return_code) {
   // Log the error, but there's not much we can do.
   if (!success) {
     LOG(ERROR) << "Removal of cryptohome for " << account_id.Serialize()
                << " failed, return code: " << return_code;
   }
 }
 
 // Runs on SequencedWorkerPool thread. Passes resolved locale to UI thread.
 void ResolveLocale(const std::string& raw_locale,
                    std::string* resolved_locale) {
   ignore_result(l10n_util::CheckAndResolveLocale(raw_locale, resolved_locale));
 }
 
-// Checks if values in |dict| correspond with |account_id| identity.
-bool UserMatches(const AccountId& account_id,
-                 const base::DictionaryValue& dict) {
-  std::string value;
-
-  // TODO(alemate): update code once user id is really a struct.
-  bool has_gaia_id = dict.GetString(kGAIAIdKey, &value);
-  if (has_gaia_id && account_id.GetGaiaId() == value)
-    return true;
-
-  bool has_email = dict.GetString(kCanonicalEmail, &value);
-  if (has_email && account_id.GetUserEmail() == value)
-    return true;
-
-  return false;
-}
-
-// Fills relevant |dict| values based on |account_id|.
-void UpdateIdentity(const AccountId& account_id, base::DictionaryValue& dict) {
-  dict.SetString(kCanonicalEmail, account_id.GetUserEmail());
-}
-
 }  // namespace
 
 // static
 void UserManagerBase::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kRegularUsers);
-  registry->RegisterListPref(kKnownUsers);
   registry->RegisterStringPref(kLastLoggedInGaiaUser, std::string());
   registry->RegisterDictionaryPref(kUserDisplayName);
   registry->RegisterDictionaryPref(kUserGivenName);
   registry->RegisterDictionaryPref(kUserDisplayEmail);
   registry->RegisterDictionaryPref(kUserOAuthTokenStatus);
   registry->RegisterDictionaryPref(kUserForceOnlineSignin);
   registry->RegisterDictionaryPref(kUserType);
   registry->RegisterStringPref(kLastActiveUser, std::string());
+
+  known_user::RegisterPrefs(registry);
 }
 
 UserManagerBase::UserManagerBase(
     scoped_refptr<base::TaskRunner> task_runner,
     scoped_refptr<base::TaskRunner> blocking_task_runner)
     : task_runner_(task_runner),
       blocking_task_runner_(blocking_task_runner),
       weak_factory_(this) {
   UpdateLoginState();
 }
@@ skipping 368 matching lines @@
   if (IsUserNonCryptohomeDataEphemeral(account_id))
     return;
 
   DictionaryPrefUpdate user_type_update(GetLocalState(), kUserType);
   user_type_update->SetWithoutPathExpansion(
       account_id.GetUserEmail(),
       new base::FundamentalValue(static_cast<int>(user_type)));
   GetLocalState()->CommitPendingWrite();
 }
 
-void UserManagerBase::UpdateUsingSAML(const AccountId& account_id,
-                                      const bool using_saml) {
-  SetKnownUserBooleanPref(account_id, kUsingSAMLKey, using_saml);
-}
-
-bool UserManagerBase::FindUsingSAML(const AccountId& account_id) {
-  bool using_saml;
-  if (GetKnownUserBooleanPref(account_id, kUsingSAMLKey, &using_saml))
-    return using_saml;
-  return false;
-}
-
-void UserManagerBase::UpdateReauthReason(const AccountId& account_id,
-                                         const int reauth_reason) {
-  SetKnownUserIntegerPref(account_id, kReauthReasonKey, reauth_reason);
-}
-
-bool UserManagerBase::FindReauthReason(const AccountId& account_id,
-                                       int* out_value) {
-  return GetKnownUserIntegerPref(account_id, kReauthReasonKey, out_value);
-}
-
 void UserManagerBase::UpdateUserAccountData(
     const AccountId& account_id,
     const UserAccountData& account_data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   SaveUserDisplayName(account_id, account_data.display_name());
 
   if (User* user = FindUserAndModify(account_id)) {
     base::string16 given_name = account_data.given_name();
     user->set_given_name(given_name);
@@ skipping 13 matching lines @@
                                     std::set<AccountId>* users_set) {
   users_vector->clear();
   users_set->clear();
   for (size_t i = 0; i < users_list.GetSize(); ++i) {
     std::string email;
     if (!users_list.GetString(i, &email) || email.empty()) {
       LOG(ERROR) << "Corrupt entry in user list at index " << i << ".";
       continue;
     }
 
-    const AccountId account_id = GetKnownUserAccountId(email, std::string());
+    const AccountId account_id = known_user::GetAccountId(email, std::string());
 
     if (existing_users.find(account_id) != existing_users.end() ||
         !users_set->insert(account_id).second) {
       LOG(ERROR) << "Duplicate user: " << email;
       continue;
     }
     users_vector->push_back(account_id);
   }
 }
 
@@ skipping 237 matching lines @@
       int user_type;
       if (prefs_user_types->GetIntegerWithoutPathExpansion(it->GetUserEmail(),
                                                            &user_type) &&
           user_type == USER_TYPE_CHILD) {
         ChangeUserChildStatus(user, true /* is child */);
       }
     }
     const AccountId account_id = user->GetAccountId();
     user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     user->set_force_online_signin(LoadForceOnlineSignin(*it));
-    user->set_using_saml(FindUsingSAML(*it));
+    user->set_using_saml(known_user::IsUsingSAML(*it));
     users_.push_back(user);
 
     base::string16 display_name;
     if (prefs_display_names->GetStringWithoutPathExpansion(it->GetUserEmail(),
                                                            &display_name)) {
       user->set_display_name(display_name);
     }
 
     base::string16 given_name;
     if (prefs_given_names->GetStringWithoutPathExpansion(it->GetUserEmail(),
@@ skipping 140 matching lines @@
       account_id.GetUserEmail(), nullptr);
 
   DictionaryPrefUpdate prefs_oauth_update(prefs, kUserOAuthTokenStatus);
   prefs_oauth_update->RemoveWithoutPathExpansion(account_id.GetUserEmail(),
                                                  nullptr);
 
   DictionaryPrefUpdate prefs_force_online_update(prefs, kUserForceOnlineSignin);
   prefs_force_online_update->RemoveWithoutPathExpansion(
       account_id.GetUserEmail(), nullptr);
 
-  RemoveKnownUserPrefs(account_id);
+  known_user::RemovePrefs(account_id);
 
   const AccountId last_active_user =
       AccountId::FromUserEmail(GetLocalState()->GetString(kLastActiveUser));
   if (account_id == last_active_user)
     GetLocalState()->SetString(kLastActiveUser, std::string());
 }
 
-bool UserManagerBase::FindKnownUserPrefs(
-    const AccountId& account_id,
-    const base::DictionaryValue** out_value) {
-  PrefService* local_state = GetLocalState();
-
-  // Local State may not be initialized in tests.
-  if (!local_state)
-    return false;
-
-  if (IsUserNonCryptohomeDataEphemeral(account_id))
-    return false;
-
-  const base::ListValue* known_users = local_state->GetList(kKnownUsers);
-  for (size_t i = 0; i < known_users->GetSize(); ++i) {
-    const base::DictionaryValue* element = nullptr;
-    if (known_users->GetDictionary(i, &element)) {
-      if (UserMatches(account_id, *element)) {
-        known_users->GetDictionary(i, out_value);
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-void UserManagerBase::UpdateKnownUserPrefs(const AccountId& account_id,
-                                           const base::DictionaryValue& values,
-                                           bool clear) {
-  PrefService* local_state = GetLocalState();
-
-  // Local State may not be initialized in tests.
-  if (!local_state)
-    return;
-
-  if (IsUserNonCryptohomeDataEphemeral(account_id))
-    return;
-
-  ListPrefUpdate update(local_state, kKnownUsers);
-  for (size_t i = 0; i < update->GetSize(); ++i) {
-    base::DictionaryValue* element = nullptr;
-    if (update->GetDictionary(i, &element)) {
-      if (UserMatches(account_id, *element)) {
-        if (clear)
-          element->Clear();
-        element->MergeDictionary(&values);
-        UpdateIdentity(account_id, *element);
-        return;
-      }
-    }
-  }
-  scoped_ptr<base::DictionaryValue> new_value(new base::DictionaryValue());
-  new_value->MergeDictionary(&values);
-  UpdateIdentity(account_id, *new_value);
-  update->Append(new_value.release());
-}
-
-bool UserManagerBase::GetKnownUserStringPref(const AccountId& account_id,
-                                             const std::string& path,
-                                             std::string* out_value) {
-  const base::DictionaryValue* user_pref_dict = nullptr;
-  if (!FindKnownUserPrefs(account_id, &user_pref_dict))
-    return false;
-
-  return user_pref_dict->GetString(path, out_value);
-}
-
-void UserManagerBase::SetKnownUserStringPref(const AccountId& account_id,
-                                             const std::string& path,
-                                             const std::string& in_value) {
-  PrefService* local_state = GetLocalState();
-
-  // Local State may not be initialized in tests.
-  if (!local_state)
-    return;
-
-  ListPrefUpdate update(local_state, kKnownUsers);
-  base::DictionaryValue dict;
-  dict.SetString(path, in_value);
-  UpdateKnownUserPrefs(account_id, dict, false);
-}
-
-bool UserManagerBase::GetKnownUserBooleanPref(const AccountId& account_id,
-                                              const std::string& path,
-                                              bool* out_value) {
-  const base::DictionaryValue* user_pref_dict = nullptr;
-  if (!FindKnownUserPrefs(account_id, &user_pref_dict))
-    return false;
-
-  return user_pref_dict->GetBoolean(path, out_value);
-}
-
-void UserManagerBase::SetKnownUserBooleanPref(const AccountId& account_id,
-                                              const std::string& path,
-                                              const bool in_value) {
-  PrefService* local_state = GetLocalState();
-
-  // Local State may not be initialized in tests.
-  if (!local_state)
-    return;
-
-  ListPrefUpdate update(local_state, kKnownUsers);
-  base::DictionaryValue dict;
-  dict.SetBoolean(path, in_value);
-  UpdateKnownUserPrefs(account_id, dict, false);
-}
-
-bool UserManagerBase::GetKnownUserIntegerPref(const AccountId& account_id,
-                                              const std::string& path,
-                                              int* out_value) {
-  const base::DictionaryValue* user_pref_dict = nullptr;
-  if (!FindKnownUserPrefs(account_id, &user_pref_dict))
-    return false;
-  return user_pref_dict->GetInteger(path, out_value);
-}
-
-void UserManagerBase::SetKnownUserIntegerPref(const AccountId& account_id,
-                                              const std::string& path,
-                                              const int in_value) {
-  PrefService* local_state = GetLocalState();
-
-  // Local State may not be initialized in tests.
-  if (!local_state)
-    return;
-
-  ListPrefUpdate update(local_state, kKnownUsers);
-  base::DictionaryValue dict;
-  dict.SetInteger(path, in_value);
-  UpdateKnownUserPrefs(account_id, dict, false);
-}
-
-AccountId UserManagerBase::GetKnownUserAccountIdImpl(
-    const std::string& user_email,
-    const std::string& gaia_id) {
-  DCHECK(!(user_email.empty() && gaia_id.empty()));
-
-  // We can have several users with the same gaia_id but different e-mails.
-  // The opposite case is not possible.
-  std::string stored_gaia_id;
-  const std::string sanitized_email =
-      user_email.empty()
-          ? std::string()
-          : gaia::CanonicalizeEmail(gaia::SanitizeEmail(user_email));
-  if (!sanitized_email.empty() &&
-      GetKnownUserStringPref(AccountId::FromUserEmail(sanitized_email),
-                             kGAIAIdKey, &stored_gaia_id)) {
-    if (!gaia_id.empty() && gaia_id != stored_gaia_id)
-      LOG(ERROR) << "User gaia id has changed. Sync will not work.";
-
-    // gaia_id is associated with cryptohome.
-    return AccountId::FromUserEmailGaiaId(sanitized_email, stored_gaia_id);
-  }
-
-  std::string stored_email;
-  // GetKnownUserStringPref() returns the first user record that matches
-  // given ID. So we will get the first one if there are multiples.
-  if (!gaia_id.empty() &&
-      GetKnownUserStringPref(AccountId::FromGaiaId(gaia_id), kCanonicalEmail,
-                             &stored_email)) {
-    return AccountId::FromUserEmailGaiaId(stored_email, gaia_id);
-  }
-
-  return AccountId::FromUserEmailGaiaId(sanitized_email, gaia_id);
-}
-
-void UserManagerBase::UpdateGaiaID(const AccountId& account_id,
-                                   const std::string& gaia_id) {
-  SetKnownUserStringPref(account_id, kGAIAIdKey, gaia_id);
-}
-
-bool UserManagerBase::FindGaiaID(const AccountId& account_id,
-                                 std::string* out_value) {
-  return GetKnownUserStringPref(account_id, kGAIAIdKey, out_value);
-}
-
-void UserManagerBase::SetKnownUserDeviceId(const AccountId& account_id,
-                                           const std::string& device_id) {
-  const std::string known_device_id = GetKnownUserDeviceId(account_id);
-  if (!known_device_id.empty() && device_id != known_device_id) {
-    NOTREACHED() << "Trying to change device ID for known user.";
-  }
-  SetKnownUserStringPref(account_id, kDeviceId, device_id);
-}
-
-std::string UserManagerBase::GetKnownUserDeviceId(const AccountId& account_id) {
-  std::string device_id;
-  if (GetKnownUserStringPref(account_id, kDeviceId, &device_id)) {
-    return device_id;
-  }
-  return std::string();
-}
-
-void UserManagerBase::SetKnownUserGAPSCookie(const AccountId& account_id,
-                                             const std::string& gaps_cookie) {
-  SetKnownUserStringPref(account_id, kGAPSCookie, gaps_cookie);
-}
-
-std::string UserManagerBase::GetKnownUserGAPSCookie(
-    const AccountId& account_id) {
-  std::string gaps_cookie;
-  if (GetKnownUserStringPref(account_id, kGAPSCookie, &gaps_cookie)) {
-    return gaps_cookie;
-  }
-  return std::string();
-}
-
 User* UserManagerBase::RemoveRegularOrSupervisedUserFromList(
     const AccountId& account_id) {
   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
   prefs_users_update->Clear();
   User* user = nullptr;
   for (UserList::iterator it = users_.begin(); it != users_.end();) {
     if ((*it)->GetAccountId() == account_id) {
       user = *it;
       it = users_.erase(it);
     } else {
       if ((*it)->HasGaiaAccount() || (*it)->IsSupervised()) {
         const std::string user_email = (*it)->email();
         prefs_users_update->Append(new base::StringValue(user_email));
       }
       ++it;
     }
   }
   OnUserRemoved(account_id);
   return user;
 }
 
-void UserManagerBase::RemoveKnownUserPrefs(const AccountId& account_id) {
-  ListPrefUpdate update(GetLocalState(), kKnownUsers);
-  for (size_t i = 0; i < update->GetSize(); ++i) {
-    base::DictionaryValue* element = nullptr;
-    if (update->GetDictionary(i, &element)) {
-      if (UserMatches(account_id, *element)) {
-        update->Remove(i, nullptr);
-        break;
-      }
-    }
-  }
-}
-
 void UserManagerBase::NotifyActiveUserChanged(const User* active_user) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   FOR_EACH_OBSERVER(UserManager::UserSessionStateObserver,
                     session_state_observer_list_,
                     ActiveUserChanged(active_user));
 }
 
 void UserManagerBase::NotifyUserAddedToSession(const User* added_user,
                                                bool user_switch_pending) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
@@ skipping 115 matching lines @@
 }
 
 void UserManagerBase::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = nullptr;
 }
 
 }  // namespace user_manager