Refactor OAuth2TokenService to have profile- and device-based implementations.

chrome/browser/signin/oauth2_token_service.cc

 // Copyright 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/signin/oauth2_token_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "base/timer.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/signin/oauth2_token_service_factory.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/common/chrome_notification_types.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
-#include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_access_token_consumer.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
+#include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 // Maximum number of retries in fetching an OAuth2 access token.
 const int kMaxFetchRetryNum = 5;
 
 // Returns an exponential backoff in milliseconds including randomness less than
 // 1000 ms when retrying fetching an OAuth2 access token.
 int64 ComputeExponentialBackOffMilliseconds(int retry_num) {
   DCHECK(retry_num < kMaxFetchRetryNum);
@@ skipping 33 matching lines @@
 OAuth2TokenService::RequestImpl::~RequestImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 void OAuth2TokenService::RequestImpl::InformConsumer(
     const GoogleServiceAuthError& error,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (error.state() == GoogleServiceAuthError::NONE)
-    consumer_-> OnGetTokenSuccess(this, access_token, expiration_date);
+    consumer_->OnGetTokenSuccess(this, access_token, expiration_date);
   else
-    consumer_-> OnGetTokenFailure(this, error);
+    consumer_->OnGetTokenFailure(this, error);
 }
 
 // Class that fetches OAuth2 access tokens for given scopes and refresh token.
 //
 // 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
@@ skipping 13 matching lines @@
 // deleted
 // - when the Fetcher completes fetching, if the Fetcher is not destructed
 //   before it completes fetching, or
 // - when the Fetcher is destructed if the Fetcher is destructed before it
 //   completes fetching (in this case, the waiting requests will be called back
 //   with error).
 class OAuth2TokenService::Fetcher : public OAuth2AccessTokenConsumer {
  public:
   // Creates a Fetcher and starts fetching an OAuth2 access token for
   // |refresh_token| and |scopes| in the request context obtained by |getter|.
-  // |profile|'s OAuth2TokenService will be informed when fetching is done.
-  static Fetcher* CreateAndStart(Profile* profile,
+  // The given |oauth2_token_service| will be informed when fetching is done.
+  static Fetcher* CreateAndStart(OAuth2TokenService* oauth2_token_service,
                                  net::URLRequestContextGetter* getter,
                                  const std::string& refresh_token,
                                  const OAuth2TokenService::ScopeSet& scopes,
                                  base::WeakPtr<RequestImpl> waiting_request);
   virtual ~Fetcher();
 
   // Add a request that is waiting for the result of this Fetcher.
   void AddWaitingRequest(base::WeakPtr<RequestImpl> waiting_request);
 
   const OAuth2TokenService::ScopeSet& GetScopeSet() const;
   const std::string& GetRefreshToken() const;
 
   // The error result from this fetcher.
   const GoogleServiceAuthError& error() const { return error_; }
 
  protected:
    // OAuth2AccessTokenConsumer
   virtual void OnGetTokenSuccess(const std::string& access_token,
                                  const base::Time& expiration_date) OVERRIDE;
   virtual void OnGetTokenFailure(const GoogleServiceAuthError& error) OVERRIDE;
 
  private:
-  Fetcher(Profile* profile,
+  Fetcher(OAuth2TokenService* oauth2_token_service,
           net::URLRequestContextGetter* getter,
           const std::string& refresh_token,
           const OAuth2TokenService::ScopeSet& scopes,
           base::WeakPtr<RequestImpl> waiting_request);
   void Start();
   void InformWaitingRequests();
   static bool ShouldRetry(const GoogleServiceAuthError& error);
 
-  Profile* const profile_;
+  // |oauth2_token_service_| remains valid for the life of this Fetcher, since
+  // this Fetcher is destructed in the dtor of the OAuth2TokenService or is
+  // scheduled for deletion at the end of OnGetTokenFailure/OnGetTokenSuccess
+  // (whichever comes first).
+  OAuth2TokenService* const oauth2_token_service_;
   scoped_refptr<net::URLRequestContextGetter> getter_;
   const std::string refresh_token_;
   const OAuth2TokenService::ScopeSet scopes_;
   std::vector<base::WeakPtr<RequestImpl> > waiting_requests_;
 
   int retry_number_;
   base::OneShotTimer<OAuth2TokenService::Fetcher> retry_timer_;
   scoped_ptr<OAuth2AccessTokenFetcher> fetcher_;
 
   // Variables that store fetch results.
   // Initialized to be GoogleServiceAuthError::SERVICE_UNAVAILABLE to handle
   // destruction.
   GoogleServiceAuthError error_;
   std::string access_token_;
   base::Time expiration_date_;
 
   DISALLOW_COPY_AND_ASSIGN(Fetcher);
 };
 
 // static
 OAuth2TokenService::Fetcher* OAuth2TokenService::Fetcher::CreateAndStart(
-    Profile* profile,
+    OAuth2TokenService* oauth2_token_service,
     net::URLRequestContextGetter* getter,
     const std::string& refresh_token,
     const OAuth2TokenService::ScopeSet& scopes,
     base::WeakPtr<RequestImpl> waiting_request) {
   OAuth2TokenService::Fetcher* fetcher = new Fetcher(
-      profile, getter, refresh_token, scopes, waiting_request);
+      oauth2_token_service, getter, refresh_token, scopes, waiting_request);
   fetcher->Start();
   return fetcher;
 }
 
 OAuth2TokenService::Fetcher::Fetcher(
-    Profile* profile,
+    OAuth2TokenService* oauth2_token_service,
     net::URLRequestContextGetter* getter,
     const std::string& refresh_token,
     const OAuth2TokenService::ScopeSet& scopes,
     base::WeakPtr<RequestImpl> waiting_request)
-    : profile_(profile),
+    : oauth2_token_service_(oauth2_token_service),
       getter_(getter),
       refresh_token_(refresh_token),
       scopes_(scopes),
       retry_number_(0),
       error_(GoogleServiceAuthError::SERVICE_UNAVAILABLE) {
-  DCHECK(profile_);
+  DCHECK(oauth2_token_service_);
   DCHECK(getter_);
   DCHECK(refresh_token_.length());
   waiting_requests_.push_back(waiting_request);
 }
 
 OAuth2TokenService::Fetcher::~Fetcher() {
   // Inform the waiting requests if it has not done so.
   if (waiting_requests_.size())
     InformWaitingRequests();
 }
 
 void OAuth2TokenService::Fetcher::Start() {
   fetcher_.reset(new OAuth2AccessTokenFetcher(this, getter_));
   fetcher_->Start(GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
                   GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
                   refresh_token_,
                   std::vector<std::string>(scopes_.begin(), scopes_.end()));
   retry_timer_.Stop();
 }
 
 void OAuth2TokenService::Fetcher::OnGetTokenSuccess(
     const std::string& access_token,
     const base::Time& expiration_date) {
   fetcher_.reset();
 
   // Fetch completes.
-  error_ = GoogleServiceAuthError(GoogleServiceAuthError::NONE);
+  error_ = GoogleServiceAuthError::AuthErrorNone();
   access_token_ = access_token;
   expiration_date_ = expiration_date;
 
-  // |oauth2_token_service| should not be NULL as this Fetcher is destructed in
-  // the dtor of the OAuth2TokenService that creates it if it is not scheduled
-  // to be destructed here and in OnGetTokenFailure().
-  OAuth2TokenService* oauth2_token_service =
-      OAuth2TokenServiceFactory::GetForProfile(profile_);
-  DCHECK(oauth2_token_service);
-
-  oauth2_token_service->RegisterCacheEntry(refresh_token_,
-                                           scopes_,
-                                           access_token_,
-                                           expiration_date_);
+  // Subclasses may override this method to skip caching in some cases, but
+  // we still inform all waiting Consumers of a successful token fetch below.
+  // This is intentional -- some consumers may need the token for cleanup
+  // tasks. https://chromiumcodereview.appspot.com/11312124/

[Mattias Nissler (ping if slow), 2013/03/26 12:04:32]

nit: Can we rather put the commit revision / bug number as a reference here as
the more canonical identifier for a bug / code change?

[David Roche, 2013/03/27 05:09:51]

I linked the code review because the comments there have an extensive discussion
of this issue.  Linking to the commit revision would be missing this info and
therefore be much harder to understand.  There was no bug associated with this
code review.

+  oauth2_token_service_->RegisterCacheEntry(refresh_token_,
+                                            scopes_,
+                                            access_token_,
+                                            expiration_date_);
   // Deregisters itself from the service to prevent more waiting requests to
   // be added when it calls back the waiting requests.
-  oauth2_token_service->OnFetchComplete(this);
+  oauth2_token_service_->OnFetchComplete(this);
   InformWaitingRequests();
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void OAuth2TokenService::Fetcher::OnGetTokenFailure(
     const GoogleServiceAuthError& error) {
   fetcher_.reset();
 
   if (ShouldRetry(error) && retry_number_ < kMaxFetchRetryNum) {
     int64 backoff = ComputeExponentialBackOffMilliseconds(retry_number_);
     ++retry_number_;
     retry_timer_.Stop();
     retry_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromMilliseconds(backoff),
                        this,
                        &OAuth2TokenService::Fetcher::Start);
     return;
   }
 
   // Fetch completes.
   error_ = error;
 
-  // |oauth2_token_service| should not be NULL as this Fetcher is destructed in
-  // the dtor of the OAuth2TokenService that creates it if it is not scheduled
-  // to be destructed here and in OnGetTokenSuccess().
-  OAuth2TokenService* oauth2_token_service =
-      OAuth2TokenServiceFactory::GetForProfile(profile_);
-  DCHECK(oauth2_token_service);
   // Deregisters itself from the service to prevent more waiting requests to be
   // added when it calls back the waiting requests.
-  oauth2_token_service->OnFetchComplete(this);
+  oauth2_token_service_->OnFetchComplete(this);
   InformWaitingRequests();
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 // static
 bool OAuth2TokenService::Fetcher::ShouldRetry(
     const GoogleServiceAuthError& error) {
   GoogleServiceAuthError::State error_state = error.state();
   return error_state == GoogleServiceAuthError::CONNECTION_FAILED ||
          error_state == GoogleServiceAuthError::REQUEST_CANCELED ||
@@ skipping 30 matching lines @@
 
 OAuth2TokenService::Request::~Request() {
 }
 
 OAuth2TokenService::Consumer::Consumer() {
 }
 
 OAuth2TokenService::Consumer::~Consumer() {
 }
 
-OAuth2TokenService::OAuth2TokenService()
-    : profile_(NULL),
-      last_auth_error_(GoogleServiceAuthError::NONE) {
+OAuth2TokenService::OAuth2TokenService(net::URLRequestContextGetter* getter)
+  : request_context_getter_(getter) {

[Mattias Nissler (ping if slow), 2013/03/26 12:04:32]

nit: 4 space indentation

[David Roche, 2013/03/27 05:09:51]

Done.

 }
 
 OAuth2TokenService::~OAuth2TokenService() {
   // Release all the pending fetchers.
   STLDeleteContainerPairSecondPointers(
       pending_fetchers_.begin(), pending_fetchers_.end());
 }
 
-void OAuth2TokenService::Initialize(Profile* profile) {
+bool OAuth2TokenService::RefreshTokenIsAvailable() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  DCHECK(profile);
-  DCHECK(!profile_);
-  profile_ = profile;
-  getter_ = profile->GetRequestContext();
-  content::Source<TokenService> token_service_source(
-      TokenServiceFactory::GetForProfile(profile));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_TOKENS_CLEARED,
-                 token_service_source);
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_TOKEN_AVAILABLE,
-                 token_service_source);
-  SigninManagerFactory::GetForProfile(profile_)->signin_global_error()->
-      AddProvider(this);
+  return !GetRefreshToken().empty();
 }
 
-void OAuth2TokenService::Shutdown() {
-  if (profile_) {
-    SigninManagerFactory::GetForProfile(profile_)->signin_global_error()->
-        RemoveProvider(this);
-  }
-}
-
-
 // static
 void OAuth2TokenService::InformConsumer(
     base::WeakPtr<OAuth2TokenService::RequestImpl> request,
     GoogleServiceAuthError error,
     std::string access_token,
     base::Time expiration_date) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (request)
     request->InformConsumer(error, access_token, expiration_date);
 }
 
 scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<RequestImpl> request(new RequestImpl(consumer));
 
-  TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
-  if (!token_service || !token_service->HasOAuthLoginToken()) {
+  std::string refresh_token = GetRefreshToken();
+  if (refresh_token.empty()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &OAuth2TokenService::InformConsumer,
         request->AsWeakPtr(),
-        GoogleServiceAuthError(GoogleServiceAuthError::USER_NOT_SIGNED_UP),
+        GoogleServiceAuthError(
+            GoogleServiceAuthError::USER_NOT_SIGNED_UP),
         std::string(),
         base::Time()));
     return request.PassAs<Request>();
   }
 
   const CacheEntry* cache_entry = GetCacheEntry(scopes);
   if (cache_entry && cache_entry->access_token.length()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &OAuth2TokenService::InformConsumer,
         request->AsWeakPtr(),
         GoogleServiceAuthError(GoogleServiceAuthError::NONE),
         cache_entry->access_token,
         cache_entry->expiration_date));
     return request.PassAs<Request>();
   }
 
