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

chrome/browser/chromeos/app_mode/kiosk_app_manager.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/app_mode/kiosk_app_manager.h"
 
 #include <map>
 #include <set>
 
 #include "base/barrier_closure.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/extensions/external_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/ownership/owner_key_util.h"
+#include "components/user_manager/user_id.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/extension_urls.h"
 
 namespace chromeos {
 
 namespace {
 
 // Domain that is used for kiosk-app account IDs.
 const char kKioskAppAccountDomain[] = "kiosk-apps";
 
 // Preference for the dictionary of user ids for which cryptohomes have to be
 // removed upon browser restart.
 const char kKioskUsersToRemove[] = "kiosk-users-to-remove";
 
 std::string GenerateKioskAppAccountId(const std::string& app_id) {
   return app_id + '@' + kKioskAppAccountDomain;
 }
 
-void ScheduleDelayedCryptohomeRemoval(const std::string& user_id,
+void ScheduleDelayedCryptohomeRemoval(const user_manager::UserID& user_id,
                                       const std::string& app_id) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate dict_update(local_state, kKioskUsersToRemove);
-  dict_update->SetStringWithoutPathExpansion(user_id, app_id);
+  dict_update->SetStringWithoutPathExpansion(user_id.GetUserEmail(), app_id);
   local_state->CommitPendingWrite();
 }
 
-void CancelDelayedCryptohomeRemoval(const std::string& user_id) {
+void CancelDelayedCryptohomeRemoval(const user_manager::UserID& user_id) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate dict_update(local_state, kKioskUsersToRemove);
-  dict_update->RemoveWithoutPathExpansion(user_id, NULL);
+  dict_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(), NULL);
   local_state->CommitPendingWrite();
 }
 
-void OnRemoveAppCryptohomeComplete(const std::string& user_id,
+void OnRemoveAppCryptohomeComplete(const user_manager::UserID& user_id,
                                    const std::string& app,
                                    const base::Closure& callback,
                                    bool success,
                                    cryptohome::MountError return_code) {
   if (success) {
     CancelDelayedCryptohomeRemoval(user_id);
   } else {
     ScheduleDelayedCryptohomeRemoval(user_id, app);
     LOG(ERROR) << "Remove cryptohome for " << app
         << " failed, return code: " << return_code;
   }
   if (!callback.is_null())
     callback.Run();
 }
 
 void PerformDelayedCryptohomeRemovals(bool service_is_available) {
   if (!service_is_available) {
     LOG(ERROR) << "Crypthomed is not available.";
     return;
   }
 
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dict =
       local_state->GetDictionary(kKioskUsersToRemove);
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
-    std::string user_id = it.key();
+    const user_manager::UserID user_id(std::string() /* gaia_id */, it.key());

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:46]

FromUserEmail()

     std::string app_id;
     it.value().GetAsString(&app_id);
     VLOG(1) << "Removing obsolete crypthome for " << app_id;
     cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
         user_id,
         base::Bind(&OnRemoveAppCryptohomeComplete,
                    user_id,
                    app_id,
                    base::Closure()));
   }
@@ skipping 56 matching lines @@
     bool is_extension_pending,
     bool auto_launched_with_zero_delay)
     : app_id(data.app_id()),
       user_id(data.user_id()),
       name(data.name()),
       icon(data.icon()),
       is_loading(data.IsLoading() || is_extension_pending),
       was_auto_launched_with_zero_delay(auto_launched_with_zero_delay) {
 }
 
-KioskAppManager::App::App() : is_loading(false),
+KioskAppManager::App::App() : user_id(std::string(), std::string()),

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:46]

EmptyUserId() ? 

+                              is_loading(false),
                               was_auto_launched_with_zero_delay(false) {}
 
 KioskAppManager::App::~App() {}
 
 std::string KioskAppManager::GetAutoLaunchApp() const {
   return auto_launch_app_id_;
 }
 
 void KioskAppManager::SetAutoLaunchApp(const std::string& app_id,
                                        OwnerSettingsServiceChromeOS* service) {
@@ skipping 413 matching lines @@
       new_app->Load();
     }
     CancelDelayedCryptohomeRemoval(it->user_id);
   }
 
   base::Closure cryptohomes_barrier_closure;
 
   const user_manager::User* active_user =
       user_manager::UserManager::Get()->GetActiveUser();
   if (active_user) {
-    std::string active_user_id = active_user->GetUserID();
+    user_manager::UserID active_user_id = active_user->GetUserID();

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:46]

auto?

     for (const auto& it : old_apps) {
       if (it.second->user_id() == active_user_id) {
         VLOG(1) << "Currently running kiosk app removed from policy, exiting";
         cryptohomes_barrier_closure = BarrierClosure(
             old_apps.size(), base::Bind(&chrome::AttemptUserExit));
         break;
       }
     }
   }
 
@@ skipping 111 matching lines @@
   *cache_dir = user_data_dir.AppendASCII(kCrxCacheDir);
 }
 
 void KioskAppManager::GetCrxUnpackDir(base::FilePath* unpack_dir) {
   base::FilePath temp_dir;
   base::GetTempDir(&temp_dir);
   *unpack_dir = temp_dir.AppendASCII(kCrxUnpackDir);
 }
 
 }  // namespace chromeos