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();
+  virtual std::vector<std::string> GetAccounts();  // ganggui_temp
 
   // 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;
+  virtual bool RefreshTokenIsAvailable(
+      const std::string& account_id) const;  // ganggui_temp

[Roger Tawa OOO till Jul 10th, 2015/05/24 21:13:18]

The above two methods should not be virtual.  Is this what you mean by temp?

[gogerald1, 2015/05/25 21:10:58]

Done.

[gogerald1, 2015/05/25 21:10:58]

Yes, just make it pass the unit_tests compilation, since many other fake token
services override them.

+
+  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();
+
+  // 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);

[Roger Tawa OOO till Jul 10th, 2015/05/24 21:13:18]

I think this should be made private, otherwise there is no difference between
this and line 196 above.

[gogerald1, 2015/05/25 21:10:57]

Yes, I will move it into protect group, it was moved from protect group to
public in the modifications for android.

+
  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);
+  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.
   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);

[Roger Tawa OOO till Jul 10th, 2015/05/24 21:13:18]

This should not be virtual.

[gogerald1, 2015/05/25 21:10:58]

I just find the fake token services override this interface, and this interface
has concrete implementation only in OAuth2TokenService, so if this interface is
non-virtual, it is difficult to change its behavior for tests. We may need
FakeOAuth2TokenService and FakeOAuth2TokenServiceDelegate for tests.

 
   // 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(
       const std::string& account_id,
       net::URLRequestContextGetter* getter,
-      OAuth2AccessTokenConsumer* consumer) = 0;
-
-  // 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);
+      OAuth2AccessTokenConsumer* consumer);  // ganggui_temp

[Roger Tawa OOO till Jul 10th, 2015/05/24 21:13:18]

This should not be virtual.

[gogerald1, 2015/05/25 21:10:58]

Done.

 
  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.
@@ skipping 51 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_