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

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 "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/prefs/pref_service.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
+#include "base/time/default_tick_clock.h"
 #include "base/values.h"
-#include "components/proximity_auth/bluetooth_connection.h"
+#include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
+#include "components/proximity_auth/ble/bluetooth_low_energy_device_whitelist.h"
+#include "components/proximity_auth/ble/pref_names.h"
+#include "components/proximity_auth/bluetooth_connection_finder.h"
+#include "components/proximity_auth/bluetooth_throttler_impl.h"
 #include "components/proximity_auth/bluetooth_util.h"
 #include "components/proximity_auth/client_impl.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
 #include "components/proximity_auth/cryptauth/cryptauth_gcm_manager_impl.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/cryptauth/secure_message_delegate.h"
 #include "components/proximity_auth/device_to_device_authenticator.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.h"
 #include "components/proximity_auth/webui/cryptauth_enroller_factory_impl.h"
 #include "components/proximity_auth/webui/proximity_auth_ui_delegate.h"
 #include "components/proximity_auth/webui/reachable_phone_flow.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace proximity_auth {
 
 namespace {
 
-// The UUID of the Smart Lock Bluetooth service.
-const char kBluetoothServiceUUID[] = "704EE561-3782-405A-A14B-2D47A2DDCDDF";
+// 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 UUID of the characteristic used to send data to the peripheral.
+const char kBLEToPeripheralCharUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
+
+// The UUID of the characteristic used to receive data from the peripheral.
+const char kBLEFromPeripheralCharUUID[] =
+    "f4b904a2-a030-43b3-98a8-221c536c03cb";
 
 // Keys in the JSON representation of a log message.
 const char kLogMessageTextKey[] = "text";
 const char kLogMessageTimeKey[] = "time";
 const char kLogMessageFileKey[] = "file";
 const char kLogMessageLineKey[] = "line";
 const char kLogMessageSeverityKey[] = "severity";
 
 // Keys in the JSON representation of a SyncState object for enrollment or
 // device sync.
@@ skipping 48 matching lines @@
   sync_state->SetBoolean(kSyncStateOperationInProgress,
                          is_enrollment_in_progress);
   return sync_state;
 }
 
 }  // namespace
 
 ProximityAuthWebUIHandler::ProximityAuthWebUIHandler(
     ProximityAuthUIDelegate* delegate)
     : delegate_(delegate),
-      web_contents_initialized_(false),
       weak_ptr_factory_(this) {
   cryptauth_client_factory_ = delegate_->CreateCryptAuthClientFactory();
 }
 
 ProximityAuthWebUIHandler::~ProximityAuthWebUIHandler() {
   LogBuffer::GetInstance()->RemoveObserver(this);
 }
 
 void ProximityAuthWebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
@@ skipping 187 matching lines @@
       !args->GetString(0, &b64_public_key) ||
       !Base64UrlDecode(b64_public_key, &public_key)) {
     return;
   }
 
   Connection* connection = GetConnection();
   for (const auto& unlock_key : device_manager_->unlock_keys()) {
     if (unlock_key.public_key() == public_key) {
       // Check if there is an existing connection to disconnect from first.
       if (connection && connection->IsConnected() &&
-          connection->remote_device().public_key == public_key) {
+          selected_remote_device_.public_key == public_key) {
         PA_LOG(INFO) << "Disconnecting from "
                      << unlock_key.friendly_device_name() << "["
                      << unlock_key.bluetooth_address() << "]";
         connection->Disconnect();
         return;
       }
 
       // Derive the PSK before connecting to the device.
-      PA_LOG(INFO) << "Connecting to " << unlock_key.friendly_device_name()
-                   << "[" << unlock_key.bluetooth_address() << "]";
+      PA_LOG(INFO) << "Deriving PSK before connecting to "
+                   << unlock_key.friendly_device_name();
       secure_message_delegate_ = delegate_->CreateSecureMessageDelegate();
       secure_message_delegate_->DeriveKey(
           user_private_key_, unlock_key.public_key(),
           base::Bind(&ProximityAuthWebUIHandler::OnPSKDerived,
                      weak_ptr_factory_.GetWeakPtr(), unlock_key));
 
       return;
     }
   }
 
@@ skipping 165 matching lines @@
     return unlock_keys;
 
   for (const auto& unlock_key : device_manager_->unlock_keys()) {
     unlock_keys->Append(ExternalDeviceInfoToDictionary(unlock_key));
   }
 
   return unlock_keys;
 }
 
 Connection* ProximityAuthWebUIHandler::GetConnection() {
-  Connection* connection = bluetooth_connection_.get();
+  Connection* connection = connection_.get();
   if (client_) {
     DCHECK(!connection);
     connection = client_->connection();
   }
   return connection;
 }
 
 void ProximityAuthWebUIHandler::OnPSKDerived(
     const cryptauth::ExternalDeviceInfo& unlock_key,
     const std::string& persistent_symmetric_key) {
   if (persistent_symmetric_key.empty()) {
     PA_LOG(ERROR) << "Failed to derive PSK.";
     return;
   }
 
-  RemoteDevice remote_device(
-      unlock_key.friendly_device_name(), unlock_key.public_key(),
-      unlock_key.bluetooth_address(), persistent_symmetric_key);
+  selected_remote_device_ =
+      RemoteDevice(unlock_key.friendly_device_name(), unlock_key.public_key(),
+                   unlock_key.bluetooth_address(), persistent_symmetric_key);
 
-  bluetooth_connection_.reset(new BluetoothConnection(
-      remote_device, device::BluetoothUUID(kBluetoothServiceUUID)));
-  bluetooth_connection_->AddObserver(this);
-
-  // This SeekDeviceByAddress operation is needed to connect to a device if
-  // it is not already known to the local device.
-  bluetooth_util::SeekDeviceByAddress(
-      remote_device.bluetooth_address,
-      base::Bind(&ProximityAuthWebUIHandler::OnSeekedDeviceByAddress,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProximityAuthWebUIHandler::OnSeekedDeviceByAddressError,
-                 weak_ptr_factory_.GetWeakPtr()),
-      content::BrowserThread::GetBlockingPool()
-          ->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
-          .get());
+  // TODO(tengs): We distinguish whether the unlock key uses classic Bluetooth
+  // or BLE based on the presence of the |bluetooth_address| field. However, we
+  // should ideally have a separate field specifying the protocol.
+  if (selected_remote_device_.bluetooth_address.empty())
+    FindBluetoothLowEnergyConnection(selected_remote_device_);
+  else
+    FindBluetoothClassicConnection(selected_remote_device_);
 }
 
