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

chrome/browser/chromeos/policy/device_local_account_policy_provider.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 "chrome/browser/chromeos/policy/device_local_account_policy_provider.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_external_data_manager.h"
 #include "chromeos/dbus/power_policy_controller.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_service.h"
 #include "components/policy/core/common/cloud/component_cloud_policy_service.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_namespace.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 DeviceLocalAccountPolicyProvider::DeviceLocalAccountPolicyProvider(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     DeviceLocalAccountPolicyService* service,
     scoped_ptr<PolicyMap> chrome_policy_overrides)
     : user_id_(user_id),
       service_(service),
       chrome_policy_overrides_(chrome_policy_overrides.Pass()),
       store_initialized_(false),
       waiting_for_policy_refresh_(false),
       weak_factory_(this) {
   service_->AddObserver(this);
   UpdateFromBroker();
 }
 
 DeviceLocalAccountPolicyProvider::~DeviceLocalAccountPolicyProvider() {
   service_->RemoveObserver(this);
 }
 
 // static
 scoped_ptr<DeviceLocalAccountPolicyProvider>
 DeviceLocalAccountPolicyProvider::Create(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     DeviceLocalAccountPolicyService* device_local_account_policy_service) {
   DeviceLocalAccount::Type type;
   if (!device_local_account_policy_service ||
       !IsDeviceLocalAccountUser(user_id, &type)) {
     return scoped_ptr<DeviceLocalAccountPolicyProvider>();
   }
 
   scoped_ptr<PolicyMap> chrome_policy_overrides;
   if (type == DeviceLocalAccount::TYPE_PUBLIC_SESSION) {
     chrome_policy_overrides.reset(new PolicyMap());
@@ skipping 58 matching lines @@
     waiting_for_policy_refresh_ = true;
     broker->core()->service()->RefreshPolicy(
         base::Bind(&DeviceLocalAccountPolicyProvider::ReportPolicyRefresh,
                    weak_factory_.GetWeakPtr()));
   } else {
     UpdateFromBroker();
   }
 }
 
 void DeviceLocalAccountPolicyProvider::OnPolicyUpdated(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   if (user_id == user_id_)
     UpdateFromBroker();
 }
 
 void DeviceLocalAccountPolicyProvider::OnDeviceLocalAccountsChanged() {
   UpdateFromBroker();
 }
 
 DeviceLocalAccountPolicyBroker* DeviceLocalAccountPolicyProvider::GetBroker()
     const {
@@ skipping 39 matching lines @@
       const PolicyMap::Entry& entry = it->second;
       chrome_policy.Set(
           it->first, entry.level, entry.scope, entry.value->DeepCopy(), NULL);
     }
   }
 
   UpdatePolicy(bundle.Pass());
 }
 
 }  // namespace policy