Hook up CryptAuthGCMManager to the enrollment and device sync managers.

components/proximity_auth/cryptauth/cryptauth_enrollment_manager_unittest.cc

 // 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.
 
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
 
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enroller.h"
+#include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/mock_sync_scheduler.h"
 #include "components/proximity_auth/cryptauth/pref_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 namespace proximity_auth {
 
 namespace {
 
+// The GCM registration id from a successful registration.
+const char kGCMRegistrationId[] = "new gcm registration id";
+
 // The user's persistent key pair identifying the local device.
 const char kUserPublicKey[] = "user public key";
 const char kUserPrivateKey[] = "user private key";
 
 // The initial "Now" time for testing.
 const double kInitialTimeNowSeconds = 20000000;
 
 // A later "Now" time for testing.
 const double kLaterTimeNow = kInitialTimeNowSeconds + 30;
 
@@ skipping 49 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockCryptAuthEnrollerFactory);
 };
 
 // Harness for testing CryptAuthEnrollmentManager.
 class TestCryptAuthEnrollmentManager : public CryptAuthEnrollmentManager {
  public:
   TestCryptAuthEnrollmentManager(
       scoped_ptr<base::Clock> clock,
       scoped_ptr<CryptAuthEnrollerFactory> enroller_factory,
       const cryptauth::GcmDeviceInfo& device_info,
+      CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service)
       : CryptAuthEnrollmentManager(clock.Pass(),
                                    enroller_factory.Pass(),
                                    kUserPublicKey,
                                    kUserPrivateKey,
                                    device_info,
+                                   gcm_manager,
                                    pref_service),
         scoped_sync_scheduler_(new NiceMock<MockSyncScheduler>()),
         weak_sync_scheduler_factory_(scoped_sync_scheduler_.get()) {}
 
   ~TestCryptAuthEnrollmentManager() override {}
 
   scoped_ptr<SyncScheduler> CreateSyncScheduler() override {
     EXPECT_TRUE(scoped_sync_scheduler_);
     return scoped_sync_scheduler_.Pass();
   }
@@ skipping 18 matching lines @@
 
 }  // namespace
 
 class ProximityAuthCryptAuthEnrollmentManagerTest
     : public testing::Test,
       public CryptAuthEnrollmentManager::Observer {
  protected:
   ProximityAuthCryptAuthEnrollmentManagerTest()
       : clock_(new base::SimpleTestClock()),
         enroller_factory_(new MockCryptAuthEnrollerFactory()),
+        gcm_manager_(kGCMRegistrationId),
         enrollment_manager_(make_scoped_ptr(clock_),
                             make_scoped_ptr(enroller_factory_),
                             device_info_,
+                            &gcm_manager_,
                             &pref_service_) {}
 
   // testing::Test:
   void SetUp() override {
     clock_->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
     enrollment_manager_.AddObserver(this);
 
     CryptAuthEnrollmentManager::RegisterPrefs(pref_service_.registry());
     pref_service_.SetUserPref(
         prefs::kCryptAuthEnrollmentIsRecoveringFromFailure,
@@ skipping 58 matching lines @@
   // Owned by |enrollment_manager_|.
   base::SimpleTestClock* clock_;
 
   // Owned by |enrollment_manager_|.
   MockCryptAuthEnrollerFactory* enroller_factory_;
 
   cryptauth::GcmDeviceInfo device_info_;
 
   TestingPrefServiceSimple pref_service_;
 
+  FakeCryptAuthGCMManager gcm_manager_;
+
   TestCryptAuthEnrollmentManager enrollment_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ProximityAuthCryptAuthEnrollmentManagerTest);
 };
 
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, RegisterPrefs) {
   TestingPrefServiceSimple pref_service;
   CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry());
   EXPECT_TRUE(pref_service.FindPreference(
       prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds));
@@ skipping 30 matching lines @@
 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) {
   scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
   clock->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
   base::TimeDelta elapsed_time = clock->Now() - base::Time::FromDoubleT(0);
 
   TestingPrefServiceSimple pref_service;
   CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthEnrollmentManager enrollment_manager(
       clock.Pass(), make_scoped_ptr(new MockCryptAuthEnrollerFactory()),
-      device_info_, &pref_service);
+      device_info_, &gcm_manager_, &pref_service);
 
   EXPECT_CALL(
       *enrollment_manager.GetSyncScheduler(),
       Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   enrollment_manager.Start();
 
   EXPECT_FALSE(enrollment_manager.IsEnrollmentValid());
   EXPECT_TRUE(enrollment_manager.GetLastEnrollmentTime().is_null());
 }
 
@@ skipping 81 matching lines @@
   completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_FAILURE_RECOVERY);
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow + 30));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
   EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthEnrollmentIsRecoveringFromFailure));
 }
 
+TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest,
+       EnrollWithoutGCMRegistrationId) {
+  // Initialize |enrollment_manager_|.
+  ON_CALL(*sync_scheduler(), GetStrategy())
+      .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
+  gcm_manager_.set_registration_id(std::string());
+  enrollment_manager_.Start();
+
+  // Trigger a sync request.
+  EXPECT_CALL(*this, OnEnrollmentStartedProxy());
+  auto sync_request = make_scoped_ptr(
+      new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
+  static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
+      ->OnSyncRequested(sync_request.Pass());
+
+  // Complete GCM registration successfully.
+  CryptAuthEnroller::EnrollmentFinishedCallback enrollment_callback;
+  EXPECT_CALL(*next_cryptauth_enroller(),
+              Enroll(kUserPublicKey, kUserPrivateKey, _,
+                     cryptauth::INVOCATION_REASON_PERIODIC, _))
+      .WillOnce(SaveArg<4>(&enrollment_callback));
+  ASSERT_TRUE(gcm_manager_.registration_in_progress());
+  gcm_manager_.CompleteRegistration(kGCMRegistrationId);
+
+  // Complete CryptAuth enrollment.
+  ASSERT_FALSE(enrollment_callback.is_null());
+  EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
+  enrollment_callback.Run(true);
+}
+
+TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, GCMRegistrationFails) {
+  // Initialize |enrollment_manager_|.
+  ON_CALL(*sync_scheduler(), GetStrategy())
+      .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
+  gcm_manager_.set_registration_id(std::string());
+  enrollment_manager_.Start();
+
+  // Trigger a sync request.
+  EXPECT_CALL(*this, OnEnrollmentStartedProxy());
+  auto sync_request = make_scoped_ptr(
+      new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler()));
+  static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
+      ->OnSyncRequested(sync_request.Pass());
+
+  // Complete GCM registration with failure.
+  EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false));
+  gcm_manager_.CompleteRegistration(std::string());
+}
+
+TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, ReenrollOnGCMPushMessage) {
+  enrollment_manager_.Start();
+
+  // Simulate receiving a GCM push message, forcing the device to re-enroll.
+  gcm_manager_.PushReenrollMessage();
+  auto completion_callback =
+      FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
+
+  EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
+  completion_callback.Run(true);
+}
+
 }  // namespace proximity_auth