-void ProximityAuthWebUIHandler::OnSeekedDeviceByAddress() {
-  PA_LOG(INFO) << "Found Bluetooth device: "
-               << bluetooth_connection_->remote_device().bluetooth_address;
-  bluetooth_connection_->Connect();
+void ProximityAuthWebUIHandler::FindBluetoothClassicConnection(
+    const RemoteDevice& remote_device) {
+  PA_LOG(INFO) << "Finding classic Bluetooth device " << remote_device.name
+               << " [" << remote_device.bluetooth_address << "].";
+
+  // TODO(tengs): Set a timeout to stop the connection finder eventually.
+  connection_finder_.reset(new BluetoothConnectionFinder(
+      remote_device, device::BluetoothUUID(kClassicBluetoothServiceUUID),
+      base::TimeDelta::FromSeconds(3)));
+  connection_finder_->Find(
+      base::Bind(&ProximityAuthWebUIHandler::OnConnectionFound,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
+                                   *GetUnlockKeysList());
 }
 
-void ProximityAuthWebUIHandler::OnSeekedDeviceByAddressError(
-    const std::string& error_message) {
-  PA_LOG(WARNING) << "Failed to seek device by address: "
-                  << bluetooth_connection_->remote_device().bluetooth_address;
+void ProximityAuthWebUIHandler::FindBluetoothLowEnergyConnection(
+    const RemoteDevice& remote_device) {
+  PrefService* pref_service = delegate_->GetPrefService();
+  if (!pref_service->FindPreference(
+          prefs::kBluetoothLowEnergyDeviceWhitelist)) {
+    PA_LOG(ERROR) << "Please enable the BLE experiment in chrome://flags.";
+    return;
+  }
+
+  PA_LOG(INFO) << "Finding Bluetooth Low Energy device " << remote_device.name;
+  if (!bluetooth_throttler_) {
+    bluetooth_throttler_.reset(new BluetoothThrottlerImpl(
+        make_scoped_ptr(new base::DefaultTickClock())));
+  }
+
+  ble_device_whitelist_.reset(
+      new BluetoothLowEnergyDeviceWhitelist(delegate_->GetPrefService()));
+
+  // TODO(tengs): Set a timeout to stop the connection finder eventually.
+  connection_finder_.reset(new BluetoothLowEnergyConnectionFinder(
+      kBLESmartLockServiceUUID, kBLEToPeripheralCharUUID,
+      kBLEFromPeripheralCharUUID, ble_device_whitelist_.get(),
+      bluetooth_throttler_.get(), 3));
+  connection_finder_->Find(
+      base::Bind(&ProximityAuthWebUIHandler::OnConnectionFound,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
+                                   *GetUnlockKeysList());
 }
 
 void ProximityAuthWebUIHandler::OnAuthenticationResult(
     Authenticator::Result result,
     scoped_ptr<SecureContext> secure_context) {
   secure_context_ = secure_context.Pass();
 
   // Create the ClientImpl asynchronously. |client_| registers itself as an
-  // observer of |bluetooth_connection_|, so creating it synchronously would
+  // observer of |connection_|, so creating it synchronously would
   // trigger |OnSendComplete()| as an observer call for |client_|.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ProximityAuthWebUIHandler::CreateStatusUpdateClient,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void ProximityAuthWebUIHandler::OnConnectionFound(
+    scoped_ptr<Connection> connection) {
+  DCHECK(connection->IsConnected());
+  connection_ = connection.Pass();
+  connection_->AddObserver(this);
+
+  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
+                                   *GetUnlockKeysList());
+
+  // TODO(tengs): Create an authenticator for BLE connections.
+  if (selected_remote_device_.bluetooth_address.empty())
+    return;
+
+  authenticator_.reset(new DeviceToDeviceAuthenticator(
+      connection_.get(), delegate_->GetAccountId(),
+      delegate_->CreateSecureMessageDelegate()));
+  authenticator_->Authenticate(
+      base::Bind(&ProximityAuthWebUIHandler::OnAuthenticationResult,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 void ProximityAuthWebUIHandler::CreateStatusUpdateClient() {
-  client_.reset(
-      new ClientImpl(bluetooth_connection_.Pass(), secure_context_.Pass()));
+  client_.reset(new ClientImpl(connection_.Pass(), secure_context_.Pass()));
   client_->AddObserver(this);
 }
 
 scoped_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::ExternalDeviceInfoToDictionary(
     const cryptauth::ExternalDeviceInfo& device_info) {
   std::string base64_public_key;
   Base64UrlEncode(device_info.public_key(), &base64_public_key);
 
   // Set the fields in the ExternalDeviceInfo proto.
@@ skipping 14 matching lines @@
   // 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(),
       [&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_->unlock_keys().end() ||
+      selected_remote_device_.public_key != device_info.public_key())
     return dictionary;
 
   // Fill in the current Bluetooth connection status.
+  std::string connection_status = kExternalDeviceDisconnected;
   Connection* connection = GetConnection();
-  if (!connection ||
-      connection->remote_device().public_key != device_info.public_key())
-    return dictionary;
-
-  std::string connection_status = kExternalDeviceDisconnected;
-  if (connection->IsConnected()) {
+  if (connection && connection->IsConnected()) {
     connection_status = kExternalDeviceConnected;
-  } else if (connection->status() == Connection::IN_PROGRESS) {
+  } else if (connection_finder_) {
     connection_status = kExternalDeviceConnecting;
   }
   dictionary->SetString(kExternalDeviceConnectionStatus, connection_status);
 
   // Fill the remote status dictionary.
   if (last_remote_status_update_) {
     scoped_ptr<base::DictionaryValue> status_dictionary(
         new base::DictionaryValue());
     status_dictionary->SetInteger("userPresent",
                                   last_remote_status_update_->user_presence);
@@ skipping 22 matching lines @@
                          ineligibility_reasons.Pass());
   return device_dictionary;
 }
 
 void ProximityAuthWebUIHandler::OnConnectionStatusChanged(
     Connection* connection,
     Connection::Status old_status,
     Connection::Status new_status) {
   PA_LOG(INFO) << "Connection status changed from " << old_status << " to "
                << new_status;
-  if (new_status == Connection::CONNECTED) {
-    authenticator_.reset(new DeviceToDeviceAuthenticator(
-        connection, delegate_->GetAccountId(),
-        delegate_->CreateSecureMessageDelegate()));
-    authenticator_->Authenticate(
-        base::Bind(&ProximityAuthWebUIHandler::OnAuthenticationResult,
-                   weak_ptr_factory_.GetWeakPtr()));
-  } else if (new_status == Connection::DISCONNECTED) {
+
+  if (new_status == Connection::DISCONNECTED) {
     last_remote_status_update_.reset();
+    selected_remote_device_ = RemoteDevice();
+    connection_finder_.reset();
   }
 
   scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *unlock_keys);
 }
 
 void ProximityAuthWebUIHandler::OnMessageReceived(const Connection& connection,
                                                   const WireMessage& message) {
   std::string address = connection.remote_device().bluetooth_address;
@@ skipping 10 matching lines @@
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
   scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *unlock_keys);
 }
 
 }  // namespace proximity_auth