Implement finding BLE connections in chrome://proximity-auth.

components/proximity_auth/ble/bluetooth_low_energy_connection_finder.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/ble/bluetooth_low_energy_connection_finder.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 96 matching lines @@
   if (adapter_->IsPowered() && discovery_session_ &&
       discovery_session_->IsActive())
     HandleDeviceUpdated(device);
 }
 
 void BluetoothLowEnergyConnectionFinder::DeviceChanged(
     BluetoothAdapter* adapter,
     BluetoothDevice* device) {
   DCHECK_EQ(adapter_.get(), adapter);
   DCHECK(device);
-  PA_LOG(INFO) << "Device changed: " << device->GetAddress();
 
   // Note: Only consider |device| when it was actually added/updated during a
   // scanning, otherwise the device is stale and the GATT connection will fail.
   // For instance, when |adapter_| change status from unpowered to powered,
   // |DeviceAdded| is called for each paired |device|.
   if (adapter_->IsPowered() && discovery_session_ &&
-      discovery_session_->IsActive())
+      discovery_session_->IsActive()) {
+    if (device_whitelist_->HasDeviceWithAddress(device->GetAddress()))
+      PA_LOG(INFO) << "Whitelisted device changed: " << device->GetAddress();
     HandleDeviceUpdated(device);
+  }
 }
 
 void BluetoothLowEnergyConnectionFinder::HandleDeviceUpdated(
     BluetoothDevice* device) {
   // Ensuring only one call to |CreateConnection()| is made. A new |connection_|
   // can be created only when the previous one disconnects, triggering a call to
   // |OnConnectionStatusChanged|.
   if (connection_ || !device->IsPaired())
     return;
 
@@ skipping 123 matching lines @@
     Connection::Status old_status,
     Connection::Status new_status) {
   DCHECK_EQ(connection, connection_.get());
   PA_LOG(INFO) << "OnConnectionStatusChanged: " << old_status << " -> "
                << new_status;
 
   if (!connection_callback_.is_null() && connection_->IsConnected()) {
     adapter_->RemoveObserver(this);
     connection_->RemoveObserver(this);
 
-    // Note: any observer of |connection_| added in |connection_callback_| will
-    // also receive this |OnConnectionStatusChanged| notification (IN_PROGRESS
-    // -> CONNECTED).
-    connection_callback_.Run(connection_.Pass());
-    connection_callback_.Reset();
+    // If we invoke the callback now, the callback function may install its own
+    // observer to |connection_|. Because we are in the ConnectionObserver
+    // callstack, this new observer will receive this connection event.
+    // Therefore, we need to invoke the callback asynchronously.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(&BluetoothLowEnergyConnectionFinder::InvokeCallbackAsync,
+                   weak_ptr_factory_.GetWeakPtr()));
   } else if (old_status == Connection::IN_PROGRESS) {
     PA_LOG(WARNING) << "Connection failed. Retrying.";
     RestartDiscoverySessionWhenReady();
   }
 }
 
 void BluetoothLowEnergyConnectionFinder::RestartDiscoverySessionWhenReady() {
   PA_LOG(INFO) << "Trying to restart discovery.";
 
   // To restart scanning for devices, it's necessary to ensure that:
@@ skipping 24 matching lines @@
   // This is a bug in the way device::BluetoothAdapter is storing the devices
   // (see crbug.com/497841).
   std::vector<BluetoothDevice*> devices = adapter_->GetDevices();
   for (const auto& device : devices) {
     if (device->GetAddress() == device_address)
       return device;
   }
   return nullptr;
 }
 
+void BluetoothLowEnergyConnectionFinder::InvokeCallbackAsync() {
+  connection_callback_.Run(connection_.Pass());
+}
+
 }  // namespace proximity_auth