Hook up ProximityAuthSystem in EasyUnlockService.

components/proximity_auth/unlock_manager.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/unlock_manager.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 62 matching lines @@
   return metrics::RemoteSecuritySettingsState::UNKNOWN;
 }
 
 }  // namespace
 
 UnlockManager::UnlockManager(ScreenlockType screenlock_type,
                              scoped_ptr<ProximityMonitor> proximity_monitor,
                              ProximityAuthClient* proximity_auth_client)
     : screenlock_type_(screenlock_type),
       life_cycle_(nullptr),
-      messenger_(nullptr),
       proximity_monitor_(proximity_monitor.Pass()),
       proximity_auth_client_(proximity_auth_client),
       is_locked_(false),
       is_attempting_auth_(false),
       is_waking_up_(false),
       screenlock_state_(ScreenlockState::INACTIVE),
       clear_waking_up_state_weak_ptr_factory_(this),
       reject_auth_attempt_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
   // TODO(isherman): Register for auth attempt notifications, equivalent to the
@@ skipping 12 matching lines @@
   SetWakingUpState(true);
 
   if (device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     device::BluetoothAdapterFactory::GetAdapter(
         base::Bind(&UnlockManager::OnBluetoothAdapterInitialized,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 UnlockManager::~UnlockManager() {
-  if (messenger_)
-    messenger_->RemoveObserver(this);
+  if (GetMessenger())
+    GetMessenger()->RemoveObserver(this);
 
   ScreenlockBridge::Get()->RemoveObserver(this);
 
 #if defined(OS_CHROMEOS)
   DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
 #endif  // defined(OS_CHROMEOS)
 
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 bool UnlockManager::IsUnlockAllowed() {
   return (remote_screenlock_state_ &&
           *remote_screenlock_state_ == RemoteScreenlockState::UNLOCKED &&
           life_cycle_ &&
           life_cycle_->GetState() ==
               RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED &&
           proximity_monitor_->IsUnlockAllowed() &&
           (screenlock_type_ != ScreenlockType::SIGN_IN ||
-           (messenger_ && messenger_->SupportsSignIn())));
+           (GetMessenger() && GetMessenger()->SupportsSignIn())));
 }
 
 void UnlockManager::SetRemoteDeviceLifeCycle(
     RemoteDeviceLifeCycle* life_cycle) {
-  if (messenger_) {
-    messenger_->RemoveObserver(this);
-    messenger_ = nullptr;
-  }
+  if (GetMessenger())
+    GetMessenger()->RemoveObserver(this);
 
   life_cycle_ = life_cycle;
   if (life_cycle_)
     SetWakingUpState(true);
 
   UpdateLockScreen();
 }
 
 void UnlockManager::OnLifeCycleStateChanged() {
   RemoteDeviceLifeCycle::State state = life_cycle_->GetState();
   PA_LOG(INFO) << "[Unlock] RemoteDeviceLifeCycle state changed: "
                << static_cast<int>(state);
 
   remote_screenlock_state_.reset();
-  if (state == RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
-    messenger_ = life_cycle_->GetMessenger();
-    messenger_->AddObserver(this);
-  }
+  if (state == RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED)
+    GetMessenger()->AddObserver(this);
 
   if (state == RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED)
     SetWakingUpState(false);
 
   UpdateLockScreen();
 }
 
 void UnlockManager::OnUnlockEventSent(bool success) {
   if (!is_attempting_auth_) {
     PA_LOG(ERROR) << "[Unlock] Sent easy_unlock event, but no auth attempted.";
@@ skipping 28 matching lines @@
     PA_LOG(ERROR) << "[Unlock] Decrypt response received but not attempting "
                   << "auth.";
     return;
   }
 
   if (!decrypted_bytes) {
     PA_LOG(INFO) << "[Unlock] Failed to decrypt sign-in challenge.";
     AcceptAuthAttempt(false);
   } else {
     sign_in_secret_ = decrypted_bytes.Pass();
-    messenger_->DispatchUnlockEvent();
+    GetMessenger()->DispatchUnlockEvent();
   }
 }
 
 void UnlockManager::OnUnlockResponse(bool success) {
   if (!is_attempting_auth_) {
     PA_LOG(ERROR) << "[Unlock] Unlock response received but not attempting "
                   << "auth.";
     return;
   }
 
   PA_LOG(INFO) << "[Unlock] Unlock response from remote device: "
                << (success ? "success" : "failure");
   if (success)
-    messenger_->DispatchUnlockEvent();
+    GetMessenger()->DispatchUnlockEvent();
   else
     AcceptAuthAttempt(false);
 }
 
 void UnlockManager::OnDisconnected() {
-  messenger_->RemoveObserver(this);
-  messenger_ = nullptr;
+  GetMessenger()->RemoveObserver(this);
 }
 
 void UnlockManager::OnScreenDidLock(
     ScreenlockBridge::LockHandler::ScreenType screen_type) {
   OnScreenLockedOrUnlocked(true);
 }
 
 void UnlockManager::OnScreenDidUnlock(
     ScreenlockBridge::LockHandler::ScreenType screen_type) {
   OnScreenLockedOrUnlocked(false);
@@ skipping 65 matching lines @@
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&UnlockManager::AcceptAuthAttempt,
                  reject_auth_attempt_weak_ptr_factory_.GetWeakPtr(), false),
       base::TimeDelta::FromSeconds(kAuthAttemptTimeoutSecs));
 
   if (screenlock_type_ == ScreenlockType::SIGN_IN) {
     SendSignInChallenge();
   } else {
-    if (messenger_->SupportsSignIn()) {
-      messenger_->RequestUnlock();
+    if (GetMessenger()->SupportsSignIn()) {
+      GetMessenger()->RequestUnlock();
     } else {
       PA_LOG(INFO) << "[Unlock] Protocol v3.1 not supported, skipping "
                    << "request_unlock.";
-      messenger_->DispatchUnlockEvent();
+      GetMessenger()->DispatchUnlockEvent();
     }
   }
 }
 
 void UnlockManager::SendSignInChallenge() {
   // TODO(isherman): Implement.
   NOTIMPLEMENTED();
 }
 
 ScreenlockState UnlockManager::GetScreenlockState() {
   if (!life_cycle_ ||
       life_cycle_->GetState() == RemoteDeviceLifeCycle::State::STOPPED)
     return ScreenlockState::INACTIVE;
 
   if (IsUnlockAllowed())
     return ScreenlockState::AUTHENTICATED;
 
   if (life_cycle_->GetState() ==
       RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED)
     return ScreenlockState::PHONE_NOT_AUTHENTICATED;
 
   if (is_waking_up_)
     return ScreenlockState::BLUETOOTH_CONNECTING;
 
   if (!bluetooth_adapter_ || !bluetooth_adapter_->IsPowered())
     return ScreenlockState::NO_BLUETOOTH;
 
-  if (screenlock_type_ == ScreenlockType::SIGN_IN && messenger_ &&
-      !messenger_->SupportsSignIn())
+  Messenger* messenger = GetMessenger();
+  if (screenlock_type_ == ScreenlockType::SIGN_IN && messenger &&
+      !messenger->SupportsSignIn())
     return ScreenlockState::PHONE_UNSUPPORTED;
 
   // If the RSSI is too low, then the remote device is nowhere near the local
   // device. This message should take priority over messages about screen lock
   // states.
   if (!proximity_monitor_->IsUnlockAllowed() &&
       !proximity_monitor_->IsInRssiRange())
     return ScreenlockState::RSSI_TOO_LOW;
 
   if (remote_screenlock_state_) {
@@ skipping 33 matching lines @@
   return ScreenlockState::NO_PHONE;
 }
 
 void UnlockManager::UpdateLockScreen() {
   UpdateProximityMonitorState();
 
   ScreenlockState new_state = GetScreenlockState();
   if (screenlock_state_ == new_state)
     return;
 
+  PA_LOG(ERROR) << "UPDATE LOCK SCREEN: " << static_cast<int>(new_state);
   proximity_auth_client_->UpdateScreenlockState(new_state);
   screenlock_state_ = new_state;
 }
 
 void UnlockManager::UpdateProximityMonitorState() {
   if (is_locked_ && life_cycle_ &&
       life_cycle_->GetState() ==
           RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
     proximity_monitor_->Start();
   } else {
@@ skipping 44 matching lines @@
       return RemoteScreenlockState::LOCKED;
 
     case SECURE_SCREEN_LOCK_STATE_UNKNOWN:
       return RemoteScreenlockState::UNKNOWN;
   }
 
   NOTREACHED();
   return RemoteScreenlockState::UNKNOWN;
 }
 
+Messenger* UnlockManager::GetMessenger() {
+  // TODO(tengs): We should use a weak pointer to hold the Messenger instance
+  // instead.
+  if (!life_cycle_)
+    return nullptr;
+  return life_cycle_->GetMessenger();
+}
+
 }  // namespace proximity_auth