Adding pref to store the user-selected proximity threshold.

components/proximity_auth/proximity_monitor_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/proximity_monitor_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/cryptauth/fake_connection.h"
 #include "components/cryptauth/remote_device.h"
+#include "components/prefs/testing_pref_service.h"
 #include "components/proximity_auth/logging/logging.h"
+#include "components/proximity_auth/proximity_auth_pref_manager.h"
 #include "components/proximity_auth/proximity_monitor_observer.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using device::BluetoothDevice;
 using testing::_;
 using testing::NiceMock;
 using testing::Return;
 using testing::SaveArg;
 
 namespace proximity_auth {
 namespace {
 
 const char kRemoteDeviceUserId[] = "example@gmail.com";
 const char kRemoteDevicePublicKey[] = "Remote Public Key";
 const char kRemoteDeviceName[] = "LGE Nexus 5";
 const char kBluetoothAddress[] = "AA:BB:CC:DD:EE:FF";
 const char kPersistentSymmetricKey[] = "PSK";
+
+// The proximity threshold corresponds to a RSSI of -70.
+const int kProximityThreshold = 2;

[Tim Song, 2017/07/10 19:27:56]

nit: rename to kProximityThresholdPrefValue

[sacomoto, 2017/07/11 09:56:06]

Done.

 const int kRssiThreshold = -70;
 
 class MockProximityMonitorObserver : public ProximityMonitorObserver {
  public:
   MockProximityMonitorObserver() {}
   ~MockProximityMonitorObserver() override {}
 
   MOCK_METHOD0(OnProximityStateChanged, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockProximityMonitorObserver);
 };
 
+class MockProximityAuthPrefManager : public ProximityAuthPrefManager {
+ public:
+  MockProximityAuthPrefManager() : ProximityAuthPrefManager(nullptr) {}
+  ~MockProximityAuthPrefManager() override {}
+
+  MOCK_CONST_METHOD0(GetProximityThreshold, int(void));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockProximityAuthPrefManager);
+};
+
 // 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;
 }
 
@@ skipping 10 matching lines @@
                                  "",
                                  false /* paired */,
                                  true /* connected */),
         remote_device_(kRemoteDeviceUserId,
                        kRemoteDeviceName,
                        kRemoteDevicePublicKey,
                        kBluetoothAddress,
                        kPersistentSymmetricKey,
                        std::string()),
         connection_(remote_device_),
-        monitor_(&connection_, base::WrapUnique(clock_)),
+        pref_manager_(new NiceMock<MockProximityAuthPrefManager>()),
+        monitor_(&connection_,
+                 base::WrapUnique(clock_),
+                 base::WrapUnique(pref_manager_)),
         task_runner_(new base::TestSimpleTaskRunner()),
         thread_task_runner_handle_(task_runner_) {
     ON_CALL(*bluetooth_adapter_, GetDevice(kBluetoothAddress))
         .WillByDefault(Return(&remote_bluetooth_device_));
     ON_CALL(remote_bluetooth_device_, GetConnectionInfo(_))
         .WillByDefault(SaveArg<0>(&connection_info_callback_));
     monitor_.AddObserver(&observer_);
+    ON_CALL(*pref_manager_, GetProximityThreshold())
+        .WillByDefault(Return(kProximityThreshold));
   }
 
   ~ProximityAuthProximityMonitorImplTest() override {}
 
   void RunPendingTasks() { task_runner_->RunPendingTasks(); }
 
   void ProvideConnectionInfo(
       const BluetoothDevice::ConnectionInfo& connection_info) {
     RunPendingTasks();
     connection_info_callback_.Run(connection_info);
 
     // Reset the callback to ensure that tests correctly only respond at most
     // once per call to GetConnectionInfo().
     connection_info_callback_ = BluetoothDevice::ConnectionInfoCallback();
   }
 
  protected:
   // Mock for verifying interactions with the proximity monitor's observer.
   NiceMock<MockProximityMonitorObserver> observer_;
 
   // Clock used for verifying time calculations. Owned by the monitor_.
   base::SimpleTestTickClock* clock_;
 
   // Mocks used for verifying interactions with the Bluetooth subsystem.
   scoped_refptr<device::MockBluetoothAdapter> bluetooth_adapter_;
   NiceMock<device::MockBluetoothDevice> remote_bluetooth_device_;
   cryptauth::RemoteDevice remote_device_;
   cryptauth::FakeConnection connection_;
 
+  // ProximityAuthPrefManager mock.
+  NiceMock<MockProximityAuthPrefManager>* pref_manager_;
+
   // The proximity monitor under test.
   ProximityMonitorImpl monitor_;
 
  private:
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
   BluetoothDevice::ConnectionInfoCallback connection_info_callback_;
   ScopedDisableLoggingForTesting disable_logging_;
 };
 
@@ skipping 203 matching lines @@
 }
 
 TEST_F(ProximityAuthProximityMonitorImplTest,
        RecordProximityMetricsOnAuthSuccess_UnknownValues) {
   // Note: A device without a recorded name will have "Unknown" as its name.
   cryptauth::RemoteDevice unnamed_remote_device(
       kRemoteDeviceUserId, "" /* name */, kRemoteDevicePublicKey,
       kBluetoothAddress, kPersistentSymmetricKey, std::string());
   cryptauth::FakeConnection connection(unnamed_remote_device);
 
+  NiceMock<MockProximityAuthPrefManager>* pref_manager =
+      new NiceMock<MockProximityAuthPrefManager>();
   std::unique_ptr<base::TickClock> clock(new base::SimpleTestTickClock());
-  ProximityMonitorImpl monitor(&connection, std::move(clock));
+  ProximityMonitorImpl monitor(&connection, std::move(clock),
+                               base::WrapUnique(pref_manager));
+  ON_CALL(*pref_manager, GetProximityThreshold())
+      .WillByDefault(Return(kProximityThreshold));
   monitor.AddObserver(&observer_);
   monitor.Start();
   ProvideConnectionInfo({127, 127, 127});
 
   base::HistogramTester histogram_tester;
   monitor.RecordProximityMetricsOnAuthSuccess();
   histogram_tester.ExpectUniqueSample("EasyUnlock.AuthProximity.RollingRssi",
                                       127, 1);
   histogram_tester.ExpectUniqueSample(
       "EasyUnlock.AuthProximity.RemoteDeviceModelHash",
       -1808066424 /* hash of "Unknown" */, 1);
 }
 
 }  // namespace proximity_auth