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

components/proximity_auth/webui/proximity_auth_webui_handler.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/webui/proximity_auth_webui_handler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/base64url.h"
@@ skipping 323 matching lines @@
   std::string b64_public_key;
   std::string public_key;
   if (!enrollment_manager || !device_manager || !args->GetSize() ||
       !args->GetString(0, &b64_public_key) ||
       !base::Base64UrlDecode(b64_public_key,
                              base::Base64UrlDecodePolicy::REQUIRE_PADDING,
                              &public_key)) {
     return;
   }
 
-  for (const auto& unlock_key : device_manager->unlock_keys()) {
+  for (const auto& unlock_key : device_manager->GetUnlockKeys()) {
     if (unlock_key.public_key() == public_key) {
       if (life_cycle_ && selected_remote_device_.public_key == public_key) {
         CleanUpRemoteDeviceLifeCycle();
         return;
       }
 
       // TODO(sacomoto): Pass an instance of ProximityAuthPrefManager. This is
       // used to get the address of BLE devices.
       remote_device_loader_.reset(new RemoteDeviceLoader(
           std::vector<cryptauth::ExternalDeviceInfo>(1, unlock_key),
@@ skipping 101 matching lines @@
 }
 
 std::unique_ptr<base::ListValue>
 ProximityAuthWebUIHandler::GetUnlockKeysList() {
   std::unique_ptr<base::ListValue> unlock_keys(new base::ListValue());
   cryptauth::CryptAuthDeviceManager* device_manager =
       proximity_auth_client_->GetCryptAuthDeviceManager();
   if (!device_manager)
     return unlock_keys;
 
-  for (const auto& unlock_key : device_manager->unlock_keys()) {
+  for (const auto& unlock_key : device_manager->GetUnlockKeys()) {
     unlock_keys->Append(ExternalDeviceInfoToDictionary(unlock_key));
   }
 
   return unlock_keys;
 }
 
 void ProximityAuthWebUIHandler::OnRemoteDevicesLoaded(
     const std::vector<cryptauth::RemoteDevice>& remote_devices) {
   if (remote_devices[0].persistent_symmetric_key.empty()) {
     PA_LOG(ERROR) << "Failed to derive PSK.";
@@ skipping 30 matching lines @@
   cryptauth::CryptAuthDeviceManager* device_manager =
       proximity_auth_client_->GetCryptAuthDeviceManager();
   if (!device_manager)
     return dictionary;
 
   // If |device_info| is a known unlock key, then combine the proto data with
   // the corresponding local device data (e.g. connection status and remote
   // status updates).
   std::string public_key = device_info.public_key();
   auto iterator = std::find_if(
-      device_manager->unlock_keys().begin(),
-      device_manager->unlock_keys().end(),
+      device_manager->GetUnlockKeys().begin(),
+      device_manager->GetUnlockKeys().end(),
       [&public_key](const cryptauth::ExternalDeviceInfo& unlock_key) {
         return unlock_key.public_key() == public_key;
       });
 
-  if (iterator == device_manager->unlock_keys().end() ||
+  if (iterator == device_manager->GetUnlockKeys().end() ||
       selected_remote_device_.public_key != device_info.public_key())
     return dictionary;
 
   // Fill in the current Bluetooth connection status.
   std::string connection_status = kExternalDeviceDisconnected;
   if (life_cycle_ &&
       life_cycle_->GetState() ==
           RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
     connection_status = kExternalDeviceConnected;
   } else if (life_cycle_) {
@@ skipping 76 matching lines @@
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
   std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onUnlockKeysChanged", *unlock_keys);
 }
 
 }  // namespace proximity_auth