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 // Indicates if all user information has been fetched. If the result is false, 87 // there are still unfininshed fetchers. 88 virtual bool IsAllUserInfoFetched() const; 89 90 private: 91 struct AccountState { 92 AccountIds ids; 93 bool is_signed_in; 94 }; 95 96 void NotifyAccountAdded(const AccountState& account); 97 void NotifyAccountRemoved(const AccountState& account); 98 void NotifySignInChanged(const AccountState& account); 99 100 void UpdateSignInState(const std::string account_key, bool is_signed_in); 101 102 void StartTrackingAccount(const std::string account_key); 103 void StopTrackingAccount(const std::string account_key); 104 void StopTrackingAllAccounts(); 105 void StartFetchingUserInfo(const std::string account_key); 106 void DeleteFetcher(AccountIdFetcher* fetcher); 107 108 IdentityProvider* identity_provider_; // Not owned. 109 scoped_refptr<net::URLRequestContextGetter> request_context_getter_; 110 std::map<std::string, AccountIdFetcher*> user_info_requests_; 111 std::map<std::string, AccountState> accounts_; 112 ObserverList<Observer> observer_list_; 113 bool shutdown_called_; 114 }; 115 116 class AccountIdFetcher : public OAuth2TokenService::Consumer, 117 public gaia::GaiaOAuthClient::Delegate { 118 public: 119 AccountIdFetcher(OAuth2TokenService* token_service, 120 net::URLRequestContextGetter* request_context_getter, 121 AccountTracker* tracker, 122 const std::string& account_key); 123 virtual ~AccountIdFetcher(); 124 125 const std::string& account_key() { return account_key_; } 126 127 void Start(); 128 129 // OAuth2TokenService::Consumer implementation. 130 virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request, 131 const std::string& access_token, 132 const base::Time& expiration_time) OVERRIDE; 133 virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request, 134 const GoogleServiceAuthError& error) OVERRIDE; 135 136 // gaia::GaiaOAuthClient::Delegate implementation. 137 virtual void OnGetUserIdResponse(const std::string& gaia_id) OVERRIDE; 138 virtual void OnOAuthError() OVERRIDE; 139 virtual void OnNetworkError(int response_code) OVERRIDE; 140 141 private: 142 OAuth2TokenService* token_service_; 143 net::URLRequestContextGetter* request_context_getter_; 144 AccountTracker* tracker_; 145 const std::string account_key_; 146 147 scoped_ptr<OAuth2TokenService::Request> login_token_request_; 148 scoped_ptr<gaia::GaiaOAuthClient> gaia_oauth_client_; 149 }; 150 151 } // namespace extensions 152 153 #endif // GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_ 154