sync: change semantics (and name) of SigninManager::GetUsername

chrome/browser/sync/profile_sync_service.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/sync/profile_sync_service.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <map>
 #include <set>
@@ skipping 147 matching lines @@
   return AreCredentialsAvailable(false);
 }
 
 bool ProfileSyncService::AreCredentialsAvailable(
     bool check_oauth_login_token) {
   if (IsManaged()) {
     return false;
   }
 
   // CrOS user is always logged in. Chrome uses signin_ to check logged in.
-  if (cros_user_.empty() && signin_->GetUsername().empty())
+  if (cros_user_.empty() && signin_->GetAuthenticatedUsername().empty())
     return false;
 
   TokenService* token_service = profile()->GetTokenService();
   if (!token_service)
     return false;
 
   // TODO(chron): Verify CrOS unit test behavior.
   if (!token_service->HasTokenForService(browser_sync::SyncServiceName()))
     return false;
   return !check_oauth_login_token || token_service->HasOAuthLoginToken();
@@ skipping 13 matching lines @@
   if (IsManaged()) {
     DisableForUser();
     return;
   }
 
   RegisterAuthNotifications();
 
   if (!HasSyncSetupCompleted())
     DisableForUser();  // Clean up in case of previous crash / setup abort.
 
-  // In Chrome, we integrate a SigninManager which works with the sync
-  // setup wizard to kick off the TokenService. CrOS does its own plumbing
-  // for the TokenService in login and does not normally rely on signin_,
-  // so only initialize this if the token service has not been initialized
-  // (e.g. the browser crashed or is being debugged).
-  if (cros_user_.empty() ||
-      !profile_->GetTokenService()->Initialized()) {
-    // Will load tokens from DB and broadcast Token events after.
-    // Note: We rely on signin_ != NULL unless !cros_user_.empty().
-    signin_->Initialize(profile_);
-  }
+  signin_->Initialize(profile_);
 
   TryStart();
 }
 
 void ProfileSyncService::TryStart() {
   if (!sync_prefs_.IsStartSuppressed() && AreCredentialsAvailable()) {
     if (HasSyncSetupCompleted() || auto_start_enabled_) {
       // If sync setup has completed we always start the backend.
       // If autostart is enabled, but we haven't completed sync setup, we try to
       // start sync anyway, since it's possible we crashed/shutdown after
@@ skipping 72 matching lines @@
       } else {
         LOG(WARNING) << "The following sync URL specified at the command-line "
                      << "is invalid: " << value;
       }
     }
   }
 }
 
 SyncCredentials ProfileSyncService::GetCredentials() {
   SyncCredentials credentials;
-  credentials.email = cros_user_.empty() ? signin_->GetUsername() : cros_user_;
+  credentials.email = cros_user_.empty() ?
+      signin_->GetAuthenticatedUsername() : cros_user_;
   DCHECK(!credentials.email.empty());
   TokenService* service = profile_->GetTokenService();
   credentials.sync_token = service->GetTokenForService(
       browser_sync::SyncServiceName());
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_.get()) {
     NOTREACHED();
@@ skipping 766 matching lines @@
 
 void ProfileSyncService::OnUserSubmittedAuth(
     const std::string& username, const std::string& password,
     const std::string& captcha, const std::string& access_code) {
   last_attempted_user_email_ = username;
   is_auth_in_progress_ = true;
   NotifyObservers();
 
   auth_start_time_ = base::TimeTicks::Now();
 
-  if (!signin_->IsInitialized()) {
-    // In ChromeOS we sign in during login, so we do not initialize signin_.
-    // If this function gets called, we need to re-authenticate (e.g. for
-    // two factor signin), so initialize signin_ here.
-    signin_->Initialize(profile_);
-  }
-
   if (!access_code.empty()) {
     signin_->ProvideSecondFactorAccessCode(access_code);
     return;
   }
 
-  if (!signin_->GetUsername().empty()) {
-    signin_->ClearInMemoryData();
-  }
-
   // The user has submitted credentials, which indicates they don't
   // want to suppress start up anymore.
   sync_prefs_.SetStartSuppressed(false);
 
   signin_->StartSignIn(username,
                        password,
                        last_auth_error_.captcha().token,
                        captcha);
 }
 
@@ skipping 385 matching lines @@
       // start up sync successfully for already logged in users who may
       // only have chromiumsync token if they logged in before the code
       // to generate oauth login token released.
       if (AreCredentialsAvailable()) {
         // Initialize the backend if sync token was loaded.
         if (backend_initialized_) {
           backend_->UpdateCredentials(GetCredentials());
         }
         if (!sync_prefs_.IsStartSuppressed())
           StartUp();
-      } else if (cros_user_.empty() && !signin_->GetUsername().empty()) {
-        // If not in Chrome OS, and we have a username without tokens,
-        // the user will need to signin again, so sign out.
-        DisableForUser();
+      } else if (cros_user_.empty() &&
+                 !signin_->GetAuthenticatedUsername().empty()) {
+        // If not in auto-start / Chrome OS mode, and we have a username
+        // without tokens, the user will need to signin again. NotifyObservers
+        // to trigger errors in the UI that will allow the user to re-login.

[Andrew T Wilson (Slow), 2011/12/07 00:50:15]

Is this comment referring to NotifyObservers still accurate?

+        UpdateAuthErrorState(GoogleServiceAuthError(
+            GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
       }
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
 
 void ProfileSyncService::AddObserver(Observer* observer) {
@@ skipping 43 matching lines @@
 void ProfileSyncService::StopAndSuppress() {
   sync_prefs_.SetStartSuppressed(true);
   Shutdown(false);
 }
 
 void ProfileSyncService::UnsuppressAndStart() {
   DCHECK(profile_);
   sync_prefs_.SetStartSuppressed(false);
   // Set username in SigninManager, as SigninManager::OnGetUserInfoSuccess
   // is never called for some clients.
-  if (signin_->GetUsername().empty()) {
-    signin_->SetUsername(sync_prefs_.GetGoogleServicesUsername());
+  if (signin_->GetAuthenticatedUsername().empty()) {
+    signin_->SetAuthenticatedUsername(
+        sync_prefs_.GetGoogleServicesUsername());
   }
   TryStart();
 }
 
 void ProfileSyncService::AcknowledgeSyncedTypes() {
   syncable::ModelTypeSet registered_types;
   GetRegisteredDataTypes(&registered_types);
   sync_prefs_.AcknowledgeSyncedTypes(registered_types);
 }
 
@@ skipping 15 matching lines @@
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }