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

chrome/browser/invalidation/ticl_invalidation_service.cc

 // Copyright (c) 2013 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/invalidation/ticl_invalidation_service.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/invalidation_service_util.h"
@@ skipping 38 matching lines @@
   -1,
 
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 namespace invalidation {
 
 TiclInvalidationService::TiclInvalidationService(
     SigninManagerBase* signin,
-    TokenService* token_service,
-    OAuth2TokenService* oauth2_token_service,
+    ProfileOAuth2TokenService* oauth2_token_service,
     Profile* profile)
     : profile_(profile),
       signin_manager_(signin),
-      token_service_(token_service),
       oauth2_token_service_(oauth2_token_service),
       invalidator_registrar_(new syncer::InvalidatorRegistrar()),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy) {
 }
 
 TiclInvalidationService::~TiclInvalidationService() {
   DCHECK(CalledOnValidThread());
 }
 
 void TiclInvalidationService::Init() {
   DCHECK(CalledOnValidThread());
 
   invalidator_storage_.reset(new InvalidatorStorage(profile_->GetPrefs()));
   if (invalidator_storage_->GetInvalidatorClientId().empty()) {
     // This also clears any existing state.  We can't reuse old invalidator
     // state with the new ID anyway.
     invalidator_storage_->SetInvalidatorClientId(GenerateInvalidatorClientId());
   }
 
   if (IsReadyToStart()) {
     StartInvalidator();
   }
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_GOOGLE_SIGNED_OUT,
                               content::Source<Profile>(profile_));
-  notification_registrar_.Add(this,
-                              chrome::NOTIFICATION_TOKEN_AVAILABLE,
-                              content::Source<TokenService>(token_service_));
-  notification_registrar_.Add(this,
-                              chrome::NOTIFICATION_TOKENS_CLEARED,
-                              content::Source<TokenService>(token_service_));
+  oauth2_token_service_->AddObserver(this);
 }
 
 void TiclInvalidationService::InitForTest(syncer::Invalidator* invalidator) {
   // Here we perform the equivalent of Init() and StartInvalidator(), but with
   // some minor changes to account for the fact that we're injecting the
   // invalidator.
   invalidator_.reset(invalidator);
 
   invalidator_->RegisterHandler(this);
   invalidator_->UpdateRegisteredIds(
@@ skipping 57 matching lines @@
 std::string TiclInvalidationService::GetInvalidatorClientId() const {
   DCHECK(CalledOnValidThread());
   return invalidator_storage_->GetInvalidatorClientId();
 }
 
 void TiclInvalidationService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(CalledOnValidThread());
-
-  switch (type) {
-    case chrome::NOTIFICATION_TOKEN_AVAILABLE: {
-      if (!IsStarted() && IsReadyToStart()) {
-        StartInvalidator();
-      }
-      break;
-    }
-    case chrome::NOTIFICATION_TOKENS_CLEARED: {
-      access_token_.clear();
-      if (IsStarted()) {
-        UpdateInvalidatorCredentials();
-      }
-      break;
-    }
-    case chrome::NOTIFICATION_GOOGLE_SIGNED_OUT: {
-      Logout();
-      break;
-    }
-    default: {
-      NOTREACHED();
-    }
-  }
+  DCHECK_EQ(type, chrome::NOTIFICATION_GOOGLE_SIGNED_OUT);
+  Logout();
 }
 
 void TiclInvalidationService::RequestAccessToken() {
   // Only one active request at a time.
   if (access_token_request_ != NULL)
     return;
   request_access_token_retry_timer_.Stop();
   OAuth2TokenService::ScopeSet oauth2_scopes;
   for (size_t i = 0; i < arraysize(kOAuth2Scopes); i++)
     oauth2_scopes.insert(kOAuth2Scopes[i]);
   // Invalidate previous token, otherwise token service will return the same
   // token again.
-  oauth2_token_service_->InvalidateToken(oauth2_scopes, access_token_);
+  const std::string& account_id = oauth2_token_service_->GetPrimaryAccountId();
+  oauth2_token_service_->InvalidateToken(account_id,
+                                         oauth2_scopes,
+                                         access_token_);
   access_token_.clear();
-  access_token_request_ =
-      oauth2_token_service_->StartRequest(oauth2_scopes, this);
+  access_token_request_ = oauth2_token_service_->StartRequest(account_id,
+                                                              oauth2_scopes,
+                                                              this);
 }
 
 void TiclInvalidationService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(access_token_request_, request);
   access_token_request_.reset();
   // Reset backoff time after successful response.
   request_access_token_backoff_.Reset();
@@ skipping 45 matching lines @@
       invalidator_registrar_->UpdateInvalidatorState(
           syncer::INVALIDATION_CREDENTIALS_REJECTED);
       break;
     }
     default: {
       // We have no way to notify the user of this.  Do nothing.
     }
   }
 }
 
