[EasyUnlock] Update BluetoothLowEnergyConnectionFinder to look for EIDs.

components/proximity_auth/remote_device_life_cycle_impl.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/remote_device_life_cycle_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "components/cryptauth/bluetooth_throttler_impl.h"
 #include "components/cryptauth/connection_finder.h"
 #include "components/cryptauth/device_to_device_authenticator.h"
 #include "components/cryptauth/secure_context.h"
 #include "components/cryptauth/secure_message_delegate.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 #include "components/proximity_auth/bluetooth_connection.h"
 #include "components/proximity_auth/bluetooth_connection_finder.h"
+#include "components/proximity_auth/bluetooth_low_energy_connection_finder.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger_impl.h"
 #include "components/proximity_auth/proximity_auth_client.h"
+#include "components/proximity_auth/switches.h"
 
 namespace proximity_auth {
 
 namespace {
 
 // The UUID of the Smart Lock classic Bluetooth service.
 const char kClassicBluetoothServiceUUID[] =
     "704EE561-3782-405A-A14B-2D47A2DDCDDF";
 
-// The UUID of the Bluetooth Low Energy service.
-const char kBLESmartLockServiceUUID[] = "b3b7e28e-a000-3e17-bd86-6e97b9e28c11";
-
 // The time to wait, in seconds, after authentication fails, before retrying
 // another connection.
 const int kAuthenticationRecoveryTimeSeconds = 10;
 
 }  // namespace
 
 RemoteDeviceLifeCycleImpl::RemoteDeviceLifeCycleImpl(
     const cryptauth::RemoteDevice& remote_device,
     ProximityAuthClient* proximity_auth_client)
     : remote_device_(remote_device),
@@ skipping 27 matching lines @@
 void RemoteDeviceLifeCycleImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void RemoteDeviceLifeCycleImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::unique_ptr<cryptauth::ConnectionFinder>
 RemoteDeviceLifeCycleImpl::CreateConnectionFinder() {
-  if (remote_device_.bluetooth_address.empty()) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery)) {
+    cryptauth::RemoteBeaconSeedFetcher fetcher(
+        proximity_auth_client_->GetCryptAuthDeviceManager());
+    std::vector<cryptauth::BeaconSeed> beacon_seeds;
+    if (!fetcher.FetchSeedsForDevice(remote_device_, &beacon_seeds)) {
+      PA_LOG(ERROR) << "Unable to fetch BeaconSeeds for "
+                    << remote_device_.name;
+      return nullptr;
+    }
+
     return base::MakeUnique<BluetoothLowEnergyConnectionFinder>(
-        remote_device_, kBLESmartLockServiceUUID,
-        BluetoothLowEnergyConnectionFinder::FinderStrategy::FIND_PAIRED_DEVICE,
-        nullptr, bluetooth_throttler_, 3);
+        remote_device_, beacon_seeds, bluetooth_throttler_);
   } else {
     return base::MakeUnique<BluetoothConnectionFinder>(
         remote_device_, device::BluetoothUUID(kClassicBluetoothServiceUUID),
         base::TimeDelta::FromSeconds(3));
   }
 }
 
 std::unique_ptr<cryptauth::Authenticator>
 RemoteDeviceLifeCycleImpl::CreateAuthenticator() {
   return base::MakeUnique<cryptauth::DeviceToDeviceAuthenticator>(
       connection_.get(), remote_device_.user_id,
       proximity_auth_client_->CreateSecureMessageDelegate());
 }
 
 void RemoteDeviceLifeCycleImpl::TransitionToState(
     RemoteDeviceLifeCycle::State new_state) {
   PA_LOG(INFO) << "Life cycle transition: " << static_cast<int>(state_)
                << " => " << static_cast<int>(new_state);
   RemoteDeviceLifeCycle::State old_state = state_;
   state_ = new_state;
   for (auto& observer : observers_)
     observer.OnLifeCycleStateChanged(old_state, new_state);
 }
 
 void RemoteDeviceLifeCycleImpl::FindConnection() {
   connection_finder_ = CreateConnectionFinder();
+  if (!connection_finder_) {
+    // TODO(tengs): We need to introduce a failed state if the RemoteDevice data
+    // is invalid.
+    TransitionToState(RemoteDeviceLifeCycleImpl::State::FINDING_CONNECTION);
+    return;
+  }
+
   connection_finder_->Find(
       base::Bind(&RemoteDeviceLifeCycleImpl::OnConnectionFound,
                  weak_ptr_factory_.GetWeakPtr()));
   TransitionToState(RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
 }
 
 void RemoteDeviceLifeCycleImpl::OnConnectionFound(
     std::unique_ptr<cryptauth::Connection> connection) {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
   connection_ = std::move(connection);
@@ skipping 40 matching lines @@
   TransitionToState(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
 }
 
 void RemoteDeviceLifeCycleImpl::OnDisconnected() {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
   messenger_.reset();
   FindConnection();
 }
 
 }  // namespace proximity_auth