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

components/proximity_auth/remote_device_life_cycle_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/remote_device_life_cycle_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 43 matching lines @@
   }
 
   std::string GetChannelBindingData() const override { return std::string(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StubSecureContext);
 };
 
 class FakeConnectionFinder : public ConnectionFinder {
  public:
-  FakeConnectionFinder(const RemoteDevice& remote_device)
+  FakeConnectionFinder(const cryptauth::RemoteDevice& remote_device)
       : remote_device_(remote_device), connection_(nullptr) {}
   ~FakeConnectionFinder() override {}
 
   void OnConnectionFound() {
     ASSERT_FALSE(connection_callback_.is_null());
     std::unique_ptr<FakeConnection> scoped_connection_(
         new FakeConnection(remote_device_));
     connection_ = scoped_connection_.get();
     connection_callback_.Run(std::move(scoped_connection_));
   }
 
   FakeConnection* connection() { return connection_; }
 
  private:
   // ConnectionFinder:
   void Find(const ConnectionCallback& connection_callback) override {
     ASSERT_TRUE(connection_callback_.is_null());
     connection_callback_ = connection_callback;
   }
 
-  const RemoteDevice remote_device_;
+  const cryptauth::RemoteDevice remote_device_;
 
   FakeConnection* connection_;
 
   ConnectionCallback connection_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnectionFinder);
 };
 
 class FakeAuthenticator : public Authenticator {
  public:
@@ skipping 24 matching lines @@
   Connection* connection_;
 
   AuthenticationCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAuthenticator);
 };
 
 // Subclass of RemoteDeviceLifeCycleImpl to make it testable.
 class TestableRemoteDeviceLifeCycleImpl : public RemoteDeviceLifeCycleImpl {
  public:
-  TestableRemoteDeviceLifeCycleImpl(const RemoteDevice& remote_device)
+  TestableRemoteDeviceLifeCycleImpl(
+      const cryptauth::RemoteDevice& remote_device)
       : RemoteDeviceLifeCycleImpl(remote_device, nullptr),
         remote_device_(remote_device) {}
 
   ~TestableRemoteDeviceLifeCycleImpl() override {}
 
   FakeConnectionFinder* connection_finder() { return connection_finder_; }
   FakeAuthenticator* authenticator() { return authenticator_; }
 
  private:
   std::unique_ptr<ConnectionFinder> CreateConnectionFinder() override {
     std::unique_ptr<FakeConnectionFinder> scoped_connection_finder(
         new FakeConnectionFinder(remote_device_));
     connection_finder_ = scoped_connection_finder.get();
     return std::move(scoped_connection_finder);
   }
 
   std::unique_ptr<Authenticator> CreateAuthenticator() override {
     EXPECT_TRUE(connection_finder_);
     std::unique_ptr<FakeAuthenticator> scoped_authenticator(
         new FakeAuthenticator(connection_finder_->connection()));
     authenticator_ = scoped_authenticator.get();
     return std::move(scoped_authenticator);
   }
 
-  const RemoteDevice remote_device_;
+  const cryptauth::RemoteDevice remote_device_;
   FakeConnectionFinder* connection_finder_;
   FakeAuthenticator* authenticator_;
 
   DISALLOW_COPY_AND_ASSIGN(TestableRemoteDeviceLifeCycleImpl);
 };
 
 }  // namespace
 
 class ProximityAuthRemoteDeviceLifeCycleImplTest
     : public testing::Test,
@@ skipping 66 matching lines @@
 
   TestableRemoteDeviceLifeCycleImpl life_cycle_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProximityAuthRemoteDeviceLifeCycleImplTest);
 };
 
 TEST_F(ProximityAuthRemoteDeviceLifeCycleImplTest, GetRemoteDevice) {
-  RemoteDevice expected_remote_device = CreateClassicRemoteDeviceForTest();
-  RemoteDevice remote_device = life_cycle_.GetRemoteDevice();
+  cryptauth::RemoteDevice expected_remote_device =
+      CreateClassicRemoteDeviceForTest();
+  cryptauth::RemoteDevice remote_device = life_cycle_.GetRemoteDevice();
   EXPECT_EQ(expected_remote_device.user_id, remote_device.user_id);
   EXPECT_EQ(expected_remote_device.name, remote_device.name);
   EXPECT_EQ(expected_remote_device.public_key, remote_device.public_key);
   EXPECT_EQ(expected_remote_device.bluetooth_address,
             remote_device.bluetooth_address);
   EXPECT_EQ(expected_remote_device.persistent_symmetric_key,
             remote_device.persistent_symmetric_key);
 }
 
 TEST_F(ProximityAuthRemoteDeviceLifeCycleImplTest, AuthenticateAndDisconnect) {
@@ skipping 53 matching lines @@
 
   // Authentication succeeds on second pass.
   Connection* connection = OnConnectionFound();
   Authenticate(Authenticator::Result::SUCCESS);
   EXPECT_TRUE(life_cycle_.GetMessenger());
   EXPECT_CALL(*this, OnLifeCycleStateChanged(_, _));
   connection->Disconnect();
 }
 
 }  // namespace proximity_auth