We should use UserID object to identify users instead of username.

chromeos/attestation/attestation_flow.cc

 // Copyright (c) 2012 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/attestation/attestation_flow.h"
 
 #include "base/bind.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/cryptohome_client.h"
+#include "components/user_manager/user_id.h"
 
 namespace chromeos {
 namespace attestation {
 
 namespace {
 
 // Redirects to one of three callbacks based on a boolean value and dbus call
 // status.
 //
 // Parameters
@@ skipping 69 matching lines @@
       cryptohome_client_(cryptohome_client),
       server_proxy_(server_proxy.Pass()),
       weak_factory_(this) {
 }
 
 AttestationFlow::~AttestationFlow() {
 }
 
 void AttestationFlow::GetCertificate(
     AttestationCertificateProfile certificate_profile,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& request_origin,
     bool force_new_key,
     const CertificateCallback& callback) {
   // If this device has not enrolled with the Privacy CA, we need to do that
   // first.  Once enrolled we can proceed with the certificate request.
   base::Closure do_cert_request = base::Bind(
       &AttestationFlow::StartCertificateRequest,
       weak_factory_.GetWeakPtr(),
       certificate_profile,
       user_id,
@@ skipping 76 matching lines @@
     return;
   }
 
   // Enrollment has successfully completed, we can move on to whatever is next.
   if (!next_task.is_null())
     next_task.Run();
 }
 
 void AttestationFlow::StartCertificateRequest(
     AttestationCertificateProfile certificate_profile,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& request_origin,
     bool generate_new_key,
     const CertificateCallback& callback) {
   AttestationKeyType key_type = GetKeyTypeForProfile(certificate_profile);
   std::string key_name = GetKeyNameForProfile(certificate_profile,
                                               request_origin);
   if (generate_new_key) {
     // Get the attestation service to create a Privacy CA certificate request.
     async_caller_->AsyncTpmAttestationCreateCertRequest(
         server_proxy_->GetType(),
@@ skipping 31 matching lines @@
         key_name,
         base::Bind(&DBusBoolRedirectCallback,
             on_key_exists,
             on_key_not_exists,
             base::Bind(callback, false, "")));
   }
 }
 
 void AttestationFlow::SendCertificateRequestToPCA(
     AttestationKeyType key_type,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& key_name,
     const CertificateCallback& callback,
     bool success,
     const std::string& data) {
   if (!success) {
     LOG(ERROR) << "Attestation: Failed to create certificate request.";
     if (!callback.is_null())
       callback.Run(false, "");
     return;
   }
 
   // Send the request to the Privacy CA.
   server_proxy_->SendCertificateRequest(
       data,
       base::Bind(&AttestationFlow::SendCertificateResponseToDaemon,
                  weak_factory_.GetWeakPtr(),
                  key_type,
                  user_id,
                  key_name,
                  callback));
 }
 
 void AttestationFlow::SendCertificateResponseToDaemon(
     AttestationKeyType key_type,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& key_name,
     const CertificateCallback& callback,
     bool success,
     const std::string& data) {
   if (!success) {
     LOG(ERROR) << "Attestation: Certificate request failed.";
     if (!callback.is_null())
       callback.Run(false, "");
     return;
   }
 
   // Forward the response to the attestation service to complete the operation.
   async_caller_->AsyncTpmAttestationFinishCertRequest(data,
                                                       key_type,
                                                       user_id,
                                                       key_name,
                                                       base::Bind(callback));
 }
 
 void AttestationFlow::GetExistingCertificate(
     AttestationKeyType key_type,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& key_name,
     const CertificateCallback& callback) {
   cryptohome_client_->TpmAttestationGetCertificate(
       key_type,
       user_id,
       key_name,
       base::Bind(&DBusDataMethodCallback, callback));
 }
 
 ServerProxy::~ServerProxy() {}
 
 PrivacyCAType ServerProxy::GetType() {
   return DEFAULT_PCA;
 }
 
 }  // namespace attestation
 }  // namespace chromeos