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

chrome/browser/chromeos/policy/cloud_external_data_policy_observer.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_POLICY_CLOUD_EXTERNAL_DATA_POLICY_OBSERVER_H_
 #define CHROME_BROWSER_CHROMEOS_POLICY_CLOUD_EXTERNAL_DATA_POLICY_OBSERVER_H_
 
 #include <map>
 #include <string>
 
@@ skipping 20 matching lines @@
 // be emitted that an external data reference has been set and the referenced
 // external data to be fetched.
 class CloudExternalDataPolicyObserver
     : public content::NotificationObserver,
       public DeviceLocalAccountPolicyService::Observer {
  public:
   class Delegate {
    public:
     // Invoked when an external data reference is set for |user_id|.
     virtual void OnExternalDataSet(const std::string& policy,
-                                   const std::string& user_id);
+                                   const user_manager::UserID& user_id);
 
     // Invoked when the external data reference is cleared for |user_id|.
     virtual void OnExternalDataCleared(const std::string& policy,
-                                       const std::string& user_id);
+                                       const user_manager::UserID& user_id);
 
     // Invoked when the external data referenced for |user_id| has been fetched.
     // Failed fetches are retried and the method is called only when a fetch
     // eventually succeeds. If a fetch fails permanently (e.g. because the
     // external data reference specifies an invalid URL), the method is not
     // called at all.
     virtual void OnExternalDataFetched(const std::string& policy,
-                                       const std::string& user_id,
+                                       const user_manager::UserID& user_id,
                                        scoped_ptr<std::string> data);
 
    protected:
     virtual ~Delegate();
   };
 
   CloudExternalDataPolicyObserver(
       chromeos::CrosSettings* cros_settings,
       DeviceLocalAccountPolicyService* device_local_account_policy_service,
       const std::string& policy,
       Delegate* delegate);
   ~CloudExternalDataPolicyObserver() override;
 
   void Init();
 
   // content::NotificationObserver:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // DeviceLocalAccountPolicyService::Observer:
-  void OnPolicyUpdated(const std::string& user_id) override;
+  void OnPolicyUpdated(const user_manager::UserID& user_id) override;
   void OnDeviceLocalAccountsChanged() override;
 
  private:
   // Helper class that observes |policy_| for a logged-in user.
   class PolicyServiceObserver;
 
   void RetrieveDeviceLocalAccounts();
 
   // Handles the new policy map |entry| for |user_id| by canceling any external
   // data fetch currently in progress, emitting a notification that an external
   // data reference has been cleared (if |entry| is NULL) or set (otherwise),
   // starting a new external data fetch in the latter case.
-  void HandleExternalDataPolicyUpdate(const std::string& user_id,
+  void HandleExternalDataPolicyUpdate(const user_manager::UserID& user_id,
                                       const PolicyMap::Entry* entry);
 
-  void OnExternalDataFetched(const std::string& user_id,
+  void OnExternalDataFetched(const user_manager::UserID& user_id,
                              scoped_ptr<std::string> data);
 
   // A map from each device-local account user ID to its current policy map
   // entry for |policy_|.
-  typedef std::map<std::string, PolicyMap::Entry> DeviceLocalAccountEntryMap;
+  typedef std::map<user_manager::UserID, PolicyMap::Entry> DeviceLocalAccountEntryMap;
   DeviceLocalAccountEntryMap device_local_account_entries_;
 
   // A map from each logged-in user to the helper that observes |policy_| in the
   // user's PolicyService.
-  typedef std::map<std::string, linked_ptr<PolicyServiceObserver> >
+  typedef std::map<user_manager::UserID, linked_ptr<PolicyServiceObserver> >
       LoggedInUserObserverMap;
   LoggedInUserObserverMap logged_in_user_observers_;
 
   chromeos::CrosSettings* cros_settings_;
   DeviceLocalAccountPolicyService* device_local_account_policy_service_;
 
   // The policy that |this| observes.
   std::string policy_;
 
   Delegate* delegate_;
 
   content::NotificationRegistrar notification_registrar_;
   scoped_ptr<chromeos::CrosSettings::ObserverSubscription>
       device_local_accounts_subscription_;
 
   // A map from user ID to a base::WeakPtr for each external data fetch
   // currently in progress. This allows fetches to be effectively be canceled by
   // invalidating the pointers.
   typedef base::WeakPtrFactory<CloudExternalDataPolicyObserver>
       WeakPtrFactory;
-  typedef std::map<std::string, linked_ptr<WeakPtrFactory> > FetchWeakPtrMap;
+  typedef std::map<user_manager::UserID, linked_ptr<WeakPtrFactory> > FetchWeakPtrMap;
   FetchWeakPtrMap fetch_weak_ptrs_;
 
   base::WeakPtrFactory<CloudExternalDataPolicyObserver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudExternalDataPolicyObserver);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_CHROMEOS_POLICY_CLOUD_EXTERNAL_DATA_POLICY_OBSERVER_H_