Refactor AO2TS to make it easier to componentize.

google_apis/gaia/oauth2_token_service.h

 // 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.
 
 #ifndef GOOGLE_APIS_GAIA_OAUTH2_TOKEN_SERVICE_H_
 #define GOOGLE_APIS_GAIA_OAUTH2_TOKEN_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.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"
 
 namespace net {
 class URLRequestContextGetter;
 }
 
 class GoogleServiceAuthError;
 class OAuth2AccessTokenFetcher;
+class OAuth2TokenServiceDelegate;
 
 // Abstract base class for a service that fetches and caches OAuth2 access
 // tokens. Concrete subclasses should implement GetRefreshToken to return
 // the appropriate refresh token. Derived services might maintain refresh tokens
 // for multiple accounts.
 //
 // All calls are expected from the UI thread.
 //
 // To use this service, call StartRequest() with a given set of scopes and a
 // consumer of the request results. The consumer is required to outlive the
@@ skipping 83 matching lines @@
     // successful completion.
     virtual void OnFetchAccessTokenComplete(const std::string& account_id,
                                             const std::string& consumer_id,
                                             const ScopeSet& scopes,
                                             GoogleServiceAuthError error,
                                             base::Time expiration_time) = 0;
     virtual void OnTokenRemoved(const std::string& account_id,
                                 const ScopeSet& scopes) = 0;
   };
 
-  OAuth2TokenService();
+  OAuth2TokenService(OAuth2TokenServiceDelegate* delegate);
   virtual ~OAuth2TokenService();
 
   // Add or remove observers of this token service.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Add or remove observers of this token service.
   void AddDiagnosticsObserver(DiagnosticsObserver* observer);
   void RemoveDiagnosticsObserver(DiagnosticsObserver* observer);
 
@@ skipping 22 matching lines @@
   // context given by |getter| instead of using the one returned by
   // |GetRequestContext| implemented by derived classes.
   scoped_ptr<Request> StartRequestWithContext(
       const std::string& account_id,
       net::URLRequestContextGetter* getter,
       const ScopeSet& scopes,
       Consumer* consumer);
 
   // Lists account IDs of all accounts with a refresh token maintained by this
   // instance.
-  virtual std::vector<std::string> GetAccounts();
+  std::vector<std::string> GetAccounts();
 
   // Returns true if a refresh token exists for |account_id|. If false, calls to
   // |StartRequest| will result in a Consumer::OnGetTokenFailure callback.
-  virtual bool RefreshTokenIsAvailable(const std::string& account_id) const = 0;
+  bool RefreshTokenIsAvailable(const std::string& account_id) const;
+
+  void RevokeAllCredentials();
 
   // Mark an OAuth2 |access_token| issued for |account_id| and |scopes| as
   // invalid. This should be done if the token was received from this class,
   // but was not accepted by the server (e.g., the server returned
   // 401 Unauthorized). The token will be removed from the cache for the given
   // scopes.
   void InvalidateToken(const std::string& account_id,
                        const ScopeSet& scopes,
                        const std::string& access_token);
 
   // Like |InvalidateToken| except is uses |client_id| to identity OAuth2 client
   // app that issued the request instead of Chrome's default values.
   void InvalidateTokenForClient(const std::string& account_id,
                                 const std::string& client_id,
                                 const ScopeSet& scopes,
                                 const std::string& access_token);
 
 
   // Return the current number of entries in the cache.
   int cache_size_for_testing() const;
   void set_max_authorization_token_fetch_retries_for_testing(int max_retries);
   // Returns the current number of pending fetchers matching given params.
   size_t GetNumPendingRequestsForTesting(
       const std::string& client_id,
       const std::string& account_id,
       const ScopeSet& scopes) const;
 
+  OAuth2TokenServiceDelegate* GetDelegate();
+
  protected:
   // Implements a cancelable |OAuth2TokenService::Request|, which should be
   // operated on the UI thread.
   // TODO(davidroche): move this out of header file.
   class RequestImpl : public base::SupportsWeakPtr<RequestImpl>,
                       public base::NonThreadSafe,
                       public Request {
    public:
     // |consumer| is required to outlive this.
     RequestImpl(const std::string& account_id, Consumer* consumer);
     ~RequestImpl() override;
 
     // Overridden from Request:
     std::string GetAccountId() const override;
 
     std::string GetConsumerId() const;
 
     // Informs |consumer_| that this request is completed.
     void InformConsumer(const GoogleServiceAuthError& error,
                         const std::string& access_token,
                         const base::Time& expiration_date);
 
    private:
     // |consumer_| to call back when this request completes.
     const std::string account_id_;
     Consumer* const consumer_;
   };
 
-  // Helper class to scope batch changes.
-  class ScopedBatchChange {
-   public:
-    explicit ScopedBatchChange(OAuth2TokenService* token_service);
-    ~ScopedBatchChange();
-   private:
-    OAuth2TokenService* token_service_;  // Weak.
-    DISALLOW_COPY_AND_ASSIGN(ScopedBatchChange);
-  };
-
-  // Subclasses can override if they want to report errors to the user.
-  virtual void UpdateAuthError(
-      const std::string& account_id,
-      const GoogleServiceAuthError& error);
+  // Implement it in delegates if they want to report errors to the user.
+  void UpdateAuthError(const std::string& account_id,
+                       const GoogleServiceAuthError& error);
 
   // Add a new entry to the cache.
   // Subclasses can override if there are implementation-specific reasons
   // that an access token should ever not be cached.
   virtual void RegisterCacheEntry(const std::string& client_id,
                                   const std::string& account_id,
                                   const ScopeSet& scopes,
                                   const std::string& access_token,
                                   const base::Time& expiration_date);
 
   // Clears the internal token cache.
   void ClearCache();
 
   // Clears all of the tokens belonging to |account_id| from the internal token
   // cache. It does not matter what other parameters, like |client_id| were
   // used to request the tokens.
   void ClearCacheForAccount(const std::string& account_id);
 
   // Cancels all requests that are currently in progress.
   void CancelAllRequests();
 
   // Cancels all requests related to a given |account_id|.
   void CancelRequestsForAccount(const std::string& account_id);
 
