Adding pref to store the user-selected proximity threshold.

components/proximity_auth/proximity_monitor_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/proximity_monitor_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/pref_service.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/metrics.h"
 #include "components/proximity_auth/proximity_monitor_observer.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 
 using device::BluetoothDevice;
 
 namespace proximity_auth {
 
 // The time to wait, in milliseconds, between proximity polling iterations.
 const int kPollingTimeoutMs = 250;
 
 // The RSSI threshold below which we consider the remote device to not be in
 // proximity.
 // Note: Because this threshold is unconfigurable right now, it is set quite
 // conservatively in order to avoid blocking users.
 const int kRssiThreshold = -70;
 
 // The weight of the most recent RSSI sample.
 const double kRssiSampleWeight = 0.3;
 
+// These are arbitrary labels displayed in the settings page for the user
+// to select. The correspondence to actual RSSI values is done in the
+// GetRssiThresholdFromPrefs().
+enum ProximityThreshold { kVeryClose = 0, kClose = 1, kFar = 2, kVeryFar = 3 };
+
 ProximityMonitorImpl::ProximityMonitorImpl(
     cryptauth::Connection* connection,
-    std::unique_ptr<base::TickClock> clock)
+    std::unique_ptr<base::TickClock> clock,
+    PrefService* pref_service)
     : connection_(connection),
       remote_device_is_in_proximity_(false),
       is_active_(false),
       clock_(std::move(clock)),
+      pref_service_(pref_service),
       polling_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
   if (device::BluetoothAdapterFactory::IsBluetoothSupported()) {
     device::BluetoothAdapterFactory::GetAdapter(
         base::Bind(&ProximityMonitorImpl::OnAdapterInitialized,
                    weak_ptr_factory_.GetWeakPtr()));
   } else {
     PA_LOG(ERROR) << "[Proximity] Proximity monitoring unavailable: "
                   << "Bluetooth is unsupported on this platform.";
   }
 }
 
 ProximityMonitorImpl::~ProximityMonitorImpl() {
 }
 
 void ProximityMonitorImpl::Start() {
   is_active_ = true;
+  GetRssiThresholdFromPrefs();
   UpdatePollingState();
 }
 
 void ProximityMonitorImpl::Stop() {
   is_active_ = false;
   ClearProximityState();
   UpdatePollingState();
 }
 
 bool ProximityMonitorImpl::IsUnlockAllowed() const {
@@ skipping 128 matching lines @@
 
   if (remote_device_is_in_proximity_ != is_now_in_proximity) {
     PA_LOG(INFO) << "[Proximity] Updated proximity state: "
                  << (is_now_in_proximity ? "proximate" : "distant");
     remote_device_is_in_proximity_ = is_now_in_proximity;
     for (auto& observer : observers_)
       observer.OnProximityStateChanged();
   }
 }
 
+void ProximityMonitorImpl::GetRssiThresholdFromPrefs() {
+  int pref_value =
+      pref_service_->GetInteger(prefs::kEasyUnlockProximityThreshold);
+  ProximityThreshold threshold = static_cast<ProximityThreshold>(pref_value);
+  switch (threshold) {

[Tim Song, 2017/07/07 21:48:24]

Add a default case as well.

[sacomoto, 2017/07/10 16:54:07]

Done.

+    case ProximityThreshold::kVeryClose:
+      rssi_threshold_ = -55;

[Tim Song, 2017/07/07 21:48:24]

I would spread out these values out a bit more. Perhaps something like:

{ -30, -50, -70, -85 }

This way we can cover more combinations of devices.

[sacomoto, 2017/07/10 16:54:07]

I spread it a bit more, but I think -30 is really unrealistic. 

+      return;
+    case ProximityThreshold::kClose:
+      rssi_threshold_ = -65;
+      return;
+    case ProximityThreshold::kFar:
+      rssi_threshold_ = -75;
+      return;
+    case ProximityThreshold::kVeryFar:
+      rssi_threshold_ = -85;
+      return;
+  }
+}
+
 }  // namespace proximity_auth