ChromeOS cryptohome should be able to use gaia id as user identifier.

components/user_manager/known_user.cc

 // Copyright 2015 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/known_user.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 28 matching lines @@
 // Key of GAPS cookie.
 const char kGAPSCookie[] = "gaps_cookie";
 
 // Key of the reason for re-auth.
 const char kReauthReasonKey[] = "reauth_reason";
 
 // Key for the GaiaId migration status.
 const char kGaiaIdMigration[] = "gaia_id_migration";
 
 PrefService* GetLocalState() {
-  UserManager* user_manager = UserManager::Get();
-  if (user_manager)
-    return user_manager->GetLocalState();
+  if (!UserManager::IsInitialized())
+    return nullptr;
 
-  return nullptr;
+  return UserManager::Get()->GetLocalState();
 }
 
 // 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());
+  if (!account_id.GetUserEmail().empty())
+    dict.SetString(kCanonicalEmail, account_id.GetUserEmail());
+
+  if (!account_id.GetGaiaId().empty())
+    dict.SetString(kGAIAIdKey, account_id.GetGaiaId());
 }
 
 }  // namespace
 
 bool FindPrefs(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;
 
   // UserManager is usually NULL in unit tests.
-  UserManager* user_manager = UserManager::Get();
-  if (user_manager &&
-      user_manager->IsUserNonCryptohomeDataEphemeral(account_id))
+  if (UserManager::IsInitialized() &&
+      UserManager::Get()->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 UpdatePrefs(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;
 
   // UserManager is usually NULL in unit tests.
-  UserManager* user_manager = UserManager::Get();
-  if (user_manager &&
-      user_manager->IsUserNonCryptohomeDataEphemeral(account_id))
+  if (UserManager::IsInitialized() &&
+      UserManager::Get()->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);
@@ skipping 82 matching lines @@
   UpdatePrefs(account_id, dict, false);
 }
 
 AccountId GetAccountId(const std::string& user_email,
                        const std::string& gaia_id) {
   // In tests empty accounts are possible.
   if (user_email.empty() && gaia_id.empty())
     return EmptyAccountId();
 
   AccountId result(EmptyAccountId());
-  UserManager* user_manager = UserManager::Get();
-  if (user_manager &&
-      user_manager->GetPlatformKnownUserId(user_email, gaia_id, &result)) {
+  // UserManager is usually NULL in unit tests.
+  if (UserManager::IsInitialized() &&
+      UserManager::Get()->GetPlatformKnownUserId(user_email, gaia_id,
+                                                 &result)) {
     return result;
   }
 
   // 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));
@@ skipping 14 matching lines @@
   if (!gaia_id.empty() && GetStringPref(AccountId::FromGaiaId(gaia_id),
                                         kCanonicalEmail, &stored_email)) {
     return AccountId::FromUserEmailGaiaId(stored_email, gaia_id);
   }
 
   return (gaia_id.empty()
               ? AccountId::FromUserEmail(user_email)
               : AccountId::FromUserEmailGaiaId(user_email, gaia_id));
 }
 
+std::vector<AccountId> GetKnownAccountIds() {
+  std::vector<AccountId> result;
+  PrefService* local_state = GetLocalState();
+
+  // Local State may not be initialized in tests.
+  if (!local_state)
+    return result;
+
+  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)) {
+      std::string email;
+      std::string gaia_id;
+      const bool has_email = element->GetString(kCanonicalEmail, &email);
+      const bool has_gaia_id = element->GetString(kGAIAIdKey, &gaia_id);
+      if (has_email || has_gaia_id)
+        result.push_back(AccountId::FromUserEmailGaiaId(email, gaia_id));
+    }
+  }
+  return result;
+}
+
 bool GetGaiaIdMigrationStatus(const AccountId& account_id,
                               const std::string& subsystem) {
   bool migrated = false;
 
   if (GetBooleanPref(account_id,
                      std::string(kGaiaIdMigration) + "." + subsystem,
                      &migrated)) {
     return migrated;
   }
 
@@ skipping 80 matching lines @@
     }
   }
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kKnownUsers);
 }
 
 }  // namespace known_user
 }  // namespace user_manager