Hook up ProximityAuthSystem in EasyUnlockService.

chrome/browser/signin/easy_unlock_service.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.h"
 
 #include "apps/app_lifetime_monitor.h"
 #include "apps/app_lifetime_monitor_factory.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/signin/chrome_proximity_auth_client.h"
 #include "chrome/browser/signin/easy_unlock_app_manager.h"
 #include "chrome/browser/signin/easy_unlock_service_factory.h"
 #include "chrome/browser/signin/easy_unlock_service_observer.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
-#include "components/proximity_auth/ble/proximity_auth_ble_system.h"
 #include "components/proximity_auth/cryptauth/cryptauth_client_impl.h"
 #include "components/proximity_auth/cryptauth/cryptauth_device_manager.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
 #include "components/proximity_auth/cryptauth/secure_message_delegate.h"
+#include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/proximity_auth_pref_manager.h"
+#include "components/proximity_auth/proximity_auth_system.h"
 #include "components/proximity_auth/screenlock_bridge.h"
 #include "components/proximity_auth/switches.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/user_manager/user.h"
 #include "components/version_info/version_info.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 227 matching lines @@
   registry->RegisterDictionaryPref(prefs::kEasyUnlockPairing,
                                    new base::DictionaryValue());
   registry->RegisterBooleanPref(
       prefs::kEasyUnlockProximityRequired,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 
   proximity_auth::CryptAuthGCMManager::RegisterPrefs(registry);
   proximity_auth::CryptAuthDeviceManager::RegisterPrefs(registry);
   proximity_auth::CryptAuthEnrollmentManager::RegisterPrefs(registry);
-  proximity_auth::ProximityAuthPrefManager::RegisterPrefs(registry);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery))
-    proximity_auth::ProximityAuthBleSystem::RegisterPrefs(registry);
+    proximity_auth::ProximityAuthPrefManager::RegisterPrefs(registry);
 }
 
 // static
 void EasyUnlockService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kEasyUnlockDeviceId, std::string());
   registry->RegisterDictionaryPref(prefs::kEasyUnlockHardlockState);
   registry->RegisterDictionaryPref(prefs::kEasyUnlockLocalStateUserPrefs);
 #if defined(OS_CHROMEOS)
   EasyUnlockTpmKeyManager::RegisterLocalStatePrefs(registry);
 #endif
@@ skipping 218 matching lines @@
     return;
   }
 
   CHECK_EQ(GetUserEmail(), user_id);
 
   auth_attempt_.reset(new EasyUnlockAuthAttempt(app_manager_.get(), user_id,
                                                 auth_attempt_type, callback));
   if (!auth_attempt_->Start())
     auth_attempt_.reset();
 
-  // TODO(tengs): We notify ProximityAuthBleSystem whenever unlock attempts are
+  // TODO(tengs): We notify ProximityAuthSystem whenever unlock attempts are
   // attempted. However, we ideally should refactor the auth attempt logic to
   // the proximity_auth component.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery) &&
       auth_attempt_type == EasyUnlockAuthAttempt::TYPE_UNLOCK &&