-  std::string refresh_token = token_service->GetOAuth2LoginRefreshToken();
-  if (!refresh_token.length()) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &OAuth2TokenService::InformConsumer,
-        request->AsWeakPtr(),
-        GoogleServiceAuthError(
-            GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS),
-        std::string(),
-        base::Time()));
-    return request.PassAs<Request>();
-  }
-
   // Makes sure there is a pending fetcher for |scopes| and |refresh_token|.
   // Adds |request| to the waiting request list of this fetcher so |request|
   // will be called back when this fetcher finishes fetching.
   FetchParameters fetch_parameters = std::make_pair(refresh_token, scopes);
   std::map<FetchParameters, Fetcher*>::iterator iter =
       pending_fetchers_.find(fetch_parameters);
   if (iter != pending_fetchers_.end()) {
     iter->second->AddWaitingRequest(request->AsWeakPtr());
     return request.PassAs<Request>();
   }
   pending_fetchers_[fetch_parameters] = Fetcher::CreateAndStart(
-      profile_, getter_, refresh_token, scopes, request->AsWeakPtr());
+      this, request_context_getter_, refresh_token, scopes,
+      request->AsWeakPtr());
   return request.PassAs<Request>();
 }
 
 void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Update the auth error state so auth errors are appropriately communicated
   // to the user.
   UpdateAuthError(fetcher->error());
 
   // Note |fetcher| is recorded in |pending_fetcher_| mapped to its refresh
   // token and scope set. This is guaranteed as follows; here a Fetcher is said
   // to be uncompleted if it has not finished calling back
   // OAuth2TokenService::OnFetchComplete().
   //
   // (1) All the live Fetchers are created by this service.
   //     This is because (1) all the live Fetchers are created by a live
   //     service, as all the fetchers created by a service are destructed in the
