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 12 matching lines @@
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/net/chrome_cookie_notification_details.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/about_signin_internals.h"
 #include "chrome/browser/signin/about_signin_internals_factory.h"
+#include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/sync/backend_migrator.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/chrome_encryptor.h"
 #include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/device_info.h"
@@ skipping 97 matching lines @@
   false,
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error) {
   return (error.action != syncer::UNKNOWN_ACTION &&
           error.action != syncer::DISABLE_SYNC_ON_CLIENT &&
           error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT);
 }
 
-ProfileSyncService::ProfileSyncService(ProfileSyncComponentsFactory* factory,
-                                       Profile* profile,
-                                       SigninManagerBase* signin_manager,
-                                       OAuth2TokenService* oauth2_token_service,
-                                       StartBehavior start_behavior)
+ProfileSyncService::ProfileSyncService(
+    ProfileSyncComponentsFactory* factory,
+    Profile* profile,
+    SigninManagerBase* signin_manager,
+    ProfileOAuth2TokenService* oauth2_token_service,
+    StartBehavior start_behavior)
     : last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
       // |profile| may be NULL in unit tests.
       sync_prefs_(profile_ ? profile_->GetPrefs() : NULL),
       sync_service_url_(kDevServerUrl),
       data_type_requested_sync_startup_(false),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
@@ skipping 42 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_) {
     if (!oauth2_token_service_)
       return false;
-    return oauth2_token_service_->RefreshTokenIsAvailable();
+    return oauth2_token_service_->RefreshTokenIsAvailable(
+        oauth2_token_service_->GetPrimaryAccountId());
   } else {
     TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
     if (!token_service)
       return false;
 
     return token_service->HasTokenForService(GaiaConstants::kSyncService);
   }
 }
 
 void ProfileSyncService::Initialize() {
@@ skipping 476 matching lines @@
     }
     default: {
       // Show error to user.
       UpdateAuthErrorState(error);
     }
   }
 }
 
 void ProfileSyncService::OnRefreshTokenAvailable(
     const std::string& account_id) {
-  OnRefreshTokensLoaded();
+  if (oauth2_token_service_->GetPrimaryAccountId() == account_id)
+    OnRefreshTokensLoaded();
 }
 
 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 1137 matching lines @@
   request_access_token_retry_timer_.Stop();
   OAuth2TokenService::ScopeSet oauth2_scopes;
   if (profile_->IsManaged()) {
     oauth2_scopes.insert(GaiaConstants::kChromeSyncManagedOAuth2Scope);
   } else {
     oauth2_scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
   }
 
   // Invalidate previous token, otherwise token service will return the same
   // token again.
-  if (!access_token_.empty())
-    oauth2_token_service_->InvalidateToken(oauth2_scopes, access_token_);
+  const std::string& account_id = oauth2_token_service_->GetPrimaryAccountId();
+  if (!access_token_.empty()) {
+    oauth2_token_service_->InvalidateToken(
+        account_id, oauth2_scopes, access_token_);
+  }
 
   access_token_.clear();
   access_token_request_ =
-      oauth2_token_service_->StartRequest(oauth2_scopes, this);
+      oauth2_token_service_->StartRequest(account_id, 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());
 }