[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"
+#include "testing/gtest/include/gtest/gtest_prod.h"

[Nicolas Zea, 2014/11/06 21:43:17]

why is this needed?

[fgorski, 2014/11/07 01:42:13]

Done.
In the end I made the test class a friend

+
+namespace base {
+class Time;
+}
 
 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.
+//
+// This class makes a check for tokens periodically, to make sure the user is
+// still logged into the profile, so that in the case that the user is not, we

[Nicolas Zea, 2014/11/06 21:43:17]

Is it just to ensure that we're still logged into the profile? Or is it to
ensure that the tokens themselves haven't expired or been revoked remotely?

We shouldn't need to periodically poll for a local event (i.e. sign out). We can
listen for those events directly.

[fgorski, 2014/11/07 01:42:13]

Every checkin with GCM should have a fresh set of tokens. We are watching for
the event, but on top of that want to periodically get a fresh batch of tokens
to report (in case the user never restarts Chrome.

[Nicolas Zea, 2014/11/07 22:19:25]

I think its worth mentioning this part in the comment. We're not really fetching
tokens periodically to see if we're logged in (although that checks that too),
but to actually have a fresh set of access tokens to send to the Checkin server.

+// can immediately report that to the GCM and stop messages addressed to that
+// user from ever reaching Chrome.
 class GCMAccountTracker : public gaia::AccountTracker::Observer,
                           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.
@@ skipping 36 matching lines @@
 
   // Starts tracking accounts.
   void Start();
 
   // Gets the number of pending token requests. Only used for testing.
   size_t get_pending_token_request_count() const {
     return pending_token_requests_.size();
   }
 
  private:
+  friend class GCMAccountTrackerTest;
+
   // Maps account keys to account states. Keyed by account_ids as used by
   // OAuth2TokenService.
   typedef std::map<std::string, AccountInfo> AccountInfos;
 
   // AccountTracker::Observer overrides.
   void OnAccountAdded(const gaia::AccountIds& ids) override;
   void OnAccountRemoved(const gaia::AccountIds& ids) override;
   void OnAccountSignInChanged(const gaia::AccountIds& ids,
                               bool is_signed_in) override;
 
   // OAuth2TokenService::Consumer overrides.
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override;
   void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                          const GoogleServiceAuthError& error) override;
 
   // GCMConnectionObserver overrides.
   void OnConnected(const net::IPEndPoint& ip_endpoint) override;
   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() const;
+  // Indicates whether there are tokens that still need fetching.
+  bool IsTokenFetchingRequired() const;
+  // Gets the time until next token fetching.
+  base::TimeDelta GetTimeToNextTokenFetching() const;
   // 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_;
 
   ScopedVector<OAuth2TokenService::Request> pending_token_requests_;
 
+  base::WeakPtrFactory<GCMAccountTracker> weak_ptr_factory_;

[Nicolas Zea, 2014/11/06 21:43:17]

nit: Given that this is specifically for reporting tokens, perhaps we should
name it something else? If someone were to attempt to use this for binding to
other methods, the InvalidateAll might introduce bugs. 

[fgorski, 2014/11/07 01:42:12]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(GCMAccountTracker);
 };
 
 }  // namespace gcm
 
 #endif  // CHROME_BROWSER_SERVICES_GCM_GCM_ACCOUNT_TRACKER_H_