[EasyUnlock] Add beacon_seeds to RemoteDevice.

components/proximity_auth/bluetooth_low_energy_connection_finder.h

 // 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.
 
 #ifndef COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_LOW_ENERGY_CONNECTION_FINDER_H
 #define COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_LOW_ENERGY_CONNECTION_FINDER_H
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 20 matching lines @@
 // Bluetooth Low Energy remote device. We look for remote devices advertising
 // the expected EID for the current or nearby time intervals.
 class BluetoothLowEnergyConnectionFinder
     : public cryptauth::ConnectionFinder,
       public cryptauth::ConnectionObserver,
       public device::BluetoothAdapter::Observer {
  public:
   // Finds (and connects) to a Bluetooth low energy device, based on the EID
   // advertised by the remote device.
   //
   // |remote_device|: The BLE remote device.

[Kyle Horimoto, 2017/05/04 03:52:51]

You should probably add some language here saying that the devices have seeds.
Probably would be good to DCHECK() this too.

Same elsewhere where you expect this.

[Tim Song, 2017/05/06 22:53:16]

The DCHECK might be too harsh as there could be issues with the syncing and we
legitimately have no BeaconSeeds.

-  // |beacon_seeds|: The BeaconSeeds for the |remote_device.
   // |bluetooth_throttler|: The reconnection throttler.
   BluetoothLowEnergyConnectionFinder(
       const cryptauth::RemoteDevice remote_device,
-      const std::vector<cryptauth::BeaconSeed>& beacon_seeds,
       cryptauth::BluetoothThrottler* bluetooth_throttler);
 
   ~BluetoothLowEnergyConnectionFinder() override;
 
   // Finds a connection to the remote device.
   void Find(const cryptauth::ConnectionFinder::ConnectionCallback&
                 connection_callback) override;
 
   // cryptauth::ConnectionObserver:
   void OnConnectionStatusChanged(
       cryptauth::Connection* connection,
       cryptauth::Connection::Status old_status,
       cryptauth::Connection::Status new_status) override;
 
   // device::BluetoothAdapter::Observer:
   void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
                              bool powered) override;
   void DeviceAdded(device::BluetoothAdapter* adapter,
                    device::BluetoothDevice* device) override;
   void DeviceChanged(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
 
  protected:
   BluetoothLowEnergyConnectionFinder(
       const cryptauth::RemoteDevice remote_device,
       const std::string& service_uuid,
-      const std::vector<cryptauth::BeaconSeed>& beacon_seeds,
       std::unique_ptr<cryptauth::BackgroundEidGenerator> eid_generator,
       cryptauth::BluetoothThrottler* bluetooth_throttler);
 
   // Creates a proximity_auth::Connection with the device given by
   // |device_address|. Exposed for testing.
   virtual std::unique_ptr<cryptauth::Connection> CreateConnection(
       const std::string& device_address);
 
   // Checks if |device| is advertising the right EID.
   virtual bool IsRightDevice(device::BluetoothDevice* device);
@@ skipping 27 matching lines @@
   void InvokeCallbackAsync();
 
   // The remote BLE device being searched. It maybe empty, in this case the
   // remote device should advertise |remote_service_uuid_| and
   // |advertised_name_|.
   cryptauth::RemoteDevice remote_device_;
 
   // The UUID of the service used by the Weave socket.
   std::string service_uuid_;
 
-  // The BeaconSeeds of the |remote_device|.
-  std::vector<cryptauth::BeaconSeed> beacon_seeds_;
-
   // Generates the expected EIDs that may be advertised by |remote_device_|. If
   // an EID matches, we know its a device we should connect to.
   std::unique_ptr<cryptauth::BackgroundEidGenerator> eid_generator_;
 
   // Throttles repeated connection attempts to the same device. This is a
   // workaround for crbug.com/508919. Not owned, must outlive this instance.
   cryptauth::BluetoothThrottler* bluetooth_throttler_;
 
   // The Bluetooth adapter over which the Bluetooth connection will be made.
   scoped_refptr<device::BluetoothAdapter> adapter_;
 
   // The discovery session associated to this object.
   std::unique_ptr<device::BluetoothDiscoverySession> discovery_session_;
 
   // The connection with |remote_device|.
   std::unique_ptr<cryptauth::Connection> connection_;
 
   // Callback called when the connection is established.
   cryptauth::ConnectionFinder::ConnectionCallback connection_callback_;
 
   base::WeakPtrFactory<BluetoothLowEnergyConnectionFinder> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothLowEnergyConnectionFinder);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_LOW_ENERGY_CONNECTION_FINDER_H