-  // Called by subclasses to notify observers.
-  virtual void FireRefreshTokenAvailable(const std::string& account_id);
-  virtual void FireRefreshTokenRevoked(const std::string& account_id);
-  virtual void FireRefreshTokensLoaded();
-
-  virtual void StartBatchChanges();
-  virtual void EndBatchChanges();
-
   // Fetches an OAuth token for the specified client/scopes. Virtual so it can
-  // be overridden for tests and for platform-specific behavior on Android.
+  // be overridden for tests and for platform-specific behavior.
   virtual void FetchOAuth2Token(RequestImpl* request,
                                 const std::string& account_id,
                                 net::URLRequestContextGetter* getter,
                                 const std::string& client_id,
                                 const std::string& client_secret,
                                 const ScopeSet& scopes);
 
-  // Creates an access token fetcher for the given account id.
-  //
-  // Subclasses should override to create an access token fetcher for the given
-  // |account_id|. This method is only called if subclasses use the default
-  // implementation of |FetchOAuth2Token|.
-  virtual OAuth2AccessTokenFetcher* CreateAccessTokenFetcher(
+  // Create an access token fetcher for the given account id.
+  OAuth2AccessTokenFetcher* CreateAccessTokenFetcher(
       const std::string& account_id,
       net::URLRequestContextGetter* getter,
-      OAuth2AccessTokenConsumer* consumer) = 0;
+      OAuth2AccessTokenConsumer* consumer);
 
   // Invalidates the |access_token| issued for |account_id|, |client_id| and
   // |scopes|. Virtual so it can be overriden for tests and for platform-
   // specifc behavior.
   virtual void InvalidateOAuth2Token(const std::string& account_id,
                                      const std::string& client_id,
                                      const ScopeSet& scopes,
                                      const std::string& access_token);
-
  private:
   class Fetcher;
   friend class Fetcher;
+  friend class OAuth2TokenServiceDelegate;
 
   // The parameters used to fetch an OAuth2 access token.
   struct RequestParameters {
     RequestParameters(const std::string& client_id,
                       const std::string& account_id,
                       const ScopeSet& scopes);
     ~RequestParameters();
     bool operator<(const RequestParameters& params) const;
 
     // OAuth2 client id.
     std::string client_id;
     // Account id for which the request is made.
     std::string account_id;
     // URL scopes for the requested access token.
     ScopeSet scopes;
   };
 
   typedef std::map<RequestParameters, Fetcher*> PendingFetcherMap;
 
-  // Derived classes must provide a request context used for fetching access
-  // tokens with the |StartRequest| method.
-  virtual net::URLRequestContextGetter* GetRequestContext() = 0;
+  // Provide a request context used for fetching access tokens with the
+  // |StartRequest| method.
+  net::URLRequestContextGetter* GetRequestContext() const;
 
   // Struct that contains the information of an OAuth2 access token.
   struct CacheEntry {
     std::string access_token;
     base::Time expiration_date;
   };
 
   // This method does the same as |StartRequestWithContext| except it
   // uses |client_id| and |client_secret| to identify OAuth
   // client app instead of using Chrome's default values.
@@ skipping 29 matching lines @@
   // Called when |fetcher| finishes fetching.
   void OnFetchComplete(Fetcher* fetcher);
 
   // Called when a number of fetchers need to be canceled.
   void CancelFetchers(std::vector<Fetcher*> fetchers_to_cancel);
 
   // The cache of currently valid tokens.
   typedef std::map<RequestParameters, CacheEntry> TokenCache;
   TokenCache token_cache_;
 
+  scoped_ptr<OAuth2TokenServiceDelegate> delegate_;
+
   // A map from fetch parameters to a fetcher that is fetching an OAuth2 access
   // token using these parameters.
   PendingFetcherMap pending_fetchers_;
 
-  // List of observers to notify when refresh token availability changes.
-  // Makes sure list is empty on destruction.
-  ObserverList<Observer, true> observer_list_;
-
   // List of observers to notify when access token status changes.
   ObserverList<DiagnosticsObserver, true> diagnostics_observer_list_;
 
-  // The depth of batch changes.
-  int batch_change_depth_;
-
   // Maximum number of retries in fetching an OAuth2 access token.
   static int max_fetch_retry_num_;
 
   FRIEND_TEST_ALL_PREFIXES(OAuth2TokenServiceTest, RequestParametersOrderTest);
   FRIEND_TEST_ALL_PREFIXES(OAuth2TokenServiceTest,
                            SameScopesRequestedForDifferentClients);
 
   DISALLOW_COPY_AND_ASSIGN(OAuth2TokenService);
 };
 
 #endif  // GOOGLE_APIS_GAIA_OAUTH2_TOKEN_SERVICE_H_