[EasyUnlock] Observe proximity changes and clean up TX power strategy.

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 133 matching lines @@
     SetWakingUpState(true);
   } else {
     proximity_monitor_.reset();
   }
 
   UpdateLockScreen();
 }
 
 void UnlockManagerImpl::OnLifeCycleStateChanged() {
   RemoteDeviceLifeCycle::State state = life_cycle_->GetState();
-  PA_LOG(INFO) << "[Unlock] RemoteDeviceLifeCycle state changed: "
+  PA_LOG(INFO) << "RemoteDeviceLifeCycle state changed: "
                << static_cast<int>(state);
 
   remote_screenlock_state_.reset();
   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.";
+    PA_LOG(ERROR) << "Sent easy_unlock event, but no auth attempted.";
     return;
   }
 
   AcceptAuthAttempt(success);
 }
 
 void UnlockManagerImpl::OnRemoteStatusUpdate(
     const RemoteStatusUpdate& status_update) {
-  PA_LOG(INFO) << "[Unlock] Status Update: ("
+  PA_LOG(INFO) << "Status Update: ("
                << "user_present=" << status_update.user_presence << ", "
                << "secure_screen_lock="
                << status_update.secure_screen_lock_state << ", "
                << "trust_agent=" << status_update.trust_agent_state << ")";
   metrics::RecordRemoteSecuritySettingsState(
       GetRemoteSecuritySettingsState(status_update));
 
   remote_screenlock_state_.reset(new RemoteScreenlockState(
       GetScreenlockStateFromRemoteUpdate(status_update)));
 
   // This also calls |UpdateLockScreen()|
   SetWakingUpState(false);
 }
 
 void UnlockManagerImpl::OnDecryptResponse(const std::string& decrypted_bytes) {
   if (!is_attempting_auth_) {
-    PA_LOG(ERROR) << "[Unlock] Decrypt response received but not attempting "
+    PA_LOG(ERROR) << "Decrypt response received but not attempting "
                   << "auth.";
     return;
   }
 
   if (decrypted_bytes.empty()) {
-    PA_LOG(WARNING) << "[Unlock] Failed to decrypt sign-in challenge.";
+    PA_LOG(WARNING) << "Failed to decrypt sign-in challenge.";
     AcceptAuthAttempt(false);
   } else {
     sign_in_secret_.reset(new std::string(decrypted_bytes));
     GetMessenger()->DispatchUnlockEvent();
   }
 }
 
 void UnlockManagerImpl::OnUnlockResponse(bool success) {
   if (!is_attempting_auth_) {
-    PA_LOG(ERROR) << "[Unlock] Unlock response received but not attempting "
+    PA_LOG(ERROR) << "Unlock response received but not attempting "
                   << "auth.";
     return;
   }
 
-  PA_LOG(INFO) << "[Unlock] Unlock response from remote device: "
+  PA_LOG(INFO) << "Unlock response from remote device: "
                << (success ? "success" : "failure");
   if (success)
     GetMessenger()->DispatchUnlockEvent();
   else
     AcceptAuthAttempt(false);
 }
 
 void UnlockManagerImpl::OnDisconnected() {
   GetMessenger()->RemoveObserver(this);
 }
 
+void UnlockManagerImpl::OnProximityStateChanged() {
+  PA_LOG(INFO) << "Proximity state changed.";
+  UpdateLockScreen();
+}
+
 void UnlockManagerImpl::OnScreenDidLock(
     ScreenlockBridge::LockHandler::ScreenType screen_type) {
   OnScreenLockedOrUnlocked(true);
 }
 
 void UnlockManagerImpl::OnScreenDidUnlock(
     ScreenlockBridge::LockHandler::ScreenType screen_type) {
   OnScreenLockedOrUnlocked(false);
 }
 
@@ skipping 32 matching lines @@
 
 #if defined(OS_CHROMEOS)
 void UnlockManagerImpl::SuspendDone(const base::TimeDelta& sleep_duration) {
   SetWakingUpState(true);
 }
 #endif  // defined(OS_CHROMEOS)
 
 void UnlockManagerImpl::OnAuthAttempted(
     ScreenlockBridge::LockHandler::AuthType auth_type) {
   if (is_attempting_auth_) {
-    PA_LOG(INFO) << "[Unlock] Already attempting auth.";
+    PA_LOG(INFO) << "Already attempting auth.";
     return;
   }
 
   if (auth_type != ScreenlockBridge::LockHandler::USER_CLICK)
     return;
 
   is_attempting_auth_ = true;
 
   if (!life_cycle_) {
-    PA_LOG(ERROR) << "[Unlock] No life_cycle active when auth is attempted";
+    PA_LOG(ERROR) << "No life_cycle active when auth is attempted";
     AcceptAuthAttempt(false);
     UpdateLockScreen();
     return;
   }
 
   if (!IsUnlockAllowed()) {
     AcceptAuthAttempt(false);
     UpdateLockScreen();
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&UnlockManagerImpl::AcceptAuthAttempt,
                  reject_auth_attempt_weak_ptr_factory_.GetWeakPtr(), false),
       base::TimeDelta::FromSeconds(kAuthAttemptTimeoutSecs));
 
   if (screenlock_type_ == ProximityAuthSystem::SIGN_IN) {
     SendSignInChallenge();
   } else {
     if (GetMessenger()->SupportsSignIn()) {
       GetMessenger()->RequestUnlock();
     } else {
-      PA_LOG(INFO) << "[Unlock] Protocol v3.1 not supported, skipping "
-                   << "request_unlock.";
+      PA_LOG(INFO) << "Protocol v3.1 not supported, skipping request_unlock.";
       GetMessenger()->DispatchUnlockEvent();
     }
   }
 }
 
 std::unique_ptr<ProximityMonitor> UnlockManagerImpl::CreateProximityMonitor(
     cryptauth::Connection* connection) {
   return base::MakeUnique<ProximityMonitorImpl>(
       connection, base::WrapUnique(new base::DefaultTickClock()));
 }
@@ skipping 39 matching lines @@
     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())
-    return ScreenlockState::RSSI_TOO_LOW;
+  if (!proximity_monitor_->IsUnlockAllowed()) {
+    if (remote_screenlock_state_ &&
+        *remote_screenlock_state_ == RemoteScreenlockState::UNLOCKED) {
+      return ScreenlockState::RSSI_TOO_LOW;
+    } else {
+      return ScreenlockState::PHONE_LOCKED_AND_RSSI_TOO_LOW;
+    }
+  }
 
   if (remote_screenlock_state_) {
     switch (*remote_screenlock_state_) {
       case RemoteScreenlockState::DISABLED:
         return ScreenlockState::PHONE_NOT_LOCKABLE;
 
       case RemoteScreenlockState::LOCKED:
         return ScreenlockState::PHONE_LOCKED;
 
       case RemoteScreenlockState::UNKNOWN:
         return ScreenlockState::PHONE_UNSUPPORTED;
 
       case RemoteScreenlockState::UNLOCKED:
         // Handled by the code below.
         break;
     }
   }
 
   return ScreenlockState::NO_PHONE;
 }
 
 void UnlockManagerImpl::UpdateLockScreen() {
   UpdateProximityMonitorState();
 
   ScreenlockState new_state = GetScreenlockState();
   if (screenlock_state_ == new_state)
     return;
 
+  PA_LOG(INFO) << "Updating screenlock state from "
+               << static_cast<int>(screenlock_state_) << " to "
+               << static_cast<int>(new_state);
   proximity_auth_client_->UpdateScreenlockState(new_state);
   screenlock_state_ = new_state;
 }
 
 void UnlockManagerImpl::UpdateProximityMonitorState() {
   if (!proximity_monitor_)
     return;
 
   if (is_locked_ && life_cycle_ &&
       life_cycle_->GetState() ==
           RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
+    proximity_monitor_->AddObserver(this);
     proximity_monitor_->Start();
   } else {
     proximity_monitor_->Stop();
   }
 }
 
 void UnlockManagerImpl::SetWakingUpState(bool is_waking_up) {
   is_waking_up_ = is_waking_up;
 
   // Clear the waking up state after a timeout.
@@ skipping 53 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