google_apis/gaia/account_tracker.h

   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_