[EasyUnlock] Update ProximityMonitor to only check for RSSI proximity.

components/proximity_auth/unlock_manager_impl.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_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 123 matching lines @@
            (GetMessenger() && GetMessenger()->SupportsSignIn())));
 }
 
 void UnlockManagerImpl::SetRemoteDeviceLifeCycle(
     RemoteDeviceLifeCycle* life_cycle) {
   if (GetMessenger())
     GetMessenger()->RemoveObserver(this);
 
   life_cycle_ = life_cycle;
   if (life_cycle_) {
-    proximity_monitor_ = CreateProximityMonitor(life_cycle->GetRemoteDevice());
     SetWakingUpState(true);
   } else {
     proximity_monitor_.reset();
   }
 
   UpdateLockScreen();
 }
 
 void UnlockManagerImpl::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)
+  if (state == RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
+    DCHECK(life_cycle_->GetConnection());
+    DCHECK(GetMessenger());
+    proximity_monitor_ = CreateProximityMonitor(life_cycle_->GetConnection());
     GetMessenger()->AddObserver(this);
+  }
 
   if (state == RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED)
     SetWakingUpState(false);
 
   UpdateLockScreen();
 }
 
 void UnlockManagerImpl::OnUnlockEventSent(bool success) {
   if (!is_attempting_auth_) {
     PA_LOG(ERROR) << "[Unlock] Sent easy_unlock event, but no auth attempted.";
@@ skipping 142 matching lines @@
       GetMessenger()->RequestUnlock();
     } else {
       PA_LOG(INFO) << "[Unlock] Protocol v3.1 not supported, skipping "
                    << "request_unlock.";
       GetMessenger()->DispatchUnlockEvent();
     }
   }
 }
 
 std::unique_ptr<ProximityMonitor> UnlockManagerImpl::CreateProximityMonitor(
-    const cryptauth::RemoteDevice& remote_device) {
+    cryptauth::Connection* connection) {
   return base::MakeUnique<ProximityMonitorImpl>(
-      remote_device, base::WrapUnique(new base::DefaultTickClock()));
+      connection, base::WrapUnique(new base::DefaultTickClock()));
 }
 
 void UnlockManagerImpl::SendSignInChallenge() {
   if (!life_cycle_ || !GetMessenger() || !GetMessenger()->GetSecureContext()) {
     PA_LOG(ERROR) << "Not ready to send sign-in challenge";
     return;
   }
 
   cryptauth::RemoteDevice remote_device = life_cycle_->GetRemoteDevice();
   proximity_auth_client_->GetChallengeForUserAndDevice(
@@ skipping 13 matching lines @@
       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_)
+  if (is_waking_up_ ||
+      life_cycle_->GetState() == RemoteDeviceLifeCycle::State::AUTHENTICATING ||
+      life_cycle_->GetState() ==
+          RemoteDeviceLifeCycle::State::FINDING_CONNECTION)
     return ScreenlockState::BLUETOOTH_CONNECTING;
 
   if (!bluetooth_adapter_ || !bluetooth_adapter_->IsPowered())
     return ScreenlockState::NO_BLUETOOTH;
 
   Messenger* messenger = GetMessenger();
   if (screenlock_type_ == ProximityAuthSystem::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())
+  if (!proximity_monitor_->IsUnlockAllowed())
     return ScreenlockState::RSSI_TOO_LOW;
 
   if (remote_screenlock_state_) {
     switch (*remote_screenlock_state_) {
       case RemoteScreenlockState::DISABLED:
         return ScreenlockState::PHONE_NOT_LOCKABLE;
 
       case RemoteScreenlockState::LOCKED:
-        if (proximity_monitor_->GetStrategy() ==
-                ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER &&
-            !proximity_monitor_->IsUnlockAllowed()) {
-          return ScreenlockState::PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
-        }
         return ScreenlockState::PHONE_LOCKED;
 
       case RemoteScreenlockState::UNKNOWN:
         return ScreenlockState::PHONE_UNSUPPORTED;
 
       case RemoteScreenlockState::UNLOCKED:
         // Handled by the code below.
         break;
     }
   }
 
-  if (!proximity_monitor_->IsUnlockAllowed()) {
-    ProximityMonitor::Strategy strategy = proximity_monitor_->GetStrategy();
-    if (strategy != ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER) {
-      // CHECK_RSSI should have been handled above, and no other states should
-      // prevent unlocking.
-      PA_LOG(ERROR) << "[Unlock] Invalid ProximityMonitor strategy: "
-                    << static_cast<int>(strategy);
-      return ScreenlockState::NO_PHONE;
-    }
-    return ScreenlockState::TX_POWER_TOO_HIGH;
-  }
-
   return ScreenlockState::NO_PHONE;
 }
 
 void UnlockManagerImpl::UpdateLockScreen() {
   UpdateProximityMonitorState();
 
   ScreenlockState new_state = GetScreenlockState();
   if (screenlock_state_ == new_state)
     return;
 
@@ skipping 74 matching lines @@
 
 Messenger* UnlockManagerImpl::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