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 59 matching lines @@
 
   if (!IsUnlockAllowed()) {
     AcceptAuthAttempt(false);
     UpdateLockScreen();
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&UnlockManager::AcceptAuthAttempt,
                  reject_auth_attempt_weak_ptr_factory_.GetWeakPtr(), false),

[sacomoto, 2015/10/01 16:09:08]

It should be "true" here.

[sacomoto, 2015/10/01 16:56:47]

Oh, I see the issue here, it's my fault. The unlock protocol is sightly
different than what I was assuming. 

Even if the phone already sent a message saying it's unlocked CrOS sends a
message "unlock_request" message and only unlocks after receiving an
"unlock_response" message, right? 

I can implement it on the iOS app tomorrow, it should not be hard. 

But I think it's not worth it. We are already sending the screen status every
few seconds, and when it changes while we are connected. Moreover, these two
extra messages would add an extra delay to the (already slow) unlock process. 

What do you think? What if for BLE devices we unlocked directly whenever the
screen is unlocked?

       base::TimeDelta::FromSeconds(kAuthAttemptTimeoutSecs));

[sacomoto, 2015/10/01 16:09:08]

Why do you need this delay?

[sacomoto, 2015/10/01 16:56:47]

Please disregard this comment.

 
   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 97 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