Chromad: Add authentication flow

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 <memory>
 #include <utility>
@@ skipping 14 matching lines @@
 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 account type.
+const char kAccountTypeKey[] = "account_type";
+
 // 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.
@@ skipping 26 matching lines @@
   return false;
 }
 
 // Fills relevant |dict| values based on |account_id|.
 void UpdateIdentity(const AccountId& account_id, base::DictionaryValue& dict) {
   if (!account_id.GetUserEmail().empty())
     dict.SetString(kCanonicalEmail, account_id.GetUserEmail());
 
   if (!account_id.GetGaiaId().empty())
     dict.SetString(kGAIAIdKey, account_id.GetGaiaId());
+
+  if (!account_id.GetAccountType().empty())
+    dict.SetString(kAccountTypeKey, account_id.GetAccountType());
 }
 
 }  // 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)
@@ skipping 145 matching lines @@
       user_email.empty()
           ? std::string()
           : gaia::CanonicalizeEmail(gaia::SanitizeEmail(user_email));
 
   if (!sanitized_email.empty() &&
       GetStringPref(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.";
 
+    AccountId account_id =
+        AccountId::FromUserEmailGaiaId(sanitized_email, stored_gaia_id);
+    std::string stored_account_type;
+    if (!sanitized_email.empty() &&
+        GetStringPref(AccountId::FromUserEmail(sanitized_email),
+                      kAccountTypeKey, &stored_account_type)) {
+      account_id.SetAccountType(stored_account_type);
+    }
     // gaia_id is associated with cryptohome.
-    return AccountId::FromUserEmailGaiaId(sanitized_email, stored_gaia_id);
+    return account_id;
   }
 
   std::string stored_email;
   // GetStringPref() returns the first user record that matches
   // given ID. So we will get the first one if there are multiples.
   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;
+      std::string account_type;
       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));
+      const bool has_account_type =
+          element->GetString(kAccountTypeKey, &account_type);
+      if (has_email || has_gaia_id) {
+        AccountId account_id = AccountId::FromUserEmailGaiaId(email, gaia_id);
+        if (has_account_type)
+          account_id.SetAccountType(account_type);
+        result.push_back(account_id);
+      }
     }
   }
   return result;
 }
 
 bool GetGaiaIdMigrationStatus(const AccountId& account_id,
                               const std::string& subsystem) {
   bool migrated = false;
 
   if (GetBooleanPref(account_id,
@@ skipping 85 matching lines @@
     }
   }
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kKnownUsers);
 }
 
 }  // namespace known_user
 }  // namespace user_manager