This CL replaces e-mail with AccountId in easy signin code.

chrome/browser/ui/webui/signin/user_manager_screen_handler.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/ui/webui/signin/user_manager_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 21 matching lines @@
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/proximity_auth/screenlock_bridge.h"
+#include "components/signin/core/account_id/account_id.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/gfx/image/image.h"
@@ skipping 254 matching lines @@
 }
 
 void UserManagerScreenHandler::ShowBannerMessage(
     const base::string16& message) {
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.showBannerMessage",
       base::StringValue(message));
 }
 
 void UserManagerScreenHandler::ShowUserPodCustomIcon(
-    const std::string& user_email,
+    const AccountId& account_id,
     const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions&
         icon_options) {
   scoped_ptr<base::DictionaryValue> icon = icon_options.ToDictionaryValue();
   if (!icon || icon->empty())
     return;
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.showUserPodCustomIcon",
-      base::StringValue(user_email),
-      *icon);
+      base::StringValue(account_id.GetUserEmail()), *icon);
 }
 
 void UserManagerScreenHandler::HideUserPodCustomIcon(
-    const std::string& user_email) {
+    const AccountId& account_id) {
   web_ui()->CallJavascriptFunction(
       "login.AccountPickerScreen.hideUserPodCustomIcon",
-      base::StringValue(user_email));
+      base::StringValue(account_id.GetUserEmail()));
 }
 
 void UserManagerScreenHandler::EnableInput() {
   // Nothing here because UI is not disabled when starting to authenticate.
 }
 
 void UserManagerScreenHandler::SetAuthType(
-    const std::string& user_email,
+    const AccountId& account_id,
     proximity_auth::ScreenlockBridge::LockHandler::AuthType auth_type,
     const base::string16& auth_value) {
-  if (GetAuthType(user_email) ==
+  if (GetAuthType(account_id) ==
       proximity_auth::ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD)
     return;
 
-  user_auth_type_map_[user_email] = auth_type;
-  web_ui()->CallJavascriptFunction(
-      "login.AccountPickerScreen.setAuthType",
-      base::StringValue(user_email),
-      base::FundamentalValue(auth_type),
-      base::StringValue(auth_value));
+  user_auth_type_map_[account_id.GetUserEmail()] = auth_type;
+  web_ui()->CallJavascriptFunction("login.AccountPickerScreen.setAuthType",
+                                   base::StringValue(account_id.GetUserEmail()),
+                                   base::FundamentalValue(auth_type),
+                                   base::StringValue(auth_value));
 }
 
 proximity_auth::ScreenlockBridge::LockHandler::AuthType
-UserManagerScreenHandler::GetAuthType(const std::string& user_email) const {
-  UserAuthTypeMap::const_iterator it = user_auth_type_map_.find(user_email);
+UserManagerScreenHandler::GetAuthType(const AccountId& account_id) const {
+  const auto it = user_auth_type_map_.find(account_id.GetUserEmail());
   if (it == user_auth_type_map_.end())
     return proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
   return it->second;
 }
 
 proximity_auth::ScreenlockBridge::LockHandler::ScreenType
 UserManagerScreenHandler::GetScreenType() const {
   return proximity_auth::ScreenlockBridge::LockHandler::LOCK_SCREEN;
 }
 
-void UserManagerScreenHandler::Unlock(const std::string& user_email) {
-  base::FilePath path =
-      profiles::GetPathOfProfileWithEmail(g_browser_process->profile_manager(),
-                                          user_email);
+void UserManagerScreenHandler::Unlock(const AccountId& account_id) {
+  const base::FilePath path = profiles::GetPathOfProfileWithEmail(
+      g_browser_process->profile_manager(), account_id.GetUserEmail());
   if (!path.empty()) {
     authenticating_profile_path_ = path;
     ReportAuthenticationResult(true, ProfileMetrics::AUTH_LOCAL);
   }
 }
 
-void UserManagerScreenHandler::AttemptEasySignin(
-    const std::string& user_email,
-    const std::string& secret,
-    const std::string& key_label) {
+void UserManagerScreenHandler::AttemptEasySignin(const AccountId& account_id,
+                                                 const std::string& secret,
+                                                 const std::string& key_label) {
   NOTREACHED();
 }
 
 void UserManagerScreenHandler::HandleInitialize(const base::ListValue* args) {
   // If the URL has a hash parameter, store it for later.
   args->GetString(0, &url_hash_);
 
   SendUserList();
   web_ui()->CallJavascriptFunction("cr.ui.Oobe.showUserManagerScreen",
       base::FundamentalValue(IsGuestModeEnabled()),
@@ skipping 151 matching lines @@
       false,  /* reuse any existing windows */
       base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                  weak_ptr_factory_.GetWeakPtr()),
       ProfileMetrics::SWITCH_PROFILE_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleAttemptUnlock(
     const base::ListValue* args) {
   std::string email;
   CHECK(args->GetString(0, &email));
-  GetScreenlockRouter(email)->OnAuthAttempted(GetAuthType(email), "");
+  GetScreenlockRouter(email)
+      ->OnAuthAttempted(GetAuthType(AccountId::FromUserEmail(email)), "");
 }
 
 void UserManagerScreenHandler::HandleHardlockUserPod(
     const base::ListValue* args) {
   std::string email;
   CHECK(args->GetString(0, &email));
+  const AccountId account_id = AccountId::FromUserEmail(email);
   SetAuthType(
-      email,
+      account_id,
       proximity_auth::ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
       base::string16());
-  HideUserPodCustomIcon(email);
+  HideUserPodCustomIcon(account_id);
 }
 
 void UserManagerScreenHandler::HandleRemoveUserWarningLoadStats(
     const base::ListValue* args) {
   const base::Value* profile_path_value;
 
   if (!args->Get(0, &profile_path_value))
     return;
 
   base::FilePath profile_path;
@@ skipping 398 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false, desktop_type_);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }