Don't overwrite email with lowercase value from GetUserInfo()....

chrome/browser/sync/engine/auth_watcher.cc

 // Copyright (c) 2006-2009 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/sync/engine/auth_watcher.h"
 
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/authenticator.h"
@@ skipping 90 matching lines @@
       &AuthWatcher::DoAuthenticateWithToken, gaia_email, auth_token));
 }
 
 void AuthWatcher::DoAuthenticateWithToken(const std::string& gaia_email,
                                           const std::string& auth_token) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
 
   Authenticator auth(scm_, user_settings_);
   Authenticator::AuthenticationResult result =
       auth.AuthenticateToken(auth_token);
-  string email = gaia_email;
-  if (auth.display_email() && *auth.display_email()) {
-    email = auth.display_email();
-    LOG(INFO) << "Auth returned email " << email << " for gaia email " <<
-        gaia_email;
-  }
   AuthWatcherEvent event = {AuthWatcherEvent::ILLEGAL_VALUE , 0};
-  gaia_->SetUsername(email);
+  gaia_->SetUsername(gaia_email);
   gaia_->SetAuthToken(auth_token, SAVE_IN_MEMORY_ONLY);
   const bool was_authenticated = NOT_AUTHENTICATED != status_;
   switch (result) {
     case Authenticator::SUCCESS:
       {
         status_ = GAIA_AUTHENTICATED;
         PathString share_name;
-        CHECK(AppendUTF8ToPathString(email.data(), email.size(), &share_name));
-        user_settings_->SwitchUser(email);
+        CHECK(AppendUTF8ToPathString(gaia_email.data(), gaia_email.size(),
+                                     &share_name));
+        user_settings_->SwitchUser(gaia_email);
 
         // Set the authentication token for notifications
-        talk_mediator_->SetAuthToken(email, auth_token);
+        talk_mediator_->SetAuthToken(gaia_email, auth_token);
         scm_->set_auth_token(auth_token);
 
         if (!was_authenticated)
           LoadDirectoryListAndOpen(share_name);
-        NotifyAuthSucceeded(email);
+        NotifyAuthSucceeded(gaia_email);
         return;
       }
   case Authenticator::BAD_AUTH_TOKEN:
     event.what_happened = AuthWatcherEvent::SERVICE_AUTH_FAILED;
     break;
   case Authenticator::CORRUPT_SERVER_RESPONSE:
   case Authenticator::SERVICE_DOWN:
     event.what_happened = AuthWatcherEvent::SERVICE_CONNECTION_FAILED;
     break;
   case Authenticator::USER_NOT_ACTIVATED:
     event.what_happened = AuthWatcherEvent::SERVICE_USER_NOT_SIGNED_UP;
     break;
   default:
     LOG(FATAL) << "Illegal return from AuthenticateToken";
     return;
   }
   // Always fall back to local authentication.
-  if (was_authenticated || AuthenticateLocally(email)) {
+  if (was_authenticated || AuthenticateLocally(gaia_email)) {
     if (AuthWatcherEvent::SERVICE_CONNECTION_FAILED == event.what_happened)
       return;
   }
   DCHECK_NE(event.what_happened, AuthWatcherEvent::ILLEGAL_VALUE);
   NotifyListeners(&event);
 }
 
 bool AuthWatcher::AuthenticateLocally(string email) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
   user_settings_->GetEmailForSignin(&email);
@@ skipping 165 matching lines @@
 string AuthWatcher::email() const {
   return gaia_->email();
 }
 
 void AuthWatcher::NotifyListeners(AuthWatcherEvent* event) {
   event->trigger = current_attempt_trigger_;
   channel_->NotifyListeners(*event);
 }
 
 }  // namespace browser_sync