Hook up CryptAuthGCMManager to the enrollment and device sync managers.

components/proximity_auth/cryptauth/cryptauth_device_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_device_manager.h"
 
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
+#include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/mock_cryptauth_client.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::DoAll;
 using ::testing::NiceMock;
 using ::testing::Return;
@@ skipping 74 matching lines @@
     EXPECT_TRUE(expected_unlock_key.unlock_key());
     EXPECT_FALSE(expected_unlock_key.unlockable());
   }
 }
 
 // Harness for testing CryptAuthDeviceManager.
 class TestCryptAuthDeviceManager : public CryptAuthDeviceManager {
  public:
   TestCryptAuthDeviceManager(scoped_ptr<base::Clock> clock,
                              scoped_ptr<CryptAuthClientFactory> client_factory,
+                             CryptAuthGCMManager* gcm_manager,
                              PrefService* pref_service)
       : CryptAuthDeviceManager(clock.Pass(),
                                client_factory.Pass(),
+                               gcm_manager,
                                pref_service),
         scoped_sync_scheduler_(new NiceMock<MockSyncScheduler>()),
         weak_sync_scheduler_factory_(scoped_sync_scheduler_.get()) {}
 
   ~TestCryptAuthDeviceManager() override {}
 
   scoped_ptr<SyncScheduler> CreateSyncScheduler() override {
     EXPECT_TRUE(scoped_sync_scheduler_);
     return scoped_sync_scheduler_.Pass();
   }
@@ skipping 20 matching lines @@
 
 class ProximityAuthCryptAuthDeviceManagerTest
     : public testing::Test,
       public CryptAuthDeviceManager::Observer,
       public MockCryptAuthClientFactory::Observer {
  protected:
   ProximityAuthCryptAuthDeviceManagerTest()
       : clock_(new base::SimpleTestClock()),
         client_factory_(new MockCryptAuthClientFactory(
             MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
+        gcm_manager_("existing gcm registration id"),
         device_manager_(make_scoped_ptr(clock_),
                         make_scoped_ptr(client_factory_),
+                        &gcm_manager_,
                         &pref_service_) {
     client_factory_->AddObserver(this);
   }
 
   ~ProximityAuthCryptAuthDeviceManagerTest() {
     client_factory_->RemoveObserver(this);
   }
 
   // testing::Test:
   void SetUp() override {
@@ skipping 92 matching lines @@
   }
 
   // Owned by |device_manager_|.
   base::SimpleTestClock* clock_;
 
   // Owned by |device_manager_|.
   MockCryptAuthClientFactory* client_factory_;
 
   TestingPrefServiceSimple pref_service_;
 
+  FakeCryptAuthGCMManager gcm_manager_;
+
   TestCryptAuthDeviceManager device_manager_;
 
   cryptauth::GetMyDevicesResponse get_my_devices_response_;
 
   cryptauth::GetMyDevicesRequest get_my_devices_request_;
 
   CryptAuthClient::GetMyDevicesCallback success_callback_;
 
   CryptAuthClient::ErrorCallback error_callback_;
 
@@ skipping 42 matching lines @@
   clock->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
   base::TimeDelta elapsed_time = clock->Now() - base::Time::FromDoubleT(0);
 
   TestingPrefServiceSimple pref_service;
   CryptAuthDeviceManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthDeviceManager device_manager(
       clock.Pass(),
       make_scoped_ptr(new MockCryptAuthClientFactory(
           MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
-      &pref_service);
+      &gcm_manager_, &pref_service);
 
   EXPECT_CALL(
       *(device_manager.GetSyncScheduler()),
       Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   device_manager.Start();
   EXPECT_TRUE(device_manager.GetLastSyncTime().is_null());
   EXPECT_EQ(0u, device_manager.unlock_keys().size());
 }
 
 TEST_F(ProximityAuthCryptAuthDeviceManagerTest, InitWithExistingPrefs) {
@@ skipping 181 matching lines @@
   ASSERT_FALSE(success_callback_.is_null());
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(response);
 
   ExpectUnlockKeysAndPrefAreEqual(expected_unlock_keys,
                                   device_manager_.unlock_keys(), pref_service_);
 }
 
+TEST_F(ProximityAuthCryptAuthDeviceManagerTest, SyncOnGCMPushMessage) {
+  device_manager_.Start();
+
+  EXPECT_CALL(*sync_scheduler(), ForceSync());
+  gcm_manager_.PushResyncMessage();
+
+  FireSchedulerForSync(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
+
+  EXPECT_CALL(*this, OnSyncFinishedProxy(
+                         CryptAuthDeviceManager::SyncResult::SUCCESS,
+                         CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
+  success_callback_.Run(get_my_devices_response_);
+
+  ExpectUnlockKeysAndPrefAreEqual(std::vector<cryptauth::ExternalDeviceInfo>(
+                                      1, get_my_devices_response_.devices(0)),
+                                  device_manager_.unlock_keys(), pref_service_);
+}
+
 }  // namespace proximity_auth