[cros] Display emails of users are stored in a separate dictionary in Local State.

chrome/browser/chromeos/login/login_utils.cc

 // Copyright (c) 2011 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/login/login_utils.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 519 matching lines @@
     net::NetworkChangeNotifier::AddOnlineStateObserver(this);
   }
 
   virtual ~LoginUtilsImpl() {
     net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
   }
 
   // LoginUtils implementation:
   virtual void PrepareProfile(
       const std::string& username,
+      const std::string& display_email,
       const std::string& password,
       const GaiaAuthConsumer::ClientLoginResult& credentials,
       bool pending_requests,
       bool using_oauth,
       bool has_cookies,
       LoginUtils::Delegate* delegate) OVERRIDE;
   virtual void DelegateDeleted(LoginUtils::Delegate* delegate) OVERRIDE;
   virtual void CompleteOffTheRecordLogin(const GURL& start_url) OVERRIDE;
   virtual void SetFirstLoginPrefs(PrefService* prefs) OVERRIDE;
   virtual scoped_refptr<Authenticator> CreateAuthenticator(
       LoginStatusConsumer* consumer) OVERRIDE;
   virtual void PrewarmAuthentication() OVERRIDE;
-  virtual void RestoreAuthenticationSession(const std::string& user_name,
-                                            Profile* profile) OVERRIDE;
+  virtual void RestoreAuthenticationSession(Profile* profile) OVERRIDE;
   virtual void StartTokenServices(Profile* user_profile) OVERRIDE;
   virtual void StartSync(
       Profile* profile,
       const GaiaAuthConsumer::ClientLoginResult& credentials) OVERRIDE;
   virtual void SetBackgroundView(
       chromeos::BackgroundView* background_view) OVERRIDE;
   virtual chromeos::BackgroundView* GetBackgroundView() OVERRIDE;
   virtual void TransferDefaultCookies(Profile* default_profile,
                                       Profile* new_profile) OVERRIDE;
   virtual void TransferDefaultAuthCache(Profile* default_profile,
@@ skipping 65 matching lines @@
   void FetchPolicyToken(Profile* offrecord_profile,
                         const std::string& token,
                         const std::string& secret);
 
   // Check user's profile for kApplicationLocale setting.
   void RespectLocalePreference(Profile* pref);
 
   // The current background view.
   chromeos::BackgroundView* background_view_;
 
-  std::string username_;
   std::string password_;
   GaiaAuthConsumer::ClientLoginResult credentials_;
   bool pending_requests_;
   bool using_oauth_;
   bool has_cookies_;
   // Has to be scoped_refptr, see comment for CreateAuthenticator(...).
   scoped_refptr<Authenticator> authenticator_;
   scoped_ptr<GaiaOAuthFetcher> oauth_fetcher_;
   scoped_ptr<PolicyOAuthFetcher> policy_oauth_fetcher_;
   scoped_ptr<OAuthLoginVerifier> oauth_login_verifier_;
@@ skipping 30 matching lines @@
   LoginUtilsWrapper() {}
 
   base::Lock create_lock_;
   scoped_ptr<LoginUtils> ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsWrapper);
 };
 
 void LoginUtilsImpl::PrepareProfile(
     const std::string& username,
+    const std::string& display_email,
     const std::string& password,
     const GaiaAuthConsumer::ClientLoginResult& credentials,
     bool pending_requests,
     bool using_oauth,
     bool has_cookies,
     LoginUtils::Delegate* delegate) {
   BootTimesLoader* btl = BootTimesLoader::Get();
 
   VLOG(1) << "Completing login for " << username;
 
   btl->AddLoginTimeMarker("StartSession-Start", false);
   DBusThreadManager::Get()->GetSessionManagerClient()->StartSession(
       username);
   btl->AddLoginTimeMarker("StartSession-End", false);
 
   btl->AddLoginTimeMarker("UserLoggedIn-Start", false);
-  UserManager::Get()->UserLoggedIn(username);
+  UserManager* user_manager = UserManager::Get();
+  user_manager->UserLoggedIn(username);
   btl->AddLoginTimeMarker("UserLoggedIn-End", false);
 
   // Switch log file as soon as possible.
   logging::RedirectChromeLogging(*(CommandLine::ForCurrentProcess()));
 
-  username_ = username;
+  // Update user's displayed email.
+  if (!display_email.empty())
+    user_manager->SaveUserDisplayEmail(username, display_email, true);
+
   password_ = password;
 
   credentials_ = credentials;
   pending_requests_ = pending_requests;
   using_oauth_ = using_oauth;
   has_cookies_ = has_cookies;
   delegate_ = delegate;
 
   policy::BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
@@ skipping 149 matching lines @@
 void LoginUtilsImpl::StartSync(
     Profile* user_profile,
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
   TokenService* token_service = user_profile->GetTokenService();
   static bool initialized = false;
   if (!initialized) {
     initialized = true;
 
     // Set the CrOS user by getting this constructor run with the
     // user's email on first retrieval.
+    std::string email = UserManager::Get()->logged_in_user().display_email();
     // TODO(tim): Tidy this up once cros_user is gone (part of bug 93922).
-    user_profile->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
-                                        username_);
-    user_profile->GetProfileSyncService(username_)->SetPassphrase(
-        password_, false);
-    username_ = "";
+    user_profile->GetPrefs()->SetString(prefs::kGoogleServicesUsername, email);
+    user_profile->GetProfileSyncService(email)->SetPassphrase(password_, false);

[Nikita (slow), 2011/12/05 13:13:04]

Please double check how email is used in Sync service and that it's not passed
to Sync servers.

[Ivan Korotkov, 2011/12/05 14:12:48]

As discussed offline, removed from this CL.

     password_ = "";
 
     token_service->Initialize(GaiaConstants::kChromeOSSource, user_profile);
     token_service->LoadTokensFromDB();
   }
   token_service->UpdateCredentials(credentials);
   if (token_service->AreCredentialsValid())
     token_service->StartFetchingTokens();
 }
 