-  //     service's dtor, and (2) there is at most one live OAuth2TokenSevice for
-  //     a given profile at a time.
+  //     service's dtor.
   //
   // (2) All the uncompleted Fetchers created by this service are recorded in
   //     |pending_fetchers_|.
   //     This is because (1) all the created Fetchers are added to
   //     |pending_fetchers_| (in method StartRequest()) and (2) method
   //     OnFetchComplete() is the only place where a Fetcher is erased from
   //     |pending_fetchers_|. Note no Fetcher is erased in method
   //     StartRequest().
   //
   // (3) Each of the Fetchers recorded in |pending_fetchers_| is mapped to its
   //     refresh token and ScopeSet. This is guaranteed by Fetcher creation in
-  //     method StartReuest().
+  //     method StartRequest().
   //
   // When this method is called, |fetcher| is alive and uncompleted.
   // By (1), |fetcher| is created by this service.
   // Then by (2), |fetcher| is recorded in |pending_fetchers_|.
   // Then by (3), |fetcher_| is mapped to its refresh token and ScopeSet.
   std::map<FetchParameters, Fetcher*>::iterator iter =
     pending_fetchers_.find(std::make_pair(
         fetcher->GetRefreshToken(), fetcher->GetScopeSet()));
   DCHECK(iter != pending_fetchers_.end());
   DCHECK_EQ(fetcher, iter->second);
