Move RemoteDevice from //components/proximity_auth to //components/cryptauth so that it can be easi…

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/remote_device.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/proximity_monitor_observer.h"
-#include "components/proximity_auth/remote_device.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 kBluetoothAddress[] = "AA:BB:CC:DD:EE:FF";
 const char kRemoteDevicePublicKey[] = "Remote Public Key";
 const char kRemoteDeviceName[] = "LGE Nexus 5";
 const char kPersistentSymmetricKey[] = "PSK";
 
 class TestProximityMonitorImpl : public ProximityMonitorImpl {
  public:
-  explicit TestProximityMonitorImpl(const RemoteDevice& remote_device,
-                                    std::unique_ptr<base::TickClock> clock)
+  explicit TestProximityMonitorImpl(
+      const cryptauth::RemoteDevice& remote_device,
+      std::unique_ptr<base::TickClock> clock)
       : ProximityMonitorImpl(remote_device, std::move(clock)) {}
   ~TestProximityMonitorImpl() override {}
 
   using ProximityMonitorImpl::SetStrategy;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestProximityMonitorImpl);
 };
 
 class MockProximityMonitorObserver : public ProximityMonitorObserver {
@@ skipping 23 matching lines @@
  public:
   ProximityAuthProximityMonitorImplTest()
       : clock_(new base::SimpleTestTickClock()),
         bluetooth_adapter_(CreateAndRegisterMockBluetoothAdapter()),
         remote_bluetooth_device_(&*bluetooth_adapter_,
                                  0,
                                  kRemoteDeviceName,
                                  kBluetoothAddress,
                                  false /* paired */,
                                  true /* connected */),
-        monitor_(RemoteDevice(kRemoteDeviceUserId,
-                              kRemoteDeviceName,
-                              kRemoteDevicePublicKey,
-                              RemoteDevice::BLUETOOTH_CLASSIC,
-                              kBluetoothAddress,
-                              kPersistentSymmetricKey,
-                              std::string()),
-                 base::WrapUnique(clock_)),
+        monitor_(
+            cryptauth::RemoteDevice(kRemoteDeviceUserId,
+                                    kRemoteDeviceName,
+                                    kRemoteDevicePublicKey,
+                                    cryptauth::RemoteDevice::BLUETOOTH_CLASSIC,
+                                    kBluetoothAddress,
+                                    kPersistentSymmetricKey,
+                                    std::string()),
+            base::WrapUnique(clock_)),
         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_);
   }
   ~ProximityAuthProximityMonitorImplTest() override {}
 
@@ skipping 427 matching lines @@
   histogram_tester.ExpectUniqueSample("EasyUnlock.AuthProximity.RollingRssi",
                                       -100, 1);
   histogram_tester.ExpectUniqueSample(
       "EasyUnlock.AuthProximity.TransmitPowerDelta", 50, 1);
 }
 
 TEST_F(ProximityAuthProximityMonitorImplTest,
        RecordProximityMetricsOnAuthSuccess_UnknownValues) {
   // Note: A device without a recorded name will have its Bluetooth address as
   // its name.
-  RemoteDevice unnamed_remote_device(
+  cryptauth::RemoteDevice unnamed_remote_device(
       kRemoteDeviceUserId, kBluetoothAddress, kRemoteDevicePublicKey,
-      RemoteDevice::BLUETOOTH_CLASSIC, kBluetoothAddress,
+      cryptauth::RemoteDevice::BLUETOOTH_CLASSIC, kBluetoothAddress,
       kPersistentSymmetricKey, std::string());
 
   std::unique_ptr<base::TickClock> clock(new base::SimpleTestTickClock());
   ProximityMonitorImpl monitor(unnamed_remote_device, std::move(clock));
   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.TransmitPowerDelta", 127, 1);
   histogram_tester.ExpectUniqueSample(
       "EasyUnlock.AuthProximity.TimeSinceLastZeroRssi",
       base::TimeDelta::FromSeconds(10).InMilliseconds(), 1);
   histogram_tester.ExpectUniqueSample(
       "EasyUnlock.AuthProximity.RemoteDeviceModelHash",
       -1808066424 /* hash of "Unknown" */, 1);
 }
 
 }  // namespace proximity_auth