Change chrome://proximity-auth to use RemoteDeviceLifeCycle.

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/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/cryptauth/base64url.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.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/messenger_impl.h"
+#include "components/proximity_auth/messenger.h"
+#include "components/proximity_auth/remote_device_life_cycle_impl.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.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 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";
-
 // 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.
 const char kSyncStateLastSuccessTime[] = "lastSuccessTime";
@@ skipping 277 matching lines @@
     return;
 
   std::string b64_public_key;
   std::string public_key;
   if (!enrollment_manager || !device_manager || !args->GetSize() ||
       !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() &&
-          selected_remote_device_.public_key == public_key) {
-        PA_LOG(INFO) << "Disconnecting from "
-                     << unlock_key.friendly_device_name() << "["
-                     << unlock_key.bluetooth_address() << "]";
-        connection->Disconnect();
+      if (life_cycle_ && selected_remote_device_.public_key == public_key) {
+        CleanUpRemoteDeviceLifeCycle();
         return;
       }
 
       // Derive the PSK before connecting to the device.
       PA_LOG(INFO) << "Deriving PSK before connecting to "
                    << unlock_key.friendly_device_name();
       secure_message_delegate_ =
           proximity_auth_client_->CreateSecureMessageDelegate();
       secure_message_delegate_->DeriveKey(
           enrollment_manager->GetUserPrivateKey(), unlock_key.public_key(),
@@ skipping 101 matching lines @@
   if (!device_manager)
     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 = connection_.get();
-  if (messenger_) {
-    DCHECK(!connection);
-    connection = messenger_->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;
   }
 
   selected_remote_device_ =
       RemoteDevice(unlock_key.friendly_device_name(), unlock_key.public_key(),
                    unlock_key.bluetooth_address(), persistent_symmetric_key);
 
-  // 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::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::FindBluetoothLowEnergyConnection(
-    const RemoteDevice& remote_device) {
-  PrefService* pref_service = proximity_auth_client_->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(
-      proximity_auth_client_->GetPrefService()));
-
-  // TODO(tengs): Set a timeout to stop the connection finder eventually.
-  connection_finder_.reset(new BluetoothLowEnergyConnectionFinder(
-      remote_device, kBLESmartLockServiceUUID,
-      BluetoothLowEnergyConnectionFinder::FIND_ANY_DEVICE,
-      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 MessengerImpl asynchronously. |messenger_| registers itself as
-  // an observer of |connection_|, so creating it synchronously would trigger
-  // |OnSendComplete()| as an observer call for |messenger_|.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&ProximityAuthWebUIHandler::CreateStatusUpdateMessenger,
-                 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(), proximity_auth_client_->GetAccountId(),
-      proximity_auth_client_->CreateSecureMessageDelegate()));
-  authenticator_->Authenticate(
-      base::Bind(&ProximityAuthWebUIHandler::OnAuthenticationResult,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void ProximityAuthWebUIHandler::CreateStatusUpdateMessenger() {
-  messenger_.reset(
-      new MessengerImpl(connection_.Pass(), secure_context_.Pass()));
-  messenger_->AddObserver(this);
+  life_cycle_.reset(new RemoteDeviceLifeCycleImpl(selected_remote_device_,
+                                                  proximity_auth_client_));
+  life_cycle_->AddObserver(this);
+  life_cycle_->Start();
 }
 
 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.
   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
@@ skipping 21 matching lines @@
       [&public_key](const cryptauth::ExternalDeviceInfo& unlock_key) {
         return unlock_key.public_key() == public_key;
       });
 
   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->IsConnected()) {
+  if (life_cycle_ &&
+      life_cycle_->GetState() ==
+          RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
     connection_status = kExternalDeviceConnected;
-  } else if (connection_finder_) {
+  } else if (life_cycle_) {
     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 16 matching lines @@
     ineligibility_reasons->AppendString(reason);
   }
 
   scoped_ptr<base::DictionaryValue> device_dictionary =
       ExternalDeviceInfoToDictionary(ineligible_device.device());
   device_dictionary->Set(kIneligibleDeviceReasons,
                          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;
+void ProximityAuthWebUIHandler::CleanUpRemoteDeviceLifeCycle() {
+  PA_LOG(INFO) << "Cleaning up connection to " << selected_remote_device_.name
+               << " [" << selected_remote_device_.bluetooth_address << "]";
+  life_cycle_.reset();
+  selected_remote_device_ = RemoteDevice();
+  last_remote_status_update_.reset();
+  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
+                                   *GetUnlockKeysList());
+}
 
-  if (new_status == Connection::DISCONNECTED) {
-    last_remote_status_update_.reset();
-    selected_remote_device_ = RemoteDevice();
-    connection_finder_.reset();
+void ProximityAuthWebUIHandler::OnLifeCycleStateChanged(
+    RemoteDeviceLifeCycle::State old_state,
+    RemoteDeviceLifeCycle::State new_state) {
+  // Do not re-attempt to find a connection after the first one fails--just
+  // abort.
+  if ((old_state != RemoteDeviceLifeCycle::State::STOPPED &&
+       new_state == RemoteDeviceLifeCycle::State::FINDING_CONNECTION) ||
+      new_state == RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED) {
+    // Clean up the life cycle asynchronously, because we are currently in the
+    // call stack of |life_cycle_|.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(&ProximityAuthWebUIHandler::CleanUpRemoteDeviceLifeCycle,
+                   weak_ptr_factory_.GetWeakPtr()));
+  } else if (new_state ==
+             RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
+    life_cycle_->GetMessenger()->AddObserver(this);
   }
 
-  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;
-  PA_LOG(INFO) << "Message received from " << address;
+                                   *GetUnlockKeysList());
 }
 
 void ProximityAuthWebUIHandler::OnRemoteStatusUpdate(
     const RemoteStatusUpdate& status_update) {
   PA_LOG(INFO) << "Remote status update:"
                << "\n  user_presence: "
                << static_cast<int>(status_update.user_presence)
                << "\n  secure_screen_lock_state: "
                << static_cast<int>(status_update.secure_screen_lock_state)
                << "\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