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 "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/metrics.h"
+#include "components/proximity_auth/proximity_auth_pref_manager.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;
 
 ProximityMonitorImpl::ProximityMonitorImpl(
     cryptauth::Connection* connection,
-    std::unique_ptr<base::TickClock> clock)
+    std::unique_ptr<base::TickClock> clock,
+    ProximityAuthPrefManager* pref_manager)
     : connection_(connection),
       remote_device_is_in_proximity_(false),
       is_active_(false),
       clock_(std::move(clock)),
+      pref_manager_(pref_manager),
       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 114 matching lines @@
   } else {
     *rssi_rolling_average_ =
         weight * connection_info.rssi + (1 - weight) * (*rssi_rolling_average_);
   }
 
   CheckForProximityStateChange();
 }
 
 void ProximityMonitorImpl::CheckForProximityStateChange() {
   bool is_now_in_proximity =
-      rssi_rolling_average_ && *rssi_rolling_average_ > kRssiThreshold;
+      rssi_rolling_average_ && *rssi_rolling_average_ > rssi_threshold_;
 
   if (rssi_rolling_average_)
     PA_LOG(INFO) << "  Rolling RSSI: " << *rssi_rolling_average_;
 
   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() {
+  ProximityAuthPrefManager::ProximityThreshold threshold =
+      pref_manager_->GetProximityThreshold();
+  switch (threshold) {
+    case ProximityAuthPrefManager::ProximityThreshold::kVeryClose:
+      rssi_threshold_ = -45;
+      return;
+    case ProximityAuthPrefManager::ProximityThreshold::kClose:
+      rssi_threshold_ = -60;
+      return;
+    case ProximityAuthPrefManager::ProximityThreshold::kFar:
+      rssi_threshold_ = -70;
+      return;
+    case ProximityAuthPrefManager::ProximityThreshold::kVeryFar:
+      rssi_threshold_ = -85;
+      return;
+    default:

[battre, 2017/07/12 07:18:47]

I would suggest to drop the default block. The compiler will warn you in case a
new threshold is being added without updating this.

[sacomoto, 2017/07/12 15:52:53]

Done.

+      PA_LOG(WARNING) << "[Proximity] Unmapped proximityThreshold: "
+                      << threshold;
+      rssi_threshold_ = -70;
+      return;
+  }
+}
+
 }  // namespace proximity_auth