@@ skipping 202 matching lines @@
     const int kConnectionsNeeded = 1;
     chrome_browser_net::PreconnectOnUIThread(
         GURL(GaiaUrls::GetInstance()->client_login_url()),
         chrome_browser_net::UrlInfo::EARLY_LOAD_MOTIVATED,
         kConnectionsNeeded);
   } else {
     new WarmingObserver();
   }
 }
 
-void LoginUtilsImpl::RestoreAuthenticationSession(const std::string& username,
-                                                  Profile* user_profile) {
-  username_ = username;
+void LoginUtilsImpl::RestoreAuthenticationSession(Profile* user_profile) {
   KickStartAuthentication(user_profile);
 }
 
 void LoginUtilsImpl::KickStartAuthentication(Profile* user_profile) {
   if (!authenticator_.get())
     CreateAuthenticator(NULL);
   std::string oauth1_token;
   std::string oauth1_secret;
   if (ReadOAuth1AccessToken(user_profile, &oauth1_token, &oauth1_secret))
     VerifyOAuth1AccessToken(user_profile, oauth1_token, oauth1_secret);
@@ skipping 60 matching lines @@
                                           const std::string& secret) {
   FetchPolicyToken(offrecord_profile, token, secret);
   // TODO(rickcam, zelidrag): Wire TokenService there when it becomes
   // capable of handling OAuth1 tokens directly.
 }
 
 bool LoginUtilsImpl::ReadOAuth1AccessToken(Profile* user_profile,
                                            std::string* token,
                                            std::string* secret) {
   // Skip reading oauth token if user does not have a valid status.
-  if (UserManager::Get()->GetUserOAuthStatus(username_) !=
+  if (UserManager::Get()->logged_in_user().oauth_token_status() !=
       User::OAUTH_TOKEN_STATUS_VALID) {
     return false;
   }
 
   PrefService* pref_service = user_profile->GetPrefs();
   std::string encoded_token = pref_service->GetString(prefs::kOAuth1Token);
   std::string encoded_secret = pref_service->GetString(prefs::kOAuth1Secret);
   if (!encoded_token.length() || !encoded_secret.length())
     return false;
 
@@ skipping 13 matching lines @@
                                             const std::string& secret) {
   // First store OAuth1 token + service for the current user profile...
   PrefService* pref_service = user_profile->GetPrefs();
   pref_service->SetString(prefs::kOAuth1Token,
                           authenticator_->EncryptToken(token));
   pref_service->SetString(prefs::kOAuth1Secret,
                           authenticator_->EncryptToken(secret));
 
   // ...then record the presence of valid OAuth token for this account in local
   // state as well.
-  UserManager::Get()->SaveUserOAuthStatus(username_,
-                                          User::OAUTH_TOKEN_STATUS_VALID);
+  UserManager::Get()->SaveUserOAuthStatus(
+      UserManager::Get()->logged_in_user().email(),
+      User::OAUTH_TOKEN_STATUS_VALID);
 }
 
 void LoginUtilsImpl::VerifyOAuth1AccessToken(Profile* user_profile,
                                              const std::string& token,
                                              const std::string& secret) {
   // Kick off verification of OAuth1 access token (via OAuthLogin), this should
   // let us fetch credentials that will be used to initialize sync engine.
   FetchCredentials(user_profile, token, secret);
 
   FetchSecondaryTokens(user_profile->GetOffTheRecordProfile(), token, secret);
 }
 
 void LoginUtilsImpl::FetchCredentials(Profile* user_profile,
                                       const std::string& token,
                                       const std::string& secret) {
-  oauth_login_verifier_.reset(new OAuthLoginVerifier(this,
-                                                     user_profile,
-                                                     token,
-                                                     secret,
-                                                     username_));
+  oauth_login_verifier_.reset(new OAuthLoginVerifier(
+      this, user_profile, token, secret,
+      UserManager::Get()->logged_in_user().email()));
   oauth_login_verifier_->StartOAuthVerification();
 }
 
 
 void LoginUtilsImpl::FetchPolicyToken(Profile* offrecord_profile,
                                       const std::string& token,
                                       const std::string& secret) {
   // Fetch dm service token now, if it hasn't been fetched yet.
   if (!policy_oauth_fetcher_.get() || policy_oauth_fetcher_->failed()) {
     // Trigger oauth token fetch for user policy.
@@ skipping 71 matching lines @@
   // Mark login host for deletion after browser starts.  This
   // guarantees that the message loop will be referenced by the
   // browser before it is dereferenced by the login host.
   if (login_host) {
     login_host->OnSessionStart();
     login_host = NULL;
   }
 }
 
 }  // namespace chromeos