This CL replaces user_manager::UserID with AccountId.

chromeos/login/auth/cryptohome_authenticator.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 "chromeos/login/auth/cryptohome_authenticator.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/auth/auth_status_consumer.h"
 #include "chromeos/login/auth/key.h"
 #include "chromeos/login/auth/user_context.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/login/user_names.h"
 #include "chromeos/login_event_recorder.h"
 #include "components/device_event_log/device_event_log.h"
+#include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user_type.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // The label used for the key derived from the user's GAIA credentials.
 const char kCryptohomeGAIAKeyLabel[] = "gaia";
 
@@ skipping 102 matching lines @@
                                            cryptohome::PRIV_DEFAULT);
   cryptohome::MountParameters mount(ephemeral);
   if (create_if_nonexistent) {
     mount.create_keys.push_back(cryptohome::KeyDefinition(
         key->GetSecret(),
         kCryptohomeGAIAKeyLabel,
         cryptohome::PRIV_DEFAULT));
   }
 
   cryptohome::HomedirMethods::GetInstance()->MountEx(
-      cryptohome::Identification(attempt->user_context.GetUserID()),
-      cryptohome::Authorization(auth_key),
-      mount,
+      cryptohome::Identification(
+          attempt->user_context.GetUserID().GetUserEmail()),
+      cryptohome::Authorization(auth_key), mount,
       base::Bind(&OnMount, attempt, resolver));
 }
 
 // Callback invoked when the system salt has been retrieved. Transforms the key
 // in |attempt->user_context| using Chrome's default hashing algorithm and the
 // system salt, then calls MountEx().
 void OnGetSystemSalt(const base::WeakPtr<AuthAttemptState>& attempt,
                      scoped_refptr<CryptohomeAuthenticator> resolver,
                      bool ephemeral,
                      bool create_if_nonexistent,
@@ skipping 95 matching lines @@
   chromeos::LoginEventRecorder::Get()->AddLoginTimeMarker(
       "CryptohomeMount-Start", false);
 
   if (attempt->user_context.GetKey()->GetKeyType() !=
           Key::KEY_TYPE_PASSWORD_PLAIN) {
     DoMount(attempt, resolver, ephemeral, create_if_nonexistent);
     return;
   }
 
   cryptohome::HomedirMethods::GetInstance()->GetKeyDataEx(
-      cryptohome::Identification(attempt->user_context.GetUserID()),
-      kCryptohomeGAIAKeyLabel,
-      base::Bind(&OnGetKeyDataEx,
-                 attempt,
-                 resolver,
-                 ephemeral,
-                 create_if_nonexistent));
+      cryptohome::Identification(
+          attempt->user_context.GetUserID().GetUserEmail()),
+      kCryptohomeGAIAKeyLabel, base::Bind(&OnGetKeyDataEx, attempt, resolver,
+                                          ephemeral, create_if_nonexistent));
 }
 
 // Calls cryptohome's mount method for guest and also get the user hash from
 // cryptohome.
 void MountGuestAndGetHash(const base::WeakPtr<AuthAttemptState>& attempt,
                           scoped_refptr<CryptohomeAuthenticator> resolver) {
   attempt->UsernameHashRequested();
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncMountGuest(
       base::Bind(&TriggerResolveWithLoginTimeMarker,
                  "CryptohomeMount-End",
                  attempt,
                  resolver));
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncGetSanitizedUsername(
-      attempt->user_context.GetUserID(),
+      attempt->user_context.GetUserID().GetUserEmail(),
       base::Bind(&TriggerResolveHash, attempt, resolver));
 }
 
 // Calls cryptohome's MountPublic method
 void MountPublic(const base::WeakPtr<AuthAttemptState>& attempt,
                  scoped_refptr<CryptohomeAuthenticator> resolver,
                  int flags) {
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncMountPublic(
-      attempt->user_context.GetUserID(),
-      flags,
+      attempt->user_context.GetUserID().GetUserEmail(), flags,
       base::Bind(&TriggerResolveWithLoginTimeMarker,
-                 "CryptohomeMountPublic-End",
-                 attempt,
-                 resolver));
+                 "CryptohomeMountPublic-End", attempt, resolver));
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncGetSanitizedUsername(
-      attempt->user_context.GetUserID(),
+      attempt->user_context.GetUserID().GetUserEmail(),
       base::Bind(&TriggerResolveHash, attempt, resolver));
 }
 
 // Calls cryptohome's key migration method.
 void Migrate(const base::WeakPtr<AuthAttemptState>& attempt,
              scoped_refptr<CryptohomeAuthenticator> resolver,
              bool passing_old_hash,
              const std::string& old_password,
              const std::string& system_salt) {
   chromeos::LoginEventRecorder::Get()->AddLoginTimeMarker(
       "CryptohomeMigrate-Start", false);
   cryptohome::AsyncMethodCaller* caller =
       cryptohome::AsyncMethodCaller::GetInstance();
 
   // TODO(bartfab): Retrieve the hashing algorithm and salt to use for |old_key|
   // from cryptohomed.
   scoped_ptr<Key> old_key =
       TransformKeyIfNeeded(Key(old_password), system_salt);
   scoped_ptr<Key> new_key =
       TransformKeyIfNeeded(*attempt->user_context.GetKey(), system_salt);
   if (passing_old_hash) {
-    caller->AsyncMigrateKey(attempt->user_context.GetUserID(),
-                            old_key->GetSecret(),
-                            new_key->GetSecret(),
-                            base::Bind(&TriggerResolveWithLoginTimeMarker,
-                                       "CryptohomeMount-End",
-                                       attempt,
-                                       resolver));
+    caller->AsyncMigrateKey(
+        attempt->user_context.GetUserID().GetUserEmail(), old_key->GetSecret(),
+        new_key->GetSecret(),
+        base::Bind(&TriggerResolveWithLoginTimeMarker, "CryptohomeMount-End",
+                   attempt, resolver));
   } else {
-    caller->AsyncMigrateKey(attempt->user_context.GetUserID(),
-                            new_key->GetSecret(),
-                            old_key->GetSecret(),
-                            base::Bind(&TriggerResolveWithLoginTimeMarker,
-                                       "CryptohomeMount-End",
-                                       attempt,
-                                       resolver));
+    caller->AsyncMigrateKey(
+        attempt->user_context.GetUserID().GetUserEmail(), new_key->GetSecret(),
+        old_key->GetSecret(),
+        base::Bind(&TriggerResolveWithLoginTimeMarker, "CryptohomeMount-End",
+                   attempt, resolver));
   }
 }
 
 // Calls cryptohome's remove method.
 void Remove(const base::WeakPtr<AuthAttemptState>& attempt,
             scoped_refptr<CryptohomeAuthenticator> resolver) {
   chromeos::LoginEventRecorder::Get()->AddLoginTimeMarker(
       "CryptohomeRemove-Start", false);
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
-      attempt->user_context.GetUserID(),
-      base::Bind(&TriggerResolveWithLoginTimeMarker,
-                 "CryptohomeRemove-End",
-                 attempt,
-                 resolver));
+      attempt->user_context.GetUserID().GetUserEmail(),
+      base::Bind(&TriggerResolveWithLoginTimeMarker, "CryptohomeRemove-End",
+                 attempt, resolver));
 }
 
 // Calls cryptohome's key check method.
 void CheckKey(const base::WeakPtr<AuthAttemptState>& attempt,
               scoped_refptr<CryptohomeAuthenticator> resolver,
               const std::string& system_salt) {
   scoped_ptr<Key> key =
       TransformKeyIfNeeded(*attempt->user_context.GetKey(), system_salt);
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncCheckKey(
-      attempt->user_context.GetUserID(),
-      key->GetSecret(),
+      attempt->user_context.GetUserID().GetUserEmail(), key->GetSecret(),
       base::Bind(&TriggerResolve, attempt, resolver));
 }
 
 }  // namespace
 
 CryptohomeAuthenticator::CryptohomeAuthenticator(
     scoped_refptr<base::TaskRunner> task_runner,
     AuthStatusConsumer* consumer)
     : Authenticator(consumer),
       task_runner_(task_runner),
@@ skipping 508 matching lines @@
   Resolve();
 }
 
 void CryptohomeAuthenticator::SetOwnerState(bool owner_check_finished,
                                             bool check_result) {
   owner_is_verified_ = owner_check_finished;
   user_can_login_ = check_result;
 }
 
 }  // namespace chromeos