Add RemoteDeviceLoader to create RemoteDevice from CryptAuth data.

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/pref_names.h"
 #include "components/proximity_auth/bluetooth_connection_finder.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/logging/logging.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/remote_device_life_cycle_impl.h"
+#include "components/proximity_auth/remote_device_loader.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 {
@@ skipping 302 matching lines @@
     return;
   }
 
   for (const auto& unlock_key : device_manager->unlock_keys()) {
     if (unlock_key.public_key() == public_key) {
       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(),
-          base::Bind(&ProximityAuthWebUIHandler::OnPSKDerived,
-                     weak_ptr_factory_.GetWeakPtr(), unlock_key));
-
+      remote_device_loader_.reset(new RemoteDeviceLoader(
+          std::vector<cryptauth::ExternalDeviceInfo>(1, unlock_key),
+          proximity_auth_client_->GetAccountId(),
+          enrollment_manager->GetUserPrivateKey(),
+          proximity_auth_client_->CreateSecureMessageDelegate()));
+      remote_device_loader_->Load(
+          base::Bind(&ProximityAuthWebUIHandler::OnRemoteDevicesLoaded,
+                     weak_ptr_factory_.GetWeakPtr()));
       return;
     }
   }
 
   PA_LOG(ERROR) << "Unlock key (" << b64_public_key << ") not found";
 }
 
 void ProximityAuthWebUIHandler::OnCryptAuthClientError(
     const std::string& error_message) {
   PA_LOG(WARNING) << "CryptAuth request failed: " << error_message;
@@ skipping 88 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;
 }
 
-void ProximityAuthWebUIHandler::OnPSKDerived(
-    const cryptauth::ExternalDeviceInfo& unlock_key,
-    const std::string& persistent_symmetric_key) {
-  if (persistent_symmetric_key.empty()) {
+void ProximityAuthWebUIHandler::OnRemoteDevicesLoaded(
+    const std::vector<RemoteDevice>& remote_devices) {
+  if (remote_devices[0].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);
-
+  selected_remote_device_ = remote_devices[0];
   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;
@@ skipping 116 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