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

chrome/browser/chromeos/policy/cloud_external_data_policy_observer.cc

 // Copyright 2013 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 "chrome/browser/chromeos/policy/cloud_external_data_policy_observer.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 #include "content/public/browser/notification_source.h"
 
 namespace policy {
 
 // Helper class that observes a policy for a logged-in user, notifying the
 // |parent_| whenever the external data reference for this user changes.
 class CloudExternalDataPolicyObserver::PolicyServiceObserver
     : public PolicyService::Observer {
  public:
   PolicyServiceObserver(CloudExternalDataPolicyObserver* parent,
-                        const std::string& user_id,
+                        const user_manager::UserID& user_id,
                         PolicyService* policy_service);
   ~PolicyServiceObserver() override;
 
   // PolicyService::Observer:
   void OnPolicyUpdated(const PolicyNamespace& ns,
                        const PolicyMap& previous,
                        const PolicyMap& current) override;
 
  private:
   CloudExternalDataPolicyObserver* parent_;
-  const std::string user_id_;
+  const user_manager::UserID user_id_;
   PolicyService* policy_service_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyServiceObserver);
 };
 
 CloudExternalDataPolicyObserver::PolicyServiceObserver::PolicyServiceObserver(
     CloudExternalDataPolicyObserver* parent,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     PolicyService* policy_service)
     : parent_(parent),
       user_id_(user_id),
       policy_service_(policy_service) {
   policy_service_->AddObserver(POLICY_DOMAIN_CHROME, this);
 
   if (!IsDeviceLocalAccountUser(user_id, NULL)) {
     // Notify |parent_| if the external data reference for |user_id_| is set
     // during login. This is omitted for device-local accounts because their
     // policy is available before login and the external data reference will
@@ skipping 24 matching lines @@
       (previous_entry && current_entry &&
            !previous_entry->Equals(*current_entry))) {
     // Notify |parent_| if the external data reference for |user_id_| has
     // changed.
     parent_->HandleExternalDataPolicyUpdate(user_id_, current_entry);
   }
 }
 
 void CloudExternalDataPolicyObserver::Delegate::OnExternalDataSet(
     const std::string& policy,
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
 }
 
 void CloudExternalDataPolicyObserver::Delegate::OnExternalDataCleared(
     const std::string& policy,
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
 }
 
 void CloudExternalDataPolicyObserver::Delegate::OnExternalDataFetched(
     const std::string& policy,
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     scoped_ptr<std::string> data) {
 }
 
 CloudExternalDataPolicyObserver::Delegate::~Delegate() {
 }
 
 CloudExternalDataPolicyObserver::CloudExternalDataPolicyObserver(
     chromeos::CrosSettings* cros_settings,
     DeviceLocalAccountPolicyService* device_local_account_policy_service,
     const std::string& policy,
@@ skipping 42 matching lines @@
   }
   Profile* profile = content::Details<Profile>(details).ptr();
 
   const user_manager::User* user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
   if (!user) {
     NOTREACHED();
     return;
   }
 
-  const std::string& user_id = user->email();
+  const user_manager::UserID& user_id = user->GetUserID();
   if (ContainsKey(logged_in_user_observers_, user_id)) {
     NOTREACHED();
     return;
   }
 
   ProfilePolicyConnector* policy_connector =
       ProfilePolicyConnectorFactory::GetForBrowserContext(profile);
   logged_in_user_observers_[user_id] = make_linked_ptr(
       new PolicyServiceObserver(this,
                                 user_id,
                                 policy_connector->policy_service()));
 }
 
 void CloudExternalDataPolicyObserver::OnPolicyUpdated(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   if (ContainsKey(logged_in_user_observers_, user_id)) {
     // When a device-local account is logged in, a policy change triggers both
     // OnPolicyUpdated() and PolicyServiceObserver::OnPolicyUpdated(). Ignore
     // the former so that the policy change is handled only once.
     return;
   }
 
   if (!device_local_account_policy_service_) {
     NOTREACHED();
     return;
@@ skipping 41 matching lines @@
   // Schedule a callback if device policy has not yet been verified.
   if (chromeos::CrosSettingsProvider::TRUSTED !=
       cros_settings_->PrepareTrustedValues(base::Bind(
           &CloudExternalDataPolicyObserver::RetrieveDeviceLocalAccounts,
           weak_factory_.GetWeakPtr()))) {
     return;
   }
 
   std::vector<DeviceLocalAccount> device_local_account_list =
       policy::GetDeviceLocalAccounts(cros_settings_);
-  std::set<std::string> device_local_accounts;
+  std::set<user_manager::UserID> device_local_accounts;
   for (std::vector<DeviceLocalAccount>::const_iterator it =
            device_local_account_list.begin();
        it != device_local_account_list.end(); ++it) {
     device_local_accounts.insert(it->user_id);
   }
 
   for (DeviceLocalAccountEntryMap::iterator it =
            device_local_account_entries_.begin();
        it != device_local_account_entries_.end(); ) {
     if (!ContainsKey(device_local_accounts, it->first)) {
-      const std::string user_id = it->first;
+      const user_manager::UserID user_id = it->first;
       it->second.DeleteOwnedMembers();
       device_local_account_entries_.erase(it++);
       // When a device-local account whose external data reference was set is
       // removed, emit a notification that the external data reference has been
       // cleared.
       HandleExternalDataPolicyUpdate(user_id, NULL);
     } else {
       ++it;
     }
   }
 
-  for (std::set<std::string>::const_iterator it = device_local_accounts.begin();
+  for (std::set<user_manager::UserID>::const_iterator it = device_local_accounts.begin();
        it != device_local_accounts.end(); ++it) {
     OnPolicyUpdated(*it);
   }
 }
 
 void CloudExternalDataPolicyObserver::HandleExternalDataPolicyUpdate(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const PolicyMap::Entry* entry) {
   if (!entry) {
     delegate_->OnExternalDataCleared(policy_, user_id);
     fetch_weak_ptrs_.erase(user_id);
     return;
   }
 
   delegate_->OnExternalDataSet(policy_, user_id);
 
   linked_ptr<WeakPtrFactory>& weak_ptr_factory = fetch_weak_ptrs_[user_id];
   weak_ptr_factory.reset(new WeakPtrFactory(this));
   if (entry->external_data_fetcher) {
     entry->external_data_fetcher->Fetch(base::Bind(
         &CloudExternalDataPolicyObserver::OnExternalDataFetched,
         weak_ptr_factory->GetWeakPtr(),
         user_id));
   } else {
     NOTREACHED();
   }
 }
 
 void CloudExternalDataPolicyObserver::OnExternalDataFetched(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     scoped_ptr<std::string> data) {
   FetchWeakPtrMap::iterator it = fetch_weak_ptrs_.find(user_id);
   DCHECK(it != fetch_weak_ptrs_.end());
   fetch_weak_ptrs_.erase(it);
   delegate_->OnExternalDataFetched(policy_, user_id, data.Pass());
 }
 
 }  // namespace policy