Hook up ProximityAuthSystem in EasyUnlockService.

chrome/browser/signin/easy_unlock_service_signin_chromeos.cc

 // Copyright 2014 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 "chrome/browser/signin/easy_unlock_service_signin_chromeos.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/signin/easy_unlock_app_manager.h"
 #include "chrome/browser/signin/easy_unlock_metrics.h"
 #include "chromeos/login/auth/user_context.h"
 #include "chromeos/tpm/tpm_token_loader.h"
+#include "components/proximity_auth/cryptauth/base64url.h"
+#include "components/proximity_auth/logging/logging.h"
+#include "components/proximity_auth/remote_device.h"
+#include "components/proximity_auth/switches.h"
 
 namespace {
 
 // The maximum allowed backoff interval when waiting for cryptohome to start.
 uint32 kMaxCryptohomeBackoffIntervalMs = 10000u;
 
 // If the data load fails, the initial interval after which the load will be
 // retried. Further intervals will exponentially increas by factor 2.
 uint32 kInitialCryptohomeBackoffIntervalMs = 200u;
 
@@ skipping 215 matching lines @@
          !user_id_.empty() &&
          !chromeos::LoginState::Get()->IsUserLoggedIn();
 }
 
 void EasyUnlockServiceSignin::OnWillFinalizeUnlock(bool success) {
   // This code path should only be exercised for the lock screen, not for the
   // sign-in screen.
   NOTREACHED();
 }
 
-void EasyUnlockServiceSignin::OnSuspendDone() {
+void EasyUnlockServiceSignin::OnSuspendDoneInternal() {
   // Ignored.
 }
 
 void EasyUnlockServiceSignin::OnScreenDidLock(
     proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   // In production code, the screen type should always be the signin screen; but
   // in tests, the screen type might be different.
   if (screen_type !=
           proximity_auth::ScreenlockBridge::LockHandler::SIGNIN_SCREEN)
     return;
@@ skipping 103 matching lines @@
         hardlock_state == EasyUnlockScreenlockStateHandler::NO_HARDLOCK) {
       SetHardlockStateForUser(user_id,
                               EasyUnlockScreenlockStateHandler::NO_PAIRING);
     }
   }
 
   // If the fetched data belongs to the currently focused user, notify the app
   // that it has to refresh it's user data.
   if (user_id == user_id_)
     NotifyUserUpdated();
+
+  if (user_id != user_id || devices.empty())
+    return;
+
+  // TODO(tengs): Currently, ProximityAuthSystem only supports one device. Once
+  // multiple devices are supported, we need to load all devices.
+  std::string decoded_public_key, decoded_psk, decoded_challenge;
+  proximity_auth::Base64UrlDecode(devices[0].public_key, &decoded_public_key);
+  proximity_auth::Base64UrlDecode(devices[0].psk, &decoded_psk);
+  proximity_auth::Base64UrlDecode(devices[0].challenge, &decoded_challenge);
+
+  // TODO(tengs): We need to store the Bluetooth type with the TPM data.
+  proximity_auth::RemoteDevice::BluetoothType bluetooth_type =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery)
+          ? proximity_auth::RemoteDevice::BLUETOOTH_LE
+          : proximity_auth::RemoteDevice::BLUETOOTH_CLASSIC;
+
+  proximity_auth::RemoteDevice remote_device(
+      user_id, std::string(), decoded_public_key, bluetooth_type,
+      devices[0].bluetooth_address, decoded_psk, decoded_challenge);
+  PA_LOG(INFO) << "Loaded Remote Device:\n"
+               << "  user id: " << remote_device.user_id << "\n"
+               << "  name: " << remote_device.name << "\n"
+               << "  public key" << devices[0].public_key << "\n"
+               << "  bt_addr:" << remote_device.bluetooth_address;
+  OnRemoteDeviceChanged(&remote_device);
 }
 
 const EasyUnlockServiceSignin::UserData*
     EasyUnlockServiceSignin::FindLoadedDataForCurrentUser() const {
   if (user_id_.empty())
     return NULL;
 
   std::map<std::string, UserData*>::const_iterator it =
       user_data_.find(user_id_);
   if (it == user_data_.end())
     return NULL;
   if (it->second->state != USER_DATA_STATE_LOADED)
     return NULL;
   return it->second;
 }