Revert of [EasyUnlock] Add beacon_seeds to RemoteDevice.

components/cryptauth/remote_device_loader.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/remote_device_loader.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/base64url.h"
@@ skipping 38 matching lines @@
                              user_id,
                              user_private_key,
                              std::move(secure_message_delegate)));
 }
 
 RemoteDeviceLoader::RemoteDeviceLoader(
     const std::vector<cryptauth::ExternalDeviceInfo>& device_info_list,
     const std::string& user_id,
     const std::string& user_private_key,
     std::unique_ptr<cryptauth::SecureMessageDelegate> secure_message_delegate)
-    : should_load_beacon_seeds_(false),
-      remaining_devices_(device_info_list),
+    : remaining_devices_(device_info_list),
       user_id_(user_id),
       user_private_key_(user_private_key),
       secure_message_delegate_(std::move(secure_message_delegate)),
       weak_ptr_factory_(this) {}
 
 RemoteDeviceLoader::~RemoteDeviceLoader() {}
 
-void RemoteDeviceLoader::Load(bool should_load_beacon_seeds,
-                              const RemoteDeviceCallback& callback) {
+void RemoteDeviceLoader::Load(const RemoteDeviceCallback& callback) {
   DCHECK(callback_.is_null());
-  should_load_beacon_seeds_ = should_load_beacon_seeds;
   callback_ = callback;
   PA_LOG(INFO) << "Loading " << remaining_devices_.size()
                << " remote devices";
 
   if (remaining_devices_.empty()) {
     callback_.Run(remote_devices_);
     return;
   }
 
   std::vector<cryptauth::ExternalDeviceInfo> all_devices_to_convert =
@@ skipping 15 matching lines @@
       remaining_devices_.begin(), remaining_devices_.end(),
       [&public_key](const cryptauth::ExternalDeviceInfo& device) {
         return device.public_key() == public_key;
       });
 
   DCHECK(iterator != remaining_devices_.end());
   remaining_devices_.erase(iterator);
   PA_LOG(INFO) << "Derived PSK for " << device.friendly_device_name()
                << ", " << remaining_devices_.size() << " keys remaining.";
 
-  cryptauth::RemoteDevice remote_device(
+  remote_devices_.push_back(cryptauth::RemoteDevice(
       user_id_, device.friendly_device_name(), device.public_key(),
-      device.bluetooth_address(), psk, std::string());
-
-  if (should_load_beacon_seeds_) {
-    std::vector<BeaconSeed> beacon_seeds;
-    for (const BeaconSeed& beacon_seed : device.beacon_seeds()) {
-      beacon_seeds.push_back(beacon_seed);
-    }
-    remote_device.LoadBeaconSeeds(beacon_seeds);
-  }
-  remote_devices_.push_back(remote_device);
+      device.bluetooth_address(), psk, std::string()));
 
   if (remaining_devices_.empty())
     callback_.Run(remote_devices_);
 }
 
 }  // namespace cryptauth