Update CryptAuthDeviceManager to store all synced devices instead of only unlock keys.

components/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/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.h>
 #include <stdexcept>
 #include <utility>
 
@@ skipping 349 matching lines @@
 bool CryptAuthDeviceManager::IsSyncInProgress() const {
   return scheduler_->GetSyncState() ==
          SyncScheduler::SyncState::SYNC_IN_PROGRESS;
 }
 
 bool CryptAuthDeviceManager::IsRecoveringFromFailure() const {
   return scheduler_->GetStrategy() ==
          SyncScheduler::Strategy::AGGRESSIVE_RECOVERY;
 }
 
+std::vector<ExternalDeviceInfo> CryptAuthDeviceManager::synced_devices() const {
+  return synced_devices_;
+}
+
+std::vector<ExternalDeviceInfo> CryptAuthDeviceManager::UnlockKeys() const {
+  std::vector<ExternalDeviceInfo> unlock_keys;
+  for (const auto& device : synced_devices_) {
+    if (device.unlock_key()) {
+      unlock_keys.push_back(device);
+    }
+  }
+  return unlock_keys;
+}
+
+std::vector<ExternalDeviceInfo> CryptAuthDeviceManager::TetherHosts() const {
+  std::vector<ExternalDeviceInfo> tether_hosts;
+  for (const auto& device : synced_devices_) {
+    if (device.mobile_hotspot_supported()) {
+      tether_hosts.push_back(device);
+    }
+  }
+  return tether_hosts;
+}
+
 void CryptAuthDeviceManager::OnGetMyDevicesSuccess(
     const cryptauth::GetMyDevicesResponse& response) {
-  // Update the unlock keys stored in the user's prefs.
-  std::unique_ptr<base::ListValue> unlock_keys_pref(new base::ListValue());
+  // Update the synced devices stored in the user's prefs.
   std::unique_ptr<base::ListValue> devices_as_list(new base::ListValue());
   for (const auto& device : response.devices()) {
     devices_as_list->Append(UnlockKeyToDictionary(device));
-    if (device.unlock_key())
-      unlock_keys_pref->Append(UnlockKeyToDictionary(device));
   }
   PA_LOG(INFO) << "Devices Synced:\n" << *devices_as_list;
 
-  bool unlock_keys_changed = !unlock_keys_pref->Equals(
+  bool unlock_keys_changed = !devices_as_list->Equals(
       pref_service_->GetList(prefs::kCryptAuthDeviceSyncUnlockKeys));
   {
     ListPrefUpdate update(pref_service_, prefs::kCryptAuthDeviceSyncUnlockKeys);
-    update.Get()->Swap(unlock_keys_pref.get());
+    update.Get()->Swap(devices_as_list.get());
   }
   UpdateUnlockKeysFromPrefs();
 
   // Reset metadata used for scheduling syncing.
   pref_service_->SetBoolean(prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure,
                             false);
   pref_service_->SetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds,
                            clock_->Now().ToDoubleT());
   pref_service_->SetInteger(prefs::kCryptAuthDeviceSyncReason,
                             cryptauth::INVOCATION_REASON_UNKNOWN);
@@ skipping 27 matching lines @@
       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();
+  synced_devices_.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);
+        synced_devices_.push_back(unlock_key);
       } else {
         PA_LOG(ERROR) << "Unable to deserialize unlock key dictionary "
                       << "(index=" << i << "):\n" << *unlock_key_dictionary;
       }
     } else {
       PA_LOG(ERROR) << "Can not get dictionary in list of unlock keys "
                     << "(index=" << i << "):\n" << *unlock_key_list;
     }
   }
 }
@@ skipping 34 matching lines @@
   request.set_invocation_reason(invocation_reason);
   request.set_allow_stale_read(is_sync_speculative);
   cryptauth_client_->GetMyDevices(
       request, base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesSuccess,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesFailure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace cryptauth