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

components/proximity_auth/unlock_manager_impl_unittest.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 <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/cryptauth/cryptauth_test_util.h"
+#include "components/cryptauth/fake_connection.h"
 #include "components/cryptauth/fake_secure_context.h"
 #include "components/cryptauth/secure_context.h"
 #include "components/proximity_auth/fake_lock_handler.h"
+#include "components/proximity_auth/fake_remote_device_life_cycle.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/mock_proximity_auth_client.h"
 #include "components/proximity_auth/proximity_monitor.h"
 #include "components/proximity_auth/remote_device_life_cycle.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/screenlock_bridge.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 30 matching lines @@
 
 class MockRemoteDeviceLifeCycle : public RemoteDeviceLifeCycle {
  public:
   MockRemoteDeviceLifeCycle() {}
   ~MockRemoteDeviceLifeCycle() override {}
 
   MOCK_METHOD0(Start, void());
   MOCK_CONST_METHOD0(GetRemoteDevice, cryptauth::RemoteDevice());
   MOCK_CONST_METHOD0(GetState, State());
   MOCK_METHOD0(GetMessenger, Messenger*());
+  MOCK_CONST_METHOD0(GetConnection, cryptauth::Connection*());
   MOCK_METHOD1(AddObserver, void(Observer*));
   MOCK_METHOD1(RemoveObserver, void(Observer*));
 };
 
 class MockMessenger : public Messenger {
  public:
   MockMessenger() {}
   ~MockMessenger() override {}
 
   MOCK_METHOD1(AddObserver, void(MessengerObserver* observer));
   MOCK_METHOD1(RemoveObserver, void(MessengerObserver* observer));
   MOCK_CONST_METHOD0(SupportsSignIn, bool());
   MOCK_METHOD0(DispatchUnlockEvent, void());
   MOCK_METHOD1(RequestDecryption, void(const std::string& challenge));
   MOCK_METHOD0(RequestUnlock, void());
   MOCK_CONST_METHOD0(GetSecureContext, cryptauth::SecureContext*());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMessenger);
 };
 
 class MockProximityMonitor : public ProximityMonitor {
  public:
-  MockProximityMonitor() {
-    ON_CALL(*this, GetStrategy())
-        .WillByDefault(Return(ProximityMonitor::Strategy::NONE));
+  MockProximityMonitor() : started_(false), stopped_(false) {
     ON_CALL(*this, IsUnlockAllowed()).WillByDefault(Return(true));
-    ON_CALL(*this, IsInRssiRange()).WillByDefault(Return(false));
   }
   ~MockProximityMonitor() override {}
 
-  MOCK_METHOD0(Start, void());
-  MOCK_METHOD0(Stop, void());
-  MOCK_CONST_METHOD0(GetStrategy, Strategy());
+  void Start() override { started_ = true; }
+  void Stop() override { stopped_ = true; }
   MOCK_CONST_METHOD0(IsUnlockAllowed, bool());
-  MOCK_CONST_METHOD0(IsInRssiRange, bool());
   MOCK_METHOD0(RecordProximityMetricsOnAuthSuccess, void());
   MOCK_METHOD1(AddObserver, void(ProximityMonitorObserver*));
   MOCK_METHOD1(RemoveObserver, void(ProximityMonitorObserver*));
 
+  bool started() { return started_; }
+  bool stopped() { return stopped_; }
+
  private:
+  bool started_;
+  bool stopped_;
+
   DISALLOW_COPY_AND_ASSIGN(MockProximityMonitor);
 };
 
 class TestUnlockManager : public UnlockManagerImpl {
  public:
   TestUnlockManager(ProximityAuthSystem::ScreenlockType screenlock_type,
                     ProximityAuthClient* proximity_auth_client)
       : UnlockManagerImpl(screenlock_type, proximity_auth_client),
         proximity_monitor_(nullptr) {}
   ~TestUnlockManager() override {}
 
   using UnlockManager::OnAuthAttempted;
   using MessengerObserver::OnUnlockEventSent;
   using MessengerObserver::OnRemoteStatusUpdate;
   using MessengerObserver::OnDecryptResponse;
   using MessengerObserver::OnUnlockResponse;
   using MessengerObserver::OnDisconnected;
   using ScreenlockBridge::Observer::OnScreenDidLock;
   using ScreenlockBridge::Observer::OnScreenDidUnlock;
   using ScreenlockBridge::Observer::OnFocusedUserChanged;
 
   MockProximityMonitor* proximity_monitor() { return proximity_monitor_; }
 
  private:
   std::unique_ptr<ProximityMonitor> CreateProximityMonitor(
-      const cryptauth::RemoteDevice& remote_device) override {
-    EXPECT_EQ(cryptauth::kTestRemoteDevicePublicKey, remote_device.public_key);
+      cryptauth::Connection* connection) override {
+    EXPECT_EQ(cryptauth::kTestRemoteDevicePublicKey,
+              connection->remote_device().public_key);
     std::unique_ptr<MockProximityMonitor> proximity_monitor(
         new NiceMock<MockProximityMonitor>());
     proximity_monitor_ = proximity_monitor.get();
     return std::move(proximity_monitor);
   }
 
   // Owned by the super class.
   MockProximityMonitor* proximity_monitor_;
 
   DISALLOW_COPY_AND_ASSIGN(TestUnlockManager);
 };
 
 // Creates a mock Bluetooth adapter and sets it as the global adapter for
 // testing.
 scoped_refptr<device::MockBluetoothAdapter>
 CreateAndRegisterMockBluetoothAdapter() {
   scoped_refptr<device::MockBluetoothAdapter> adapter =
       new NiceMock<device::MockBluetoothAdapter>();
   device::BluetoothAdapterFactory::SetAdapterForTesting(adapter);
   return adapter;
 }
 
 }  // namespace
 
 class ProximityAuthUnlockManagerImplTest : public testing::Test {
  public:
   ProximityAuthUnlockManagerImplTest()
       : remote_device_(cryptauth::CreateClassicRemoteDeviceForTest()),
+        life_cycle_(remote_device_),
+        connection_(remote_device_),
         bluetooth_adapter_(CreateAndRegisterMockBluetoothAdapter()),
         task_runner_(new base::TestSimpleTaskRunner()),
         thread_task_runner_handle_(task_runner_) {
     ON_CALL(*bluetooth_adapter_, IsPowered()).WillByDefault(Return(true));
-    ON_CALL(life_cycle_, GetMessenger()).WillByDefault(Return(&messenger_));
-    ON_CALL(life_cycle_, GetRemoteDevice())
-        .WillByDefault(Return(remote_device_));
     ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
     ON_CALL(messenger_, GetSecureContext())
         .WillByDefault(Return(&secure_context_));
 
+    life_cycle_.set_connection(&connection_);
+    life_cycle_.set_messenger(&messenger_);
     ScreenlockBridge::Get()->SetLockHandler(&lock_handler_);
 
 #if defined(OS_CHROMEOS)
     chromeos::DBusThreadManager::Initialize();
 #endif
   }
 
   ~ProximityAuthUnlockManagerImplTest() override {
     // Make sure to verify the mock prior to the destruction of the unlock
     // manager, as otherwise it's impossible to tell whether calls to Stop()
@@ skipping 14 matching lines @@
     ScreenlockBridge::Get()->SetLockHandler(nullptr);
   }
 
   void CreateUnlockManager(
       ProximityAuthSystem::ScreenlockType screenlock_type) {
     unlock_manager_.reset(
         new TestUnlockManager(screenlock_type, &proximity_auth_client_));
   }
 
   void SimulateUserPresentState() {
-    ON_CALL(life_cycle_, GetState())
-        .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
     unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
-
-    ON_CALL(life_cycle_, GetState())
-        .WillByDefault(
-            Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
+    life_cycle_.ChangeState(
+        RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
     unlock_manager_->OnLifeCycleStateChanged();
-
     unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
   }
 
   void RunPendingTasks() { task_runner_->RunPendingTasks(); }
 
   MockProximityMonitor* proximity_monitor() {
     return unlock_manager_ ? unlock_manager_->proximity_monitor() : nullptr;
   }
 
  protected:
   cryptauth::RemoteDevice remote_device_;
+  FakeRemoteDeviceLifeCycle life_cycle_;
+  cryptauth::FakeConnection connection_;
 
   // Mock used for verifying interactions with the Bluetooth subsystem.
   scoped_refptr<device::MockBluetoothAdapter> bluetooth_adapter_;
 
   NiceMock<MockProximityAuthClient> proximity_auth_client_;
-  NiceMock<MockRemoteDeviceLifeCycle> life_cycle_;
   NiceMock<MockMessenger> messenger_;
   std::unique_ptr<TestUnlockManager> unlock_manager_;
   cryptauth::FakeSecureContext secure_context_;
 
  private:
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
   FakeLockHandler lock_handler_;
   ScopedDisableLoggingForTesting disable_logging_;
 };
 
 TEST_F(ProximityAuthUnlockManagerImplTest, IsUnlockAllowed_InitialState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_SessionLock_AllGood) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
 
   EXPECT_TRUE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, IsUnlockAllowed_SignIn_AllGood) {
   CreateUnlockManager(ProximityAuthSystem::SIGN_IN);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
   unlock_manager_->OnLifeCycleStateChanged();
 
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(true));
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
 
   EXPECT_TRUE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_SignIn_MessengerDoesNotSupportSignIn) {
   CreateUnlockManager(ProximityAuthSystem::SIGN_IN);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
   unlock_manager_->OnLifeCycleStateChanged();
 
   ON_CALL(messenger_, SupportsSignIn()).WillByDefault(Return(false));
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
-       IsUnlockAllowed_SignIn_MessengerIsNull) {
-  CreateUnlockManager(ProximityAuthSystem::SIGN_IN);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
-  ON_CALL(life_cycle_, GetMessenger()).WillByDefault(Return(nullptr));
-  unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
-  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
-
-  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
-}
-
-TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_DisallowedByProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
-  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
 
   ON_CALL(*proximity_monitor(), IsUnlockAllowed()).WillByDefault(Return(false));
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_SecureChannelNotEstablished) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::AUTHENTICATING));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::AUTHENTICATING);
+  unlock_manager_->OnLifeCycleStateChanged();
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_RemoteDeviceLifeCycleIsNull) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_RemoteScreenlockStateLocked) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenLocked);
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_RemoteScreenlockStateUnknown) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenlockStateUnknown);
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_RemoteScreenlockStateDisabled) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
   unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenlockDisabled);
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        IsUnlockAllowed_RemoteScreenlockStateNotYetReceived) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
 
   EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, SetRemoteDeviceLifeCycle_SetToNull) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::INACTIVE));
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        SetRemoteDeviceLifeCycle_ExistingRemoteDeviceLifeCycle) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(proximity_auth_client_, UpdateScreenlockState(_)).Times(0);
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
-       SetRemoteDeviceLifeCycle_NullThenExistingRemoteDeviceLifeCycle) {
-  CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
-  SimulateUserPresentState();
-
-  EXPECT_CALL(proximity_auth_client_,
-              UpdateScreenlockState(ScreenlockState::INACTIVE));
-  unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
-
-  EXPECT_CALL(proximity_auth_client_,
-              UpdateScreenlockState(ScreenlockState::AUTHENTICATED));
-  unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
-}
-
-TEST_F(ProximityAuthUnlockManagerImplTest,
        SetRemoteDeviceLifeCycle_AuthenticationFailed) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED);
