Making OAuth2TokenService multi-login aware, updating callers, minor fixes

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2012 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 <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 197 matching lines @@
 bool ProfileSyncService::IsOAuthRefreshTokenAvailable() {
   // Function name doesn't reflect which token is checked. Function checks
   // refresh token when use_oauth2_token_ is true (all platforms except android)
   // and sync token otherwise (for android).
   // TODO(pavely): Remove "else" part once use_oauth2_token_ is gone.
   if (use_oauth2_token_) {
     ProfileOAuth2TokenService* token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
     if (!token_service)
       return false;
-    return token_service->RefreshTokenIsAvailable();
+    return token_service->RefreshTokenIsAvailable(
+        token_service->GetPrimaryAccountId());
   } else {
     TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
     if (!token_service)
       return false;
     return token_service->HasTokenForService(GaiaConstants::kSyncService);
   }
 }
 
 void ProfileSyncService::Initialize() {
   if (profile_)
@@ skipping 455 matching lines @@
     }
     default: {
       // Show error to user.
       UpdateAuthErrorState(error);
     }
   }
 }
 
 void ProfileSyncService::OnRefreshTokenAvailable(
     const std::string& account_id) {
   OnRefreshTokensLoaded();

[Roger Tawa OOO till Jul 10th, 2013/08/29 15:41:40]

Shouldn't this happen only if |account_id| is the primary account id? Or are we
just assuming OnRefreshTokensLoaded() will fail if the primary is not available
yet?

[fgorski, 2013/08/29 23:04:14]

Done.

 }
 
 void ProfileSyncService::OnRefreshTokenRevoked(
     const std::string& account_id) {
   if (!IsOAuthRefreshTokenAvailable()) {
+    access_token_.clear();
     // The additional check around IsOAuthRefreshTokenAvailable() above
     // prevents us sounding the alarm if we actually have a valid token but
     // a refresh attempt by TokenService failed for any variety of reasons
     // (e.g. flaky network). It's possible the token we do have is also
     // invalid, but in that case we should already have (or can expect) an
     // auth error sent from the sync backend.
     UpdateAuthErrorState(
         GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED));
   }
 }
 
 void ProfileSyncService::OnRefreshTokensLoaded() {
   // This notification gets fired when TokenService loads the tokens
   // from storage.
   // Initialize the backend if sync is enabled. If the sync token was
   // not loaded, GetCredentials() will generate invalid credentials to
   // cause the backend to generate an auth error (crbug.com/121755).
   if (backend_) {
     RequestAccessToken();
   } else {
     TryStart();
   }
 }
 
-void ProfileSyncService::OnRefreshTokensCleared() {
-  access_token_.clear();
-}
-
 void ProfileSyncService::Shutdown() {
   UnregisterAuthNotifications();
 
   if (profile_)
     SigninGlobalError::GetForProfile(profile_)->RemoveProvider(this);
 
   ShutdownImpl(browser_sync::SyncBackendHost::STOP);
 
   if (sync_thread_)
     sync_thread_->Stop();
@@ skipping 1117 matching lines @@
   if (access_token_request_ != NULL)
     return;
   request_access_token_retry_timer_.Stop();
   OAuth2TokenService::ScopeSet oauth2_scopes;
   if (profile_->IsManaged()) {
     oauth2_scopes.insert(GaiaConstants::kChromeSyncManagedOAuth2Scope);
   } else {
     oauth2_scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
   }
 
-  OAuth2TokenService* token_service =
+  ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   // Invalidate previous token, otherwise token service will return the same
   // token again.
   if (!access_token_.empty())
     token_service->InvalidateToken(oauth2_scopes, access_token_);
   access_token_.clear();
-  access_token_request_ = token_service->StartRequest(oauth2_scopes, this);
+  access_token_request_ = token_service->StartRequest(
+      token_service->GetPrimaryAccountId(), oauth2_scopes, this);
 }
 
 void ProfileSyncService::SetEncryptionPassphrase(const std::string& passphrase,
                                                  PassphraseType type) {
   // This should only be called when the backend has been initialized.
   DCHECK(sync_initialized());
   DCHECK(!(type == IMPLICIT && IsUsingSecondaryPassphrase())) <<
       "Data is already encrypted using an explicit passphrase";
   DCHECK(!(type == EXPLICIT &&
            passphrase_required_reason_ == syncer::REASON_DECRYPTION)) <<
@@ skipping 225 matching lines @@
     NOTREACHED();
 #endif
   }
 
   return signin_->GetAuthenticatedUsername();
 }
 
 WeakHandle<syncer::JsEventHandler> ProfileSyncService::GetJsEventHandler() {
   return MakeWeakHandle(sync_js_controller_.AsWeakPtr());
 }