-      proximity_auth_ble_system_) {
-    proximity_auth_ble_system_->OnAuthAttempted(user_id);
+      proximity_auth_system_) {
+    proximity_auth_system_->OnAuthAttempted(user_id);
   }
 }
 
 void EasyUnlockService::FinalizeUnlock(bool success) {
   if (!auth_attempt_.get())
     return;
 
   this->OnWillFinalizeUnlock(success);
   auth_attempt_->FinalizeUnlock(GetUserEmail(), success);
   auth_attempt_.reset();
@@ skipping 96 matching lines @@
 
 void EasyUnlockService::Shutdown() {
   if (shut_down_)
     return;
   shut_down_ = true;
 
   ShutdownInternal();
 
   ResetScreenlockState();
   bluetooth_detector_.reset();
+  proximity_auth_system_.reset();
 #if defined(OS_CHROMEOS)
   power_monitor_.reset();
 #endif
 
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void EasyUnlockService::ReloadAppAndLockScreen() {
   // Make sure lock screen state set by the extension gets reset.
   ResetScreenlockState();
   app_manager_->ReloadApp();
   NotifyUserUpdated();
 }
 
 void EasyUnlockService::UpdateAppState() {
   if (IsAllowed()) {
     EnsureTpmKeyPresentIfNeeded();
     app_manager_->LoadApp();
     NotifyUserUpdated();
 
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery) &&
-        GetType() == EasyUnlockService::TYPE_REGULAR &&
-        !proximity_auth_ble_system_) {
-      proximity_auth_ble_system_.reset(
-          new proximity_auth::ProximityAuthBleSystem(
-              proximity_auth::ScreenlockBridge::Get(), &proximity_auth_client_,
-              profile_->GetPrefs()));
-    }
-
 #if defined(OS_CHROMEOS)
     if (!power_monitor_)
       power_monitor_.reset(new PowerMonitor(this));
 #endif
   } else {
     bool bluetooth_waking_up = false;
 #if defined(OS_CHROMEOS)
     // If the service is not allowed due to bluetooth not being detected just
     // after system suspend is done, give bluetooth more time to be detected
     // before disabling the app (and resetting screenlock state).
     bluetooth_waking_up =
         power_monitor_.get() && power_monitor_->waking_up() &&
         !bluetooth_detector_->IsPresent();
 #endif
 
     if (!bluetooth_waking_up) {
       app_manager_->DisableAppIfLoaded();
       ResetScreenlockState();
-      proximity_auth_ble_system_.reset();
+      proximity_auth_system_.reset();
 #if defined(OS_CHROMEOS)
       power_monitor_.reset();
 #endif
     }
   }
 }
 
 void EasyUnlockService::DisableAppWithoutResettingScreenlockState() {
   app_manager_->DisableAppIfLoaded();
 }
@@ skipping 121 matching lines @@
         return PASSWORD_ENTRY_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
       case ScreenlockState::AUTHENTICATED:
         return PASSWORD_ENTRY_WITH_AUTHENTICATED_PHONE;
     }
   }
 
   NOTREACHED();
   return EASY_UNLOCK_AUTH_EVENT_COUNT;
 }
 
+void EasyUnlockService::OnRemoteDeviceChanged(
+    const proximity_auth::RemoteDevice* remote_device) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery))
+    return;
+
+  if (remote_device) {
+    PA_LOG(INFO) << "Remote device changed, recreating ProximityAuthSystem.";
+    proximity_auth_system_.reset(new proximity_auth::ProximityAuthSystem(
+        *remote_device, proximity_auth_client()));
+    proximity_auth_system_->Start();
+  } else {
+    PA_LOG(INFO) << "Remote device removed, destroying ProximityAuthSystem.";
+    proximity_auth_system_.reset();
+  }
+}
+
 #if defined(OS_CHROMEOS)
 void EasyUnlockService::OnCryptohomeKeysFetchedForChecking(
     const std::string& user_id,
     const std::set<std::string> paired_devices,
     bool success,
     const chromeos::EasyUnlockDeviceKeyDataList& key_data_list) {
   DCHECK(!user_id.empty() && !paired_devices.empty());
 
   if (!success) {
     SetHardlockStateForUser(user_id,
@@ skipping 13 matching lines @@
             ? EasyUnlockScreenlockStateHandler::PAIRING_ADDED
             : EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
   }
 }
 #endif
 
 void EasyUnlockService::PrepareForSuspend() {
   app_manager_->DisableAppIfLoaded();
   if (screenlock_state_handler_ && screenlock_state_handler_->IsActive())
     UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING);
+  if (proximity_auth_system_)
+    proximity_auth_system_->OnSuspend();
+}
+
+void EasyUnlockService::OnSuspendDone() {
+  if (proximity_auth_system_)
+    proximity_auth_system_->OnSuspendDone();
 }
 
 void EasyUnlockService::EnsureTpmKeyPresentIfNeeded() {
   if (tpm_key_checked_ || GetType() != TYPE_REGULAR || GetUserEmail().empty() ||
       GetHardlockState() == EasyUnlockScreenlockStateHandler::NO_PAIRING) {
     return;
   }
 
 #if defined(OS_CHROMEOS)
   // If this is called before the session is started, the chances are Chrome
   // is restarting in order to apply user flags. Don't check TPM keys in this
   // case.
   if (!user_manager::UserManager::Get() ||
       !user_manager::UserManager::Get()->IsSessionStarted())
     return;
 
   // TODO(tbarzic): Set check_private_key only if previous sign-in attempt
   // failed.
   EasyUnlockTpmKeyManagerFactory::GetInstance()->Get(profile_)
       ->PrepareTpmKey(true /* check_private_key */,
                       base::Closure());
 #endif  // defined(OS_CHROMEOS)
 
   tpm_key_checked_ = true;
 }