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

components/proximity_auth/unlock_manager_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/unlock_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 44 matching lines @@
 RemoteStatusUpdate kRemoteScreenlockStateUnknown = {
     USER_PRESENCE_UNKNOWN, SECURE_SCREEN_LOCK_STATE_UNKNOWN,
     TRUST_AGENT_UNSUPPORTED};
 
 class MockRemoteDeviceLifeCycle : public RemoteDeviceLifeCycle {
  public:
   MockRemoteDeviceLifeCycle() {}
   ~MockRemoteDeviceLifeCycle() override {}
 
   MOCK_METHOD0(Start, void());
-  MOCK_CONST_METHOD0(GetRemoteDevice, RemoteDevice());
+  MOCK_CONST_METHOD0(GetRemoteDevice, cryptauth::RemoteDevice());
   MOCK_CONST_METHOD0(GetState, State());
   MOCK_METHOD0(GetMessenger, Messenger*());
   MOCK_METHOD1(AddObserver, void(Observer*));
   MOCK_METHOD1(RemoveObserver, void(Observer*));
 };
 
 class MockMessenger : public Messenger {
  public:
   MockMessenger() {}
   ~MockMessenger() override {}
@@ skipping 76 matching lines @@
   using MessengerObserver::OnUnlockResponse;
   using MessengerObserver::OnDisconnected;
   using ScreenlockBridge::Observer::OnScreenDidLock;
   using ScreenlockBridge::Observer::OnScreenDidUnlock;
   using ScreenlockBridge::Observer::OnFocusedUserChanged;
 
   MockProximityMonitor* proximity_monitor() { return proximity_monitor_; }
 
  private:
   std::unique_ptr<ProximityMonitor> CreateProximityMonitor(
-      const RemoteDevice& remote_device) override {
+      const cryptauth::RemoteDevice& remote_device) override {
     EXPECT_EQ(kTestRemoteDevicePublicKey, remote_device.public_key);
     std::unique_ptr<MockProximityMonitor> proximity_monitor(
         new NiceMock<MockProximityMonitor>());
     proximity_monitor_ = proximity_monitor.get();
     return std::move(proximity_monitor);
   }
 
   // Owned by the super class.
   MockProximityMonitor* proximity_monitor_;
 
@@ skipping 73 matching lines @@
     unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
   }
 
   void RunPendingTasks() { task_runner_->RunPendingTasks(); }
 
   MockProximityMonitor* proximity_monitor() {
     return unlock_manager_ ? unlock_manager_->proximity_monitor() : nullptr;
   }
 
  protected:
-  RemoteDevice remote_device_;
+  cryptauth::RemoteDevice remote_device_;
 
   // Mock used for verifying interactions with the Bluetooth subsystem.
   scoped_refptr<device::MockBluetoothAdapter> bluetooth_adapter_;
 
   NiceMock<MockProximityAuthClient> proximity_auth_client_;
   NiceMock<MockRemoteDeviceLifeCycle> life_cycle_;
   NiceMock<MockMessenger> messenger_;
   std::unique_ptr<TestUnlockManager> unlock_manager_;
   FakeSecureContext secure_context_;
 
@@ skipping 657 matching lines @@
           }));
 
   EXPECT_CALL(messenger_, RequestDecryption(kChallenge));
   unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
 
   EXPECT_CALL(proximity_auth_client_, FinalizeSignin(std::string()));
   unlock_manager_->OnDecryptResponse(std::string());
 }
 
 }  // namespace proximity_auth