Add IdentityProvider-based AccountTracker to google_apis

google_apis/gaia/account_tracker.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 CHROME_BROWSER_EXTENSIONS_API_IDENTITY_ACCOUNT_TRACKER_H_
-#define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_ACCOUNT_TRACKER_H_
+#ifndef GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_
+#define GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
+#include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
-#include "components/signin/core/browser/signin_error_controller.h"
-#include "components/signin/core/browser/signin_manager_base.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
+#include "google_apis/gaia/identity_provider.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 
 class GoogleServiceAuthError;
-class Profile;
 
-namespace extensions {
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace gaia {
 
 struct AccountIds {
   std::string account_key;  // The account ID used by OAuth2TokenService.

[fgorski, 2014/06/17 04:14:00]

Did you consider the following:
* calling it account_id
* turning it into a method that returns whichever of the other 2 is the right
account_id at the time.

[Michael Courage, 2014/06/18 23:13:17]

Considered, but this seemed more straightforward to me.

   std::string gaia;
   std::string email;
 };
 
 class AccountIdFetcher;
 
 // The AccountTracker keeps track of what accounts exist on the
 // profile and the state of their credentials. The tracker fetches the
 // gaia ID of each account it knows about.
 //
 // The AccountTracker maintains these invariants:
 // 1. Events are only fired after the gaia ID has been fetched.
 // 2. Add/Remove and SignIn/SignOut pairs are always generated in order.
 // 3. SignIn follows Add, and there will be a SignOut between SignIn & Remove.
 // 4. If there is no primary account, there are no other accounts.
 class AccountTracker : public OAuth2TokenService::Observer,
-                       public SigninErrorController::AuthStatusProvider,
-                       public SigninManagerBase::Observer {
+                       public IdentityProvider::Observer {
  public:
-  explicit AccountTracker(Profile* profile);
+  AccountTracker(scoped_ptr<IdentityProvider> identity_provider,
+                 net::URLRequestContextGetter* request_context_getter);
   virtual ~AccountTracker();
 
   class Observer {
    public:
     virtual void OnAccountAdded(const AccountIds& ids) = 0;
     virtual void OnAccountRemoved(const AccountIds& ids) = 0;
     virtual void OnAccountSignInChanged(const AccountIds& ids,
                                         bool is_signed_in) = 0;
   };
 
   void Shutdown();
 
-  void ReportAuthError(const std::string& account_key,
-                       const GoogleServiceAuthError& error);
-
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Returns the list of accounts that are signed in, and for which gaia IDs
   // have been fetched. The primary account for the profile will be first
   // in the vector. Additional accounts will be in order of their gaia IDs.
   std::vector<AccountIds> GetAccounts() const;
   std::string FindAccountKeyByGaiaId(const std::string& gaia_id);

[fgorski, 2014/06/17 04:14:00]

Could you have a method to get AccountIds by GaiaId? => solves the problem of
saving too much if I can always look it up.

[Michael Courage, 2014/06/18 23:13:17]

Done.

 
   // OAuth2TokenService::Observer implementation.
   virtual void OnRefreshTokenAvailable(const std::string& account_key) OVERRIDE;
   virtual void OnRefreshTokenRevoked(const std::string& account_key) OVERRIDE;
 
   void OnUserInfoFetchSuccess(AccountIdFetcher* fetcher,
                               const std::string& gaia_id);
   void OnUserInfoFetchFailure(AccountIdFetcher* fetcher);
 
-  // AuthStatusProvider implementation.
-  virtual std::string GetAccountId() const OVERRIDE;
-  virtual std::string GetUsername() const OVERRIDE;
-  virtual GoogleServiceAuthError GetAuthStatus() const OVERRIDE;
-
-  // SigninManagerBase::Observer implementation.
-  virtual void GoogleSigninSucceeded(const std::string& username,
-                                     const std::string& password) OVERRIDE;
-  virtual void GoogleSignedOut(const std::string& username) OVERRIDE;
+  // IdentityProvider::Observer implementation.
+  virtual void OnActiveAccountLogin() OVERRIDE;

[fgorski, 2014/06/17 04:14:00]

Is active account a new name for primary account?

[Roger Tawa OOO till Jul 10th, 2014/06/17 15:28:20]

No.  IdentityProvider has its own concept of one account being more special than
others, and exposes that as the "active" account of the given provider.  Its
like a more generalized concept than primary account.  The "primary" account is
a profile specific thing, sort of like a backward compatibility mode for code
that knows only about the sync account.

[fgorski, 2014/06/19 13:48:14]

Thanks for the explanation... Now I feel like I've been out of the loop forever
;)

+  virtual void OnActiveAccountLogout() OVERRIDE;
 
   // Sets the state of an account. Does not fire notifications.
   void SetAccountStateForTest(AccountIds ids, bool is_signed_in);
 
+  IdentityProvider* identity_provider() { return identity_provider_.get(); }
+
  private:
   struct AccountState {
     AccountIds ids;
     bool is_signed_in;
   };
 
-  const std::string signin_manager_account_id() const;
+  const std::string active_account_id() const;
 
   void NotifyAccountAdded(const AccountState& account);
   void NotifyAccountRemoved(const AccountState& account);
   void NotifySignInChanged(const AccountState& account);
 
-  void ClearAuthError(const std::string& account_key);
-  void UpdateSignInState(const std::string& account_key, bool is_signed_in);
+  void UpdateSignInState(const std::string account_key, bool is_signed_in);
 
-  void StartTrackingAccount(const std::string& account_key);
-  void StopTrackingAccount(const std::string& account_key);
+  void StartTrackingAccount(const std::string account_key);
+  void StopTrackingAccount(const std::string account_key);
   void StopTrackingAllAccounts();
-  void StartFetchingUserInfo(const std::string& account_key);
+  void StartFetchingUserInfo(const std::string account_key);
   void DeleteFetcher(AccountIdFetcher* fetcher);
 
-  Profile* profile_;
+  scoped_ptr<IdentityProvider> identity_provider_;

[fgorski, 2014/06/17 04:14:00]

Why is AccountTracker taking the ownership of IdentityProvider?

[Michael Courage, 2014/06/18 23:13:15]

That seemed to match existing IdentityProvider usage, but there is no real
reason. Removed ownership.

+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   std::map<std::string, AccountIdFetcher*> user_info_requests_;
   std::map<std::string, AccountState> accounts_;
-  std::map<std::string, GoogleServiceAuthError> account_errors_;
   ObserverList<Observer> observer_list_;
 };
 
 class AccountIdFetcher : public OAuth2TokenService::Consumer,
                          public gaia::GaiaOAuthClient::Delegate {
  public:
-  AccountIdFetcher(Profile* profile,
+  AccountIdFetcher(OAuth2TokenService* token_service,
+                   net::URLRequestContextGetter* request_context_getter,
                    AccountTracker* tracker,
                    const std::string& account_key);
   virtual ~AccountIdFetcher();
 
   const std::string& account_key() { return account_key_; }
 
   void Start();
 
   // OAuth2TokenService::Consumer implementation.
   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                                  const std::string& access_token,
                                  const base::Time& expiration_time) OVERRIDE;
   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                                  const GoogleServiceAuthError& error) OVERRIDE;
 
   // gaia::GaiaOAuthClient::Delegate implementation.
   virtual void OnGetUserIdResponse(const std::string& gaia_id) OVERRIDE;
   virtual void OnOAuthError() OVERRIDE;
   virtual void OnNetworkError(int response_code) OVERRIDE;
 
  private:
-  Profile* profile_;
+  OAuth2TokenService* token_service_;
+  net::URLRequestContextGetter* request_context_getter_;
   AccountTracker* tracker_;
   const std::string account_key_;
 
   scoped_ptr<OAuth2TokenService::Request> login_token_request_;
   scoped_ptr<gaia::GaiaOAuthClient> gaia_oauth_client_;
 };
 
 }  // namespace extensions
 
-#endif  // CHROME_BROWSER_EXTENSIONS_API_IDENTITY_ACCOUNT_TRACKER_H_
+#endif  // GOOGLE_APIS_GAIA_ACCOUNT_TRACKER_H_