Hook up CryptAuthGCMManager to the enrollment and device sync managers.

components/proximity_auth/cryptauth/cryptauth_device_manager.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/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
@@ skipping 70 matching lines @@
   external_device->set_unlock_key(true);
   external_device->set_unlockable(false);
   return true;
 }
 
 }  // namespace
 
 CryptAuthDeviceManager::CryptAuthDeviceManager(
     scoped_ptr<base::Clock> clock,
     scoped_ptr<CryptAuthClientFactory> client_factory,
+    CryptAuthGCMManager* gcm_manager,
     PrefService* pref_service)
     : clock_(clock.Pass()),
       client_factory_(client_factory.Pass()),
+      gcm_manager_(gcm_manager),
       pref_service_(pref_service),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 CryptAuthDeviceManager::~CryptAuthDeviceManager() {
+  gcm_manager_->RemoveObserver(this);
 }
 
 // static
 void CryptAuthDeviceManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDoublePref(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds,
                                0.0);
   registry->RegisterBooleanPref(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure, false);
   registry->RegisterIntegerPref(prefs::kCryptAuthDeviceSyncReason,
                                 cryptauth::INVOCATION_REASON_UNKNOWN);
   registry->RegisterListPref(prefs::kCryptAuthDeviceSyncUnlockKeys);
 }
 
 void CryptAuthDeviceManager::Start() {
   UpdateUnlockKeysFromPrefs();
 
+  gcm_manager_->AddObserver(this);
+
   base::Time last_successful_sync = GetLastSyncTime();
   base::TimeDelta elapsed_time_since_last_sync =
       clock_->Now() - last_successful_sync;
 
   bool is_recovering_from_failure =
       pref_service_->GetBoolean(
           prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure) ||
       last_successful_sync.is_null();
 
   scheduler_ = CreateSyncScheduler();
@@ skipping 84 matching lines @@
       OnSyncFinished(SyncResult::FAILURE, DeviceChangeResult::UNCHANGED));
 }
 
 scoped_ptr<SyncScheduler> CryptAuthDeviceManager::CreateSyncScheduler() {
   return make_scoped_ptr(new SyncSchedulerImpl(
       this, base::TimeDelta::FromHours(kRefreshPeriodHours),
       base::TimeDelta::FromMinutes(kDeviceSyncBaseRecoveryPeriodMinutes),
       kDeviceSyncMaxJitterRatio, "CryptAuth DeviceSync"));
 }
 
+void CryptAuthDeviceManager::OnResyncMessage() {
+  ForceSyncNow(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
+}
+
 void CryptAuthDeviceManager::UpdateUnlockKeysFromPrefs() {
   const base::ListValue* unlock_key_list =
       pref_service_->GetList(prefs::kCryptAuthDeviceSyncUnlockKeys);
   unlock_keys_.clear();
   for (size_t i = 0; i < unlock_key_list->GetSize(); ++i) {
     const base::DictionaryValue* unlock_key_dictionary;
     if (unlock_key_list->GetDictionary(i, &unlock_key_dictionary)) {
       cryptauth::ExternalDeviceInfo unlock_key;
       if (DictionaryToUnlockKey(*unlock_key_dictionary, &unlock_key)) {
         unlock_keys_.push_back(unlock_key);
@@ skipping 36 matching lines @@
   cryptauth::GetMyDevicesRequest request;
   request.set_invocation_reason(invocation_reason);
   cryptauth_client_->GetMyDevices(
       request, base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesSuccess,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesFailure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace proximity_auth