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

components/proximity_auth/device_to_device_authenticator_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/device_to_device_authenticator.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
 #include "base/timer/mock_timer.h"
+#include "components/cryptauth/connection.h"
+#include "components/cryptauth/cryptauth_test_util.h"
 #include "components/cryptauth/fake_secure_message_delegate.h"
-#include "components/proximity_auth/connection.h"
+#include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/device_to_device_responder_operations.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"
 
 namespace proximity_auth {
 
 namespace {
 
 // The account id of the user.
 const char kAccountId[] = "example@gmail.com";
 
@@ skipping 22 matching lines @@
 // Callback saving the result of ValidateHelloMessage().
 void SaveValidateHelloMessageResult(bool* validated_out,
                                     std::string* public_key_out,
                                     bool validated,
                                     const std::string& public_key) {
   *validated_out = validated;
   *public_key_out = public_key;
 }
 
 // Connection implementation for testing.
-class FakeConnection : public Connection {
+class FakeConnection : public cryptauth::Connection {
  public:
   FakeConnection(const cryptauth::RemoteDevice& remote_device)
-      : Connection(remote_device), connection_blocked_(false) {}
+      : cryptauth::Connection(remote_device), connection_blocked_(false) {}
   ~FakeConnection() override {}
 
   // Connection:
-  void Connect() override { SetStatus(Connection::Status::CONNECTED); }
-  void Disconnect() override { SetStatus(Connection::Status::DISCONNECTED); }
+  void Connect() override {
+    SetStatus(cryptauth::Connection::Status::CONNECTED);
+  }
+  void Disconnect() override {
+    SetStatus(cryptauth::Connection::Status::DISCONNECTED);
+  }
 
-  using Connection::OnBytesReceived;
+  using cryptauth::Connection::OnBytesReceived;
 
   void ClearMessageBuffer() { message_buffer_.clear(); }
 
-  const ScopedVector<WireMessage>& message_buffer() { return message_buffer_; }
+  const ScopedVector<cryptauth::WireMessage>& message_buffer() {
+    return message_buffer_;
+  }
 
   void set_connection_blocked(bool connection_blocked) {
     connection_blocked_ = connection_blocked;
   }
 
   bool connection_blocked() { return connection_blocked_; }
 
  protected:
-  // Connection:
-  void SendMessageImpl(std::unique_ptr<WireMessage> message) override {
-    const WireMessage& message_alias = *message;
+  // cryptauth::Connection:
+  void SendMessageImpl(
+      std::unique_ptr<cryptauth::WireMessage> message) override {
+    const cryptauth::WireMessage& message_alias = *message;
     message_buffer_.push_back(std::move(message));
     OnDidSendMessage(message_alias, !connection_blocked_);
   }
 
  private:
-  ScopedVector<WireMessage> message_buffer_;
+  ScopedVector<cryptauth::WireMessage> message_buffer_;
 
   bool connection_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnection);
 };
 
 // Harness for testing DeviceToDeviceAuthenticator.
 class DeviceToDeviceAuthenticatorForTest : public DeviceToDeviceAuthenticator {
  public:
   DeviceToDeviceAuthenticatorForTest(
-      Connection* connection,
+      cryptauth::Connection* connection,
       std::unique_ptr<cryptauth::SecureMessageDelegate> secure_message_delegate)
       : DeviceToDeviceAuthenticator(connection,
                                     kAccountId,
                                     std::move(secure_message_delegate)),
         timer_(nullptr) {}
   ~DeviceToDeviceAuthenticatorForTest() override {}
 
   base::MockTimer* timer() { return timer_; }
 
  private:
@@ skipping 13 matching lines @@
   base::MockTimer* timer_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceToDeviceAuthenticatorForTest);
 };
 
 }  // namespace
 
 class ProximityAuthDeviceToDeviceAuthenticatorTest : public testing::Test {
  public:
   ProximityAuthDeviceToDeviceAuthenticatorTest()
-      : remote_device_(CreateClassicRemoteDeviceForTest()),
+      : remote_device_(cryptauth::CreateClassicRemoteDeviceForTest()),
         connection_(remote_device_),
         secure_message_delegate_(new cryptauth::FakeSecureMessageDelegate),
         authenticator_(&connection_,
                        base::WrapUnique(secure_message_delegate_)) {}
   ~ProximityAuthDeviceToDeviceAuthenticatorTest() override {}
 
   void SetUp() override {
     // Set up the session asymmetric keys for both the local and remote devices.
     ASSERT_TRUE(
         base::Base64UrlDecode(kInitiatorSessionPublicKeyBase64,
@@ skipping 39 matching lines @@
     EXPECT_TRUE(validated);
     EXPECT_EQ(local_session_public_key_, local_session_public_key);
 
     return hello_message;
   }
 
   // Simulate receiving a valid [Responder Auth] message from the remote device.
   std::string SimulateResponderAuth(const std::string& hello_message) {
     std::string remote_device_private_key =
         secure_message_delegate_->GetPrivateKeyForPublicKey(
-            kTestRemoteDevicePublicKey);
+            cryptauth::kTestRemoteDevicePublicKey);
 
     std::string responder_auth_message;
     DeviceToDeviceResponderOperations::CreateResponderAuthMessage(
         hello_message, remote_session_public_key_, remote_session_private_key_,
         remote_device_private_key, remote_device_.persistent_symmetric_key,
         secure_message_delegate_,
         base::Bind(&SaveStringResult, &responder_auth_message));
     EXPECT_FALSE(responder_auth_message.empty());
 
-    WireMessage wire_message(responder_auth_message);
+    cryptauth::WireMessage wire_message(responder_auth_message);
     connection_.OnBytesReceived(wire_message.Serialize());
 
     return responder_auth_message;
   }
 
   void OnAuthenticationResult(Authenticator::Result result,
                               std::unique_ptr<SecureContext> secure_context) {
     secure_context_ = std::move(secure_context);
     OnAuthenticationResultProxy(result);
   }
@@ skipping 46 matching lines @@
       secure_message_delegate_,
       base::Bind(&SaveBooleanResult, &initiator_auth_validated));
   ASSERT_TRUE(initiator_auth_validated);
 }
 
 TEST_F(ProximityAuthDeviceToDeviceAuthenticatorTest, ResponderRejectsHello) {
   std::string hello_message = BeginAuthentication();
 
   // If the responder could not validate the [Hello message], it essentially
   // sends random bytes back for privacy reasons.
-  WireMessage wire_message(base::RandBytesAsString(300u));
+  cryptauth::WireMessage wire_message(base::RandBytesAsString(300u));
   EXPECT_CALL(*this,
               OnAuthenticationResultProxy(Authenticator::Result::FAILURE));
   connection_.OnBytesReceived(wire_message.Serialize());
   EXPECT_FALSE(secure_context_);
 }
 
 TEST_F(ProximityAuthDeviceToDeviceAuthenticatorTest, ResponderAuthTimesOut) {
   // Starts the authentication protocol and grab [Hello] message.
   std::string hello_message = BeginAuthentication();
   ASSERT_TRUE(authenticator_.timer());
@@ skipping 44 matching lines @@
 
 TEST_F(ProximityAuthDeviceToDeviceAuthenticatorTest,
        SendMessagesAfterAuthenticationSuccess) {
   std::string hello_message = BeginAuthentication();
   EXPECT_CALL(*this,
               OnAuthenticationResultProxy(Authenticator::Result::SUCCESS));
   SimulateResponderAuth(hello_message);
 
   // Test that the authenticator is properly cleaned up after authentication
   // completes.
-  WireMessage wire_message(base::RandBytesAsString(300u));
+  cryptauth::WireMessage wire_message(base::RandBytesAsString(300u));
   connection_.SendMessage(
-      base::MakeUnique<WireMessage>(base::RandBytesAsString(300u)));
+      base::MakeUnique<cryptauth::WireMessage>(base::RandBytesAsString(300u)));
   connection_.OnBytesReceived(wire_message.Serialize());
   connection_.SendMessage(
-      base::MakeUnique<WireMessage>(base::RandBytesAsString(300u)));
+      base::MakeUnique<cryptauth::WireMessage>(base::RandBytesAsString(300u)));
   connection_.OnBytesReceived(wire_message.Serialize());
 }
 
 }  // namespace proximity_auth