@@ skipping 13 matching lines @@
   return &token_iterator->second;
 }
 
 void OAuth2TokenService::RegisterCacheEntry(
     const std::string& refresh_token,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  // Only register OAuth2 access tokens for the refresh token held by
-  // TokenService.
-  TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
-  if (!token_service ||
-      !token_service->HasOAuthLoginToken() ||
-      token_service->GetOAuth2LoginRefreshToken().compare(refresh_token) != 0) {
-    DLOG(INFO) <<
-        "Received a token with a refresh token not maintained by TokenService.";
-    return;
-  }
-
   CacheEntry& token = token_cache_[scopes];
   token.access_token = access_token;
   token.expiration_date = expiration_date;
 }
 
-void OAuth2TokenService::Observe(int type,
-                                 const content::NotificationSource& source,
-                                 const content::NotificationDetails& details) {
-  DCHECK(type == chrome::NOTIFICATION_TOKENS_CLEARED ||
-         type == chrome::NOTIFICATION_TOKEN_AVAILABLE);
-  if (type == chrome::NOTIFICATION_TOKEN_AVAILABLE) {
-    TokenService::TokenAvailableDetails* tok_details =
-        content::Details<TokenService::TokenAvailableDetails>(details).ptr();
-    if (tok_details->service() != GaiaConstants::kGaiaOAuth2LoginRefreshToken)
-      return;
-  }
-  // The GaiaConstants::kGaiaOAuth2LoginRefreshToken token is used to create
-  // OAuth2 access tokens. If this token either changes or is cleared, any
-  // available tokens must be invalidated.
-  token_cache_.clear();
-  UpdateAuthError(GoogleServiceAuthError::AuthErrorNone());
+void OAuth2TokenService::UpdateAuthError(const GoogleServiceAuthError& error) {
+  // Default implementation does nothing.
 }
 
-void OAuth2TokenService::UpdateAuthError(const GoogleServiceAuthError& error) {
-  // Do not report connection errors as these are not actually auth errors.
-  // We also want to avoid masking a "real" auth error just because we
-  // subsequently get a transient network error.
-  if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED)
-    return;
-
-  if (error.state() != last_auth_error_.state()) {
-    last_auth_error_ = error;
-    SigninManagerFactory::GetForProfile(profile_)->signin_global_error()->
-        AuthStatusChanged();
-  }
+void OAuth2TokenService::ClearCache() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  token_cache_.clear();
 }
 
-GoogleServiceAuthError OAuth2TokenService::GetAuthStatus() const {
-  return last_auth_error_;
+int OAuth2TokenService::cache_size_for_testing() const {
+  return token_cache_.size();
 }