+void TiclInvalidationService::OnRefreshTokenAvailable(
+    const std::string& account_id) {
+  if (oauth2_token_service_->GetPrimaryAccountId() == account_id) {
+    if (!IsStarted() && IsReadyToStart()) {
+      StartInvalidator();
+    }
+  }
+}
+
+void TiclInvalidationService::OnRefreshTokenRevoked(
+    const std::string& account_id) {
+  if (oauth2_token_service_->GetPrimaryAccountId() == account_id) {
+    access_token_.clear();
+    if (IsStarted()) {
+      UpdateInvalidatorCredentials();
+    }
+  }
+}
+
 void TiclInvalidationService::OnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   if (state == syncer::INVALIDATION_CREDENTIALS_REJECTED) {
     // This may be due to normal OAuth access token expiration.  If so, we must
     // fetch a new one using our refresh token.  Resetting the invalidator's
     // access token will not reset the invalidator's exponential backoff, so
     // it's safe to try to update the token every time we receive this signal.
     //
     // We won't be receiving any invalidations while the refresh is in progress,
     // we set our state to TRANSIENT_INVALIDATION_ERROR.  If the credentials
     // really are invalid, the refresh request should fail and
     // OnGetTokenFailure() will put us into a INVALIDATION_CREDENTIALS_REJECTED
     // state.
     invalidator_registrar_->UpdateInvalidatorState(
         syncer::TRANSIENT_INVALIDATION_ERROR);
     RequestAccessToken();
   } else {
     invalidator_registrar_->UpdateInvalidatorState(state);
   }
 }
 
 void TiclInvalidationService::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
   invalidator_registrar_->DispatchInvalidationsToHandlers(invalidation_map);
 }
 
 void TiclInvalidationService::Shutdown() {
   DCHECK(CalledOnValidThread());
+  oauth2_token_service_->RemoveObserver(this);
   if (IsStarted()) {
     StopInvalidator();
   }
   invalidator_storage_.reset();
   invalidator_registrar_.reset();
 }
 
 bool TiclInvalidationService::IsReadyToStart() {
   if (profile_->IsManaged()) {
     DVLOG(2) << "Not starting TiclInvalidationService: User is managed.";
     return false;
   }
 
   if (signin_manager_->GetAuthenticatedUsername().empty()) {
     DVLOG(2) << "Not starting TiclInvalidationService: User is not signed in.";
     return false;
   }
 
   if (!oauth2_token_service_) {
     DVLOG(2)
         << "Not starting TiclInvalidationService: TokenService unavailable.";
     return false;
   }
 
-  if (!oauth2_token_service_->RefreshTokenIsAvailable()) {
+  if (!oauth2_token_service_->RefreshTokenIsAvailable(
+          oauth2_token_service_->GetPrimaryAccountId())) {
     DVLOG(2)
         << "Not starting TiclInvalidationServce: Waiting for refresh token.";
     return false;
   }
 
   return true;
 }
 
 bool TiclInvalidationService::IsStarted() {
   return invalidator_.get() != NULL;
@@ skipping 58 matching lines @@
   }
 
   // This service always expects to have a valid invalidator storage.
   // So we must not only clear the old one, but also start a new one.
   invalidator_storage_->Clear();
   invalidator_storage_.reset(new InvalidatorStorage(profile_->GetPrefs()));
   invalidator_storage_->SetInvalidatorClientId(GenerateInvalidatorClientId());
 }
 
 }  // namespace invalidation