Migrate weave-related classes from proximity_auth/ble to cryptauth/ble.

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>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "components/cryptauth/fake_connection.h"
+#include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/authenticator.h"
 #include "components/proximity_auth/connection_finder.h"
-#include "components/proximity_auth/fake_connection.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/secure_context.h"
-#include "components/proximity_auth/wire_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Mock;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 
 namespace proximity_auth {
@@ skipping 28 matching lines @@
 
 class FakeConnectionFinder : public ConnectionFinder {
  public:
   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_));
+        new cryptauth::FakeConnection(remote_device_));
     connection_ = scoped_connection_.get();
     connection_callback_.Run(std::move(scoped_connection_));
   }
 
-  FakeConnection* connection() { return connection_; }
+  cryptauth::FakeConnection* connection() { return connection_; }
 
  private:
   // ConnectionFinder:
   void Find(const ConnectionCallback& connection_callback) override {
     ASSERT_TRUE(connection_callback_.is_null());
     connection_callback_ = connection_callback;
   }
 
   const cryptauth::RemoteDevice remote_device_;
 
-  FakeConnection* connection_;
+  cryptauth::FakeConnection* connection_;
 
   ConnectionCallback connection_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnectionFinder);
 };
 
 class FakeAuthenticator : public Authenticator {
  public:
-  FakeAuthenticator(Connection* connection) : connection_(connection) {}
+  FakeAuthenticator(cryptauth::Connection* connection)
+      : connection_(connection) {}
   ~FakeAuthenticator() override {
     // This object should be destroyed immediately after authentication is
     // complete in order not to outlive the underlying connection.
     EXPECT_FALSE(callback_.is_null());
     EXPECT_EQ(kTestRemoteDevicePublicKey,
               connection_->remote_device().public_key);
   }
 
   void OnAuthenticationResult(Authenticator::Result result) {
     ASSERT_FALSE(callback_.is_null());
     std::unique_ptr<SecureContext> secure_context;
     if (result == Authenticator::Result::SUCCESS)
       secure_context.reset(new StubSecureContext());
     callback_.Run(result, std::move(secure_context));
   }
 
  private:
   // Authenticator:
   void Authenticate(const AuthenticationCallback& callback) override {
     ASSERT_TRUE(callback_.is_null());
     callback_ = callback;
   }
 
-  Connection* connection_;
+  cryptauth::Connection* connection_;
 
   AuthenticationCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAuthenticator);
 };
 
 // Subclass of RemoteDeviceLifeCycleImpl to make it testable.
 class TestableRemoteDeviceLifeCycleImpl : public RemoteDeviceLifeCycleImpl {
  public:
   TestableRemoteDeviceLifeCycleImpl(
@@ skipping 52 matching lines @@
                            RemoteDeviceLifeCycle::State::STOPPED,
                            RemoteDeviceLifeCycle::State::FINDING_CONNECTION));
     life_cycle_.Start();
     task_runner_->RunUntilIdle();
     Mock::VerifyAndClearExpectations(this);
 
     EXPECT_EQ(RemoteDeviceLifeCycle::State::FINDING_CONNECTION,
               life_cycle_.GetState());
   }
 
-  FakeConnection* OnConnectionFound() {
+  cryptauth::FakeConnection* OnConnectionFound() {
     EXPECT_EQ(RemoteDeviceLifeCycle::State::FINDING_CONNECTION,
               life_cycle_.GetState());
 
     EXPECT_CALL(*this, OnLifeCycleStateChanged(
                            RemoteDeviceLifeCycle::State::FINDING_CONNECTION,
                            RemoteDeviceLifeCycle::State::AUTHENTICATING));
     life_cycle_.connection_finder()->OnConnectionFound();
     task_runner_->RunUntilIdle();
     Mock::VerifyAndClearExpectations(this);
 
@@ skipping 105 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