Adding pref to store the user-selected proximity threshold.

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"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/cryptauth/secure_context.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/metrics.h"
 #include "components/proximity_auth/proximity_auth_client.h"
+#include "components/proximity_auth/proximity_auth_pref_manager.h"
 #include "components/proximity_auth/proximity_monitor_impl.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 
 using chromeos::DBusThreadManager;
 #endif  // defined(OS_CHROMEOS)
 
 namespace proximity_auth {
@@ skipping 42 matching lines @@
               SCREEN_LOCK_ENABLED_TRUST_AGENT_ENABLED;
       }
   }
 
   NOTREACHED();
   return metrics::RemoteSecuritySettingsState::UNKNOWN;
 }
 
 }  // namespace
 
+class ProximityAuthPrefManager;
+
 UnlockManagerImpl::UnlockManagerImpl(
     ProximityAuthSystem::ScreenlockType screenlock_type,
-    ProximityAuthClient* proximity_auth_client)
+    ProximityAuthClient* proximity_auth_client,
+    ProximityAuthPrefManager* pref_manager)
     : screenlock_type_(screenlock_type),
       life_cycle_(nullptr),
       proximity_auth_client_(proximity_auth_client),
+      pref_manager_(pref_manager),
       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) {
   ScreenlockBridge* screenlock_bridge = ScreenlockBridge::Get();
   screenlock_bridge->AddObserver(this);
   OnScreenLockedOrUnlocked(screenlock_bridge->IsLocked());
@@ skipping 52 matching lines @@
 
 void UnlockManagerImpl::OnLifeCycleStateChanged() {
   RemoteDeviceLifeCycle::State state = life_cycle_->GetState();
   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());
+    proximity_monitor_ =
+        CreateProximityMonitor(life_cycle_->GetConnection(), pref_manager_);
     GetMessenger()->AddObserver(this);
   }
 
   if (state == RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED)
     SetWakingUpState(false);
 
   UpdateLockScreen();
 }
 
 void UnlockManagerImpl::OnUnlockEventSent(bool success) {
@@ skipping 144 matching lines @@
     if (GetMessenger()->SupportsSignIn()) {
       GetMessenger()->RequestUnlock();
     } else {
       PA_LOG(INFO) << "Protocol v3.1 not supported, skipping request_unlock.";
       GetMessenger()->DispatchUnlockEvent();
     }
   }
 }
 
 std::unique_ptr<ProximityMonitor> UnlockManagerImpl::CreateProximityMonitor(
-    cryptauth::Connection* connection) {
+    cryptauth::Connection* connection,
+    ProximityAuthPrefManager* pref_manager) {
   return base::MakeUnique<ProximityMonitorImpl>(
-      connection, base::WrapUnique(new base::DefaultTickClock()));
+      connection, base::WrapUnique(new base::DefaultTickClock()), pref_manager);
 }
 
 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 159 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