Refactor AO2TS to make it easier to componentize.

google_apis/gaia/oauth2_token_service.cc

 // Copyright 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 "google_apis/gaia/oauth2_token_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher_impl.h"
+#include "google_apis/gaia/oauth2_token_service_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 
 int OAuth2TokenService::max_fetch_retry_num_ = 5;
 
 OAuth2TokenService::RequestParameters::RequestParameters(
     const std::string& client_id,
     const std::string& account_id,
     const ScopeSet& scopes)
     : client_id(client_id),
       account_id(account_id),
@@ skipping 41 matching lines @@
     const GoogleServiceAuthError& error,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(CalledOnValidThread());
   if (error.state() == GoogleServiceAuthError::NONE)
     consumer_->OnGetTokenSuccess(this, access_token, expiration_date);
   else
     consumer_->OnGetTokenFailure(this, error);
 }
 
-OAuth2TokenService::ScopedBatchChange::ScopedBatchChange(
-    OAuth2TokenService* token_service) : token_service_(token_service) {
-  DCHECK(token_service_);
-  token_service_->StartBatchChanges();
-}
-
-OAuth2TokenService::ScopedBatchChange::~ScopedBatchChange() {
-  token_service_->EndBatchChanges();
-}
-
 // Class that fetches an OAuth2 access token for a given account id and set of
 // scopes.
 //
 // It aims to meet OAuth2TokenService's requirements on token fetching. Retry
 // mechanism is used to handle failures.
 //
 // To use this class, call CreateAndStart() to create and start a Fetcher.
 //
 // The Fetcher will call back the service by calling
 // OAuth2TokenService::OnFetchComplete() when it completes fetching, if it is
@@ skipping 283 matching lines @@
 
 OAuth2TokenService::Request::~Request() {
 }
 
 OAuth2TokenService::Consumer::Consumer(const std::string& id)
     : id_(id) {}
 
 OAuth2TokenService::Consumer::~Consumer() {
 }
 
-OAuth2TokenService::OAuth2TokenService() : batch_change_depth_(0) {
+OAuth2TokenService::OAuth2TokenService(OAuth2TokenServiceDelegate* delegate)
+    : delegate_(delegate) {
+  DCHECK(delegate_);
 }
 
 OAuth2TokenService::~OAuth2TokenService() {
   // Release all the pending fetchers.
   STLDeleteContainerPairSecondPointers(
       pending_fetchers_.begin(), pending_fetchers_.end());
 }
 
+OAuth2TokenServiceDelegate* OAuth2TokenService::GetDelegate() {
+  return delegate_.get();
+}
+
 void OAuth2TokenService::AddObserver(Observer* observer) {
-  observer_list_.AddObserver(observer);
+  delegate_->AddObserver(observer);
 }
 
 void OAuth2TokenService::RemoveObserver(Observer* observer) {
-  observer_list_.RemoveObserver(observer);
+  delegate_->RemoveObserver(observer);
 }
 
 void OAuth2TokenService::AddDiagnosticsObserver(DiagnosticsObserver* observer) {
   diagnostics_observer_list_.AddObserver(observer);
 }
 
 void OAuth2TokenService::RemoveDiagnosticsObserver(
     DiagnosticsObserver* observer) {
   diagnostics_observer_list_.RemoveObserver(observer);
 }
 
-std::vector<std::string> OAuth2TokenService::GetAccounts() {
-  return std::vector<std::string>();
-}
-
 scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   return StartRequestForClientWithContext(
       account_id,
       GetRequestContext(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
       scopes,
       consumer);
 }
 
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestForClient(
     const std::string& account_id,
     const std::string& client_id,
     const std::string& client_secret,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   return StartRequestForClientWithContext(
       account_id,
       GetRequestContext(),
       client_id,
       client_secret,
       scopes,
       consumer);
 }
 
+net::URLRequestContextGetter* OAuth2TokenService::GetRequestContext() const {
+  return delegate_->GetRequestContext();
+}
+
 scoped_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestWithContext(
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const ScopeSet& scopes,
     Consumer* consumer) {
   return StartRequestForClientWithContext(
       account_id,
       getter,
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
@@ skipping 10 matching lines @@
     const std::string& client_secret,
     const ScopeSet& scopes,
     Consumer* consumer) {
   DCHECK(CalledOnValidThread());
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 OAuth2TokenService::StartRequestForClientWithContext 1"));
-
   scoped_ptr<RequestImpl> request(new RequestImpl(account_id, consumer));
   FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
                     OnAccessTokenRequested(account_id,
                                            consumer->id(),
                                            scopes));
 
   if (!RefreshTokenIsAvailable(account_id)) {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile2(
@@ skipping 66 matching lines @@
   pending_fetchers_[request_parameters] =
       Fetcher::CreateAndStart(this,
                               account_id,
                               getter,
                               client_id,
                               client_secret,
                               scopes,
                               request->AsWeakPtr());
 }
 
+OAuth2AccessTokenFetcher* OAuth2TokenService::CreateAccessTokenFetcher(
+    const std::string& account_id,
+    net::URLRequestContextGetter* getter,
+    OAuth2AccessTokenConsumer* consumer) {
+  return delegate_->CreateAccessTokenFetcher(account_id, getter, consumer);
+}
+
 void OAuth2TokenService::StartCacheLookupRequest(
     RequestImpl* request,
     const OAuth2TokenService::RequestParameters& request_parameters,
     OAuth2TokenService::Consumer* consumer) {
   CHECK(HasCacheEntry(request_parameters));
   const CacheEntry* cache_entry = GetCacheEntry(request_parameters);
   FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
                     OnFetchAccessTokenComplete(
                         request_parameters.account_id,
                         consumer->id(),
                         request_parameters.scopes,
                         GoogleServiceAuthError::AuthErrorNone(),
                         cache_entry->expiration_date));
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &RequestImpl::InformConsumer,
       request->AsWeakPtr(),
       GoogleServiceAuthError(GoogleServiceAuthError::NONE),
       cache_entry->access_token,
       cache_entry->expiration_date));
 }
 
-void OAuth2TokenService::InvalidateToken(const std::string& account_id,
-                                         const ScopeSet& scopes,
-                                         const std::string& access_token) {
-  InvalidateOAuth2Token(account_id,
-                        GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
-                        scopes,
-                        access_token);
+std::vector<std::string> OAuth2TokenService::GetAccounts() const {
+  return delegate_->GetAccounts();
 }
 
-void OAuth2TokenService::InvalidateTokenForClient(
+bool OAuth2TokenService::RefreshTokenIsAvailable(
+    const std::string& account_id) const {
+  return delegate_->RefreshTokenIsAvailable(account_id);
+}
+
+void OAuth2TokenService::RevokeAllCredentials() {
+  CancelAllRequests();
+  ClearCache();
+  delegate_->RevokeAllCredentials();
+}
+
+void OAuth2TokenService::InvalidateAccessToken(
+    const std::string& account_id,
+    const ScopeSet& scopes,
+    const std::string& access_token) {
+  InvalidateAccessTokenImpl(account_id,
+                            GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
+                            scopes, access_token);
+}
+
+void OAuth2TokenService::InvalidateAccessTokenForClient(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
-  InvalidateOAuth2Token(account_id, client_id, scopes, access_token);
+  InvalidateAccessTokenImpl(account_id, client_id, scopes, access_token);
 }
 
-void OAuth2TokenService::InvalidateOAuth2Token(
+void OAuth2TokenService::InvalidateAccessTokenImpl(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
   DCHECK(CalledOnValidThread());
   RemoveCacheEntry(
       RequestParameters(client_id,
                         account_id,
                         scopes),
       access_token);
+  delegate_->InvalidateAccessToken(account_id, client_id, scopes, access_token);
 }
 
 void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
   DCHECK(CalledOnValidThread());
 
   // Update the auth error state so auth errors are appropriately communicated
   // to the user.
   UpdateAuthError(fetcher->GetAccountId(), fetcher->error());
 
   // Note |fetcher| is recorded in |pending_fetcher_| mapped to its refresh
@@ skipping 74 matching lines @@
   if (token_iterator != token_cache_.end() &&
       token_iterator->second.access_token == token_to_remove) {
     FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
                       OnTokenRemoved(request_parameters.account_id,
                                      request_parameters.scopes));
     token_cache_.erase(token_iterator);
     return true;
   }
   return false;
 }
+void OAuth2TokenService::UpdateAuthError(const std::string& account_id,
+                                         const GoogleServiceAuthError& error) {
+  delegate_->UpdateAuthError(account_id, error);
+}
 
 void OAuth2TokenService::RegisterCacheEntry(
     const std::string& client_id,
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(CalledOnValidThread());
 
   CacheEntry& token = token_cache_[RequestParameters(client_id,
                                                      account_id,
                                                      scopes)];
   token.access_token = access_token;
   token.expiration_date = expiration_date;
 }
 
-void OAuth2TokenService::UpdateAuthError(
-    const std::string& account_id,
-    const GoogleServiceAuthError& error) {
-  // Default implementation does nothing.
-}
-
 void OAuth2TokenService::ClearCache() {
   DCHECK(CalledOnValidThread());
   for (TokenCache::iterator iter = token_cache_.begin();
        iter != token_cache_.end(); ++iter) {
     FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
                       OnTokenRemoved(iter->first.account_id,
                                      iter->first.scopes));
   }
 
   token_cache_.clear();
@@ skipping 41 matching lines @@
 void OAuth2TokenService::CancelFetchers(
     std::vector<Fetcher*> fetchers_to_cancel) {
   for (std::vector<OAuth2TokenService::Fetcher*>::iterator iter =
            fetchers_to_cancel.begin();
        iter != fetchers_to_cancel.end();
        ++iter) {
     (*iter)->Cancel();
   }
 }
 
-void OAuth2TokenService::FireRefreshTokenAvailable(
-    const std::string& account_id) {
-  // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
-  // fixed.
-  tracked_objects::ScopedTracker tracking_profile(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "422460 OAuth2TokenService::FireRefreshTokenAvailable"));
-
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnRefreshTokenAvailable(account_id));
-}
-
-void OAuth2TokenService::FireRefreshTokenRevoked(
-    const std::string& account_id) {
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnRefreshTokenRevoked(account_id));
-}
-
-void OAuth2TokenService::FireRefreshTokensLoaded() {
-  // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
-  // fixed.
-  tracked_objects::ScopedTracker tracking_profile(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "422460 OAuth2TokenService::FireRefreshTokensLoaded"));
-
-  FOR_EACH_OBSERVER(Observer, observer_list_, OnRefreshTokensLoaded());
-}
-
-void OAuth2TokenService::StartBatchChanges() {
-  ++batch_change_depth_;
-  if (batch_change_depth_ == 1)
-    FOR_EACH_OBSERVER(Observer, observer_list_, OnStartBatchChanges());
-}
-
-void OAuth2TokenService::EndBatchChanges() {
-  --batch_change_depth_;
-  DCHECK_LE(0, batch_change_depth_);
-  if (batch_change_depth_ == 0)
-    FOR_EACH_OBSERVER(Observer, observer_list_, OnEndBatchChanges());
-}
-
-int OAuth2TokenService::cache_size_for_testing() const {
-  return token_cache_.size();
-}
-
 void OAuth2TokenService::set_max_authorization_token_fetch_retries_for_testing(
     int max_retries) {
   DCHECK(CalledOnValidThread());
   max_fetch_retry_num_ = max_retries;
 }
 
 size_t OAuth2TokenService::GetNumPendingRequestsForTesting(
     const std::string& client_id,
     const std::string& account_id,
     const ScopeSet& scopes) const {
   PendingFetcherMap::const_iterator iter = pending_fetchers_.find(
       OAuth2TokenService::RequestParameters(
           client_id,
           account_id,
           scopes));
   return iter == pending_fetchers_.end() ?
              0 : iter->second->GetWaitingRequestCount();
 }