Home | History | Annotate | Download | only in gaia 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_
      6 #define GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_
      7 
      8 #include <map>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/observer_list.h"
     14 #include "google_apis/gaia/gaia_oauth_client.h"
     15 #include "google_apis/gaia/identity_provider.h"
     16 #include "google_apis/gaia/oauth2_token_service.h"
     17 
     18 class GoogleServiceAuthError;
     19 
     20 namespace net {
     21 class URLRequestContextGetter;
     22 }
     23 
     24 namespace gaia {
     25 
     26 struct AccountIds {
     27   std::string account_key;  // The account ID used by OAuth2TokenService.
     28   std::string gaia;
     29   std::string email;
     30 };
     31 
     32 class AccountIdFetcher;
     33 
     34 // The AccountTracker keeps track of what accounts exist on the
     35 // profile and the state of their credentials. The tracker fetches the
     36 // gaia ID of each account it knows about.
     37 //
     38 // The AccountTracker maintains these invariants:
     39 // 1. Events are only fired after the gaia ID has been fetched.
     40 // 2. Add/Remove and SignIn/SignOut pairs are always generated in order.
     41 // 3. SignIn follows Add, and there will be a SignOut between SignIn & Remove.
     42 // 4. If there is no primary account, there are no other accounts.
     43 class AccountTracker : public OAuth2TokenService::Observer,
     44                        public IdentityProvider::Observer {
     45  public:
     46   AccountTracker(IdentityProvider* identity_provider,
     47                  net::URLRequestContextGetter* request_context_getter);
     48   virtual ~AccountTracker();
     49 
     50   class Observer {
     51    public:
     52     virtual void OnAccountAdded(const AccountIds& ids) = 0;
     53     virtual void OnAccountRemoved(const AccountIds& ids) = 0;
     54     virtual void OnAccountSignInChanged(const AccountIds& ids,
     55                                         bool is_signed_in) = 0;
     56   };
     57 
     58   void Shutdown();
     59 
     60   void AddObserver(Observer* observer);
     61   void RemoveObserver(Observer* observer);
     62 
     63   // Returns the list of accounts that are signed in, and for which gaia IDs
     64   // have been fetched. The primary account for the profile will be first
     65   // in the vector. Additional accounts will be in order of their gaia IDs.
     66   std::vector<AccountIds> GetAccounts() const;
     67   AccountIds FindAccountIdsByGaiaId(const std::string& gaia_id);
     68 
     69   // OAuth2TokenService::Observer implementation.
     70   virtual void OnRefreshTokenAvailable(const std::string& account_key) OVERRIDE;
     71   virtual void OnRefreshTokenRevoked(const std::string& account_key) OVERRIDE;
     72 
     73   void OnUserInfoFetchSuccess(AccountIdFetcher* fetcher,
     74                               const std::string& gaia_id);
     75   void OnUserInfoFetchFailure(AccountIdFetcher* fetcher);
     76 
     77   // IdentityProvider::Observer implementation.
     78   virtual void OnActiveAccountLogin() OVERRIDE;
     79   virtual void OnActiveAccountLogout() OVERRIDE;
     80 
     81   // Sets the state of an account. Does not fire notifications.
     82   void SetAccountStateForTest(AccountIds ids, bool is_signed_in);
     83 
     84   IdentityProvider* identity_provider() { return identity_provider_; }
     85 
     86  private:
     87   struct AccountState {
     88     AccountIds ids;
     89     bool is_signed_in;
     90   };
     91 
     92   void NotifyAccountAdded(const AccountState& account);
     93   void NotifyAccountRemoved(const AccountState& account);
     94   void NotifySignInChanged(const AccountState& account);
     95 
     96   void UpdateSignInState(const std::string account_key, bool is_signed_in);
     97 
     98   void StartTrackingAccount(const std::string account_key);
     99   void StopTrackingAccount(const std::string account_key);
    100   void StopTrackingAllAccounts();
    101   void StartFetchingUserInfo(const std::string account_key);
    102   void DeleteFetcher(AccountIdFetcher* fetcher);
    103 
    104   IdentityProvider* identity_provider_;  // Not owned.
    105   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
    106   std::map<std::string, AccountIdFetcher*> user_info_requests_;
    107   std::map<std::string, AccountState> accounts_;
    108   ObserverList<Observer> observer_list_;
    109   bool shutdown_called_;
    110 };
    111 
    112 class AccountIdFetcher : public OAuth2TokenService::Consumer,
    113                          public gaia::GaiaOAuthClient::Delegate {
    114  public:
    115   AccountIdFetcher(OAuth2TokenService* token_service,
    116                    net::URLRequestContextGetter* request_context_getter,
    117                    AccountTracker* tracker,
    118                    const std::string& account_key);
    119   virtual ~AccountIdFetcher();
    120 
    121   const std::string& account_key() { return account_key_; }
    122 
    123   void Start();
    124 
    125   // OAuth2TokenService::Consumer implementation.
    126   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
    127                                  const std::string& access_token,
    128                                  const base::Time& expiration_time) OVERRIDE;
    129   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
    130                                  const GoogleServiceAuthError& error) OVERRIDE;
    131 
    132   // gaia::GaiaOAuthClient::Delegate implementation.
    133   virtual void OnGetUserIdResponse(const std::string& gaia_id) OVERRIDE;
    134   virtual void OnOAuthError() OVERRIDE;
    135   virtual void OnNetworkError(int response_code) OVERRIDE;
    136 
    137  private:
    138   OAuth2TokenService* token_service_;
    139   net::URLRequestContextGetter* request_context_getter_;
    140   AccountTracker* tracker_;
    141   const std::string account_key_;
    142 
    143   scoped_ptr<OAuth2TokenService::Request> login_token_request_;
    144   scoped_ptr<gaia::GaiaOAuthClient> gaia_oauth_client_;
    145 };
    146 
    147 }  // namespace extensions
    148 
    149 #endif  // GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_
    150