Hook up CryptAuthGCMManager to the enrollment and device sync managers.

components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h

 // Copyright 2015 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 COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H
 #define COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
+#include "components/proximity_auth/cryptauth/cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/cryptauth/sync_scheduler.h"
 
 class PrefRegistrySimple;
 class PrefService;
 
 namespace base {
 class Clock;
 class Time;
 }
 
 namespace proximity_auth {
 
 class CryptAuthEnroller;
 class CryptAuthEnrollerFactory;
 
 // This class manages the device's enrollment with CryptAuth, periodically
 // re-enrolling to keep the state on the server fresh. If an enrollment fails,
 // the manager will schedule the next enrollment more aggressively to recover
 // from the failure.
-class CryptAuthEnrollmentManager : public SyncScheduler::Delegate {
+class CryptAuthEnrollmentManager : public SyncScheduler::Delegate,
+                                   public CryptAuthGCMManager::Observer {
  public:
   class Observer {
    public:
     // Called when an enrollment attempt is started.
     virtual void OnEnrollmentStarted() = 0;
 
     // Called when an enrollment attempt finishes with the |success| of the
     // attempt.
     virtual void OnEnrollmentFinished(bool success) = 0;
 
     virtual ~Observer() {}
   };
 
   // Creates the manager:
   // |clock|: Used to determine the time between sync attempts.
   // |enroller_factory|: Creates CryptAuthEnroller instances to perform each
   //                     enrollment attempt.
   // |user_public_key|: The user's persistent public key identifying the device.
   // |user_private_key|: The corresponding private key to |user_public_key|.
   // |device_info|: Contains information about the local device that will be
   //                uploaded to CryptAuth with each enrollment request.
+  // |gcm_manager|: Used to perform GCM registrations and also notifies when GCM
+  //                push messages trigger re-enrollments.
+  //                Not owned and must outlive this instance.
   // |pref_service|: Contains preferences across browser restarts, and should
   //                 have been registered through RegisterPrefs().
   CryptAuthEnrollmentManager(
       scoped_ptr<base::Clock> clock,
       scoped_ptr<CryptAuthEnrollerFactory> enroller_factory,
       const std::string& user_public_key,
       const std::string& user_private_key,
       const cryptauth::GcmDeviceInfo& device_info,
+      CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service);
 
   ~CryptAuthEnrollmentManager() override;
 
   // Registers the prefs used by this class to the given |pref_service|.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Begins scheduling periodic enrollment attempts.
   void Start();
 
@@ skipping 26 matching lines @@
   // Returns true if the last enrollment failed and the manager is now
   // scheduling enrollments more aggressively to recover. If no enrollment has
   // ever been recorded, then this function will also return true.
   bool IsRecoveringFromFailure() const;
 
  protected:
   // Creates a new SyncScheduler instance. Exposed for testing.
   virtual scoped_ptr<SyncScheduler> CreateSyncScheduler();
 
  private:
+  // CryptAuthGCMManager::Observer:
+  void OnGCMRegistrationResult(bool success) override;
+  void OnReenrollMessage() override;
+
   // SyncScheduler::Delegate:
   void OnSyncRequested(
       scoped_ptr<SyncScheduler::SyncRequest> sync_request) override;
 
+  // Starts a CryptAuth enrollment attempt.
+  void DoCryptAuthEnrollment();
+
   // Callback when |cryptauth_enroller_| completes.
   void OnEnrollmentFinished(bool success);
 
   // Used to determine the time.
   scoped_ptr<base::Clock> clock_;
 
   // Creates CryptAuthEnroller instances for each enrollment attempt.
   scoped_ptr<CryptAuthEnrollerFactory> enroller_factory_;
 
   // The user's persistent key-pair identifying the local device.
   std::string user_public_key_;
   std::string user_private_key_;
 
   // The local device information to upload to CryptAuth.
   const cryptauth::GcmDeviceInfo device_info_;
 
+  //  Used to perform GCM registrations and also notifies when GCM push messages
+  //  trigger re-enrollments. Not owned and must outlive this instance.
+  CryptAuthGCMManager* gcm_manager_;
+
   // Contains perferences that outlive the lifetime of this object and across
   // process restarts.
   // Not owned and must outlive this instance.
   PrefService* pref_service_;
 
   // Schedules the time between enrollment attempts.
   scoped_ptr<SyncScheduler> scheduler_;
 
   // Contains the SyncRequest that |scheduler_| requests when an enrollment
   // attempt is made.
   scoped_ptr<SyncScheduler::SyncRequest> sync_request_;
 
   // The CryptAuthEnroller instance for the current enrollment attempt. A new
   // instance will be created for each individual attempt.
   scoped_ptr<CryptAuthEnroller> cryptauth_enroller_;
 
   // List of observers.
   base::ObserverList<Observer> observers_;
 
   base::WeakPtrFactory<CryptAuthEnrollmentManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CryptAuthEnrollmentManager);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H