+
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::PHONE_NOT_AUTHENTICATED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, SetRemoteDeviceLifeCycle_WakingUp) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::FINDING_CONNECTION));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
+
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        SetRemoteDeviceLifeCycle_NullRemoteDeviceLifeCycle_NoProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
 }
 
 TEST_F(
     ProximityAuthUnlockManagerImplTest,
     SetRemoteDeviceLifeCycle_ConnectingRemoteDeviceLifeCycle_StopsProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::FINDING_CONNECTION));
-
-  EXPECT_CALL(*proximity_monitor(), Stop()).Times(AtLeast(1));
   unlock_manager_->OnLifeCycleStateChanged();
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
+  unlock_manager_->OnLifeCycleStateChanged();
+  EXPECT_TRUE(proximity_monitor()->stopped());
 }
 
 TEST_F(
     ProximityAuthUnlockManagerImplTest,
     SetRemoteDeviceLifeCycle_ConnectedRemoteDeviceLifeCycle_StartsProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
-  EXPECT_CALL(*proximity_monitor(), Start()).Times(AtLeast(1));
   unlock_manager_->OnLifeCycleStateChanged();
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
+  EXPECT_TRUE(proximity_monitor()->started());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_SecureChannelEstablished_RegistersAsObserver) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
   EXPECT_CALL(messenger_, AddObserver(unlock_manager_.get()));
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_StartsProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
-  EXPECT_CALL(*proximity_monitor(), Start()).Times(AtLeast(1));
+  EXPECT_TRUE(proximity_monitor()->started());
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_StopsProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED));
-
-  EXPECT_CALL(*proximity_monitor(), Stop()).Times(AtLeast(1));
   unlock_manager_->OnLifeCycleStateChanged();
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED);
+  unlock_manager_->OnLifeCycleStateChanged();
+  EXPECT_TRUE(proximity_monitor()->stopped());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_Stopped_UpdatesScreenlockState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
-
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::INACTIVE));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::STOPPED);
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_AuthenticationFailed_UpdatesScreenlockState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED));
-
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::PHONE_NOT_AUTHENTICATED));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED);
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_FindingConnection_UpdatesScreenlockState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::FINDING_CONNECTION));
-
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnLifeCycleStateChanged_Authenticating_UpdatesScreenlockState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::AUTHENTICATING));
-
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::AUTHENTICATING);
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(
     ProximityAuthUnlockManagerImplTest,
     OnLifeCycleStateChanged_SecureChannelEstablished_UpdatesScreenlockState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
-
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
   unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnDisconnected_UnregistersAsObserver) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED));
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED);
+  unlock_manager_->OnLifeCycleStateChanged();
 
   EXPECT_CALL(messenger_, RemoveObserver(unlock_manager_.get()))
       .Times(testing::AtLeast(1));
   unlock_manager_.get()->OnDisconnected();
   unlock_manager_->SetRemoteDeviceLifeCycle(nullptr);
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnScreenDidUnlock_StopsProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
-  EXPECT_CALL(*proximity_monitor(), Stop());
   unlock_manager_.get()->OnScreenDidUnlock(
       ScreenlockBridge::LockHandler::LOCK_SCREEN);
+  EXPECT_TRUE(proximity_monitor()->stopped());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnScreenDidLock_StartsProximityMonitor) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
-
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::STOPPED));
   unlock_manager_->SetRemoteDeviceLifeCycle(&life_cycle_);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(
-          Return(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED));
-  unlock_manager_->OnLifeCycleStateChanged();
-
-  EXPECT_CALL(*proximity_monitor(), Start());
   unlock_manager_.get()->OnScreenDidLock(
       ScreenlockBridge::LockHandler::LOCK_SCREEN);
+
+  life_cycle_.ChangeState(
+      RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
+  unlock_manager_->OnLifeCycleStateChanged();
+  EXPECT_TRUE(proximity_monitor()->started());
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest, OnScreenDidLock_SetsWakingUpState) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   unlock_manager_.get()->OnScreenDidUnlock(
       ScreenlockBridge::LockHandler::LOCK_SCREEN);
 
-  ON_CALL(life_cycle_, GetState())
-      .WillByDefault(Return(RemoteDeviceLifeCycle::State::FINDING_CONNECTION));
-  unlock_manager_->OnLifeCycleStateChanged();
-
   EXPECT_CALL(proximity_auth_client_,
               UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
-  unlock_manager_.get()->OnScreenDidLock(
-      ScreenlockBridge::LockHandler::LOCK_SCREEN);
+
+  life_cycle_.ChangeState(RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
+  unlock_manager_->OnLifeCycleStateChanged();
 }
 
 TEST_F(ProximityAuthUnlockManagerImplTest,
        OnDecryptResponse_NoAuthAttemptInProgress) {
   CreateUnlockManager(ProximityAuthSystem::SESSION_LOCK);
   SimulateUserPresentState();
 
   EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
   unlock_manager_.get()->OnDecryptResponse(kSignInSecret);
 }
@@ skipping 228 matching lines @@
           }));
 
   EXPECT_CALL(messenger_, RequestDecryption(kChallenge));
   unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeSignin(std::string()));
   unlock_manager_->OnDecryptResponse(std::string());
 }
 
 }  // namespace proximity_auth