[GCM] Fetching OAuth2 tokens periodically in account tracker

chrome/browser/services/gcm/gcm_account_tracker.h

 // Copyright 2014 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_SERVICES_GCM_GCM_ACCOUNT_TRACKER_H_
 #define CHROME_BROWSER_SERVICES_GCM_GCM_ACCOUNT_TRACKER_H_
 
 #include <map>
 #include <string>
 
 #include "base/memory/scoped_vector.h"
 #include "components/gcm_driver/gcm_client.h"
 #include "components/gcm_driver/gcm_connection_observer.h"
 #include "google_apis/gaia/account_tracker.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 
+class PrefService;
+
+namespace base {
+class Time;
+}
+
+namespace user_prefs {
+class PrefRegistrySyncable;
+}
+
 namespace gcm {
 
 class GCMDriver;
 
 // Class for reporting back which accounts are signed into. It is only meant to
 // be used when the user is signed into sync.
 class GCMAccountTracker : public gaia::AccountTracker::Observer,

[Nicolas Zea, 2014/10/08 00:45:29]

FYI I think it would be good to explain _why_ we're doing a periodic check in
the first place. My instinct when thinking about this is that periodic work
shouldn't be necessary if we only care about local data. Explaining that this is
actually checking that the token is valid periodically would probably make
things clearer.

[fgorski, 2014/11/06 01:16:14]

Done.

                           public OAuth2TokenService::Consumer,
                           public GCMConnectionObserver {
  public:
   // State of the account.
   // Allowed transitions:
   // TOKEN_NEEDED - account info was created.
   // TOKEN_NEEDED -> GETTING_TOKEN - access token was requested.
   // GETTING_TOKEN -> TOKEN_NEEDED - access token fetching failed.
   // GETTING_TOKEN -> TOKEN_PRESENT - access token fetching succeeded.
   // GETTING_TOKEN -> ACCOUNT_REMOVED - account was removed.
@@ skipping 15 matching lines @@
     // Email address of the tracked account.
     std::string email;
     // OAuth2 access token, when |state| is TOKEN_PRESENT.
     std::string access_token;
     // Expiration time of the access tokens.
     base::Time expiration_time;
     // Status of the token fetching.
     AccountState state;
   };
 
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
   // Creates an instance of GCMAccountTracker. |account_tracker| is used to
   // deliver information about the accounts present in the browser context to
   // |driver|.
   GCMAccountTracker(scoped_ptr<gaia::AccountTracker> account_tracker,
-                    GCMDriver* driver);
+                    GCMDriver* driver,
+                    PrefService* prefs);
   virtual ~GCMAccountTracker();
 
   // Shuts down the tracker ensuring a proper clean up. After Shutdown() is
   // called Start() and Stop() should no longer be used. Must be called before
   // destruction.
   void Shutdown();
 
   // Starts tracking accounts.
   void Start();
 
@@ skipping 17 matching lines @@
   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;
 
   // GCMConnectionObserver overrides.
   virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE;
   virtual void OnDisconnected() OVERRIDE;
 
+  // Schedules fetching tokens at the time when they are needed to be reported.
+  void ScheduleFetchingTokens();
   // Report the list of accounts with OAuth2 tokens back using the |callback_|
   // function. If there are token requests in progress, do nothing.
-  void CompleteCollectingTokens();
+  void ReportTokens();
   // Verify that all of the tokens are ready to be passed down to the GCM
   // Driver, e.g. none of them has expired or is missing. Returns true if not
   // all tokens are valid and a fetching yet more tokens is required.
   bool SanitizeTokens();
+  // Indicates whether token reporting is required, either because it is due, or
+  // some of the accounts were removed.
+  bool IsTokenReportingRequired();
+  // Indicates whether there are tokens that still need fetching.
+  bool IsTokenFetchingRequired();
+  // Gets the time until next token fetching.
+  base::TimeDelta GetTimeToNextTokenFetching();
   // Deletes a token request. Should be called from OnGetTokenSuccess(..) or
   // OnGetTokenFailure(..).
   void DeleteTokenRequest(const OAuth2TokenService::Request* request);
   // Checks on all known accounts, and calls GetToken(..) for those with
   // |state == TOKEN_NEEDED|.
   void GetAllNeededTokens();
   // Starts fetching the OAuth2 token for the GCM group scope.
   void GetToken(AccountInfos::iterator& account_iter);
 
   // Handling of actual sign in and sign out for accounts.
   void OnAccountSignedIn(const gaia::AccountIds& ids);
   void OnAccountSignedOut(const gaia::AccountIds& ids);
 
   OAuth2TokenService* GetTokenService();
 
   // Account tracker.
   scoped_ptr<gaia::AccountTracker> account_tracker_;
 
   // GCM Driver. Not owned.
   GCMDriver* driver_;
 
   // State of the account.
   AccountInfos account_infos_;
 
   // Indicates whether shutdown has been called.
   bool shutdown_called_;
 
+  // Pref service for storing timestamp of last token fetching. Not owned.
+  PrefService* prefs_;
+
+  base::Time last_token_fetch_time_;

[Nicolas Zea, 2014/10/08 00:45:29]

nit: comment about what this is for

[fgorski, 2014/11/06 01:16:14]

Done.

+
   ScopedVector<OAuth2TokenService::Request> pending_token_requests_;
 
+  base::WeakPtrFactory<GCMAccountTracker> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GCMAccountTracker);
 };
 
 }  // namespace gcm
 
 #endif  // CHROME_BROWSER_SERVICES_GCM_GCM_ACCOUNT_TRACKER_H_