Moved //components/proximity_auth/cryptauth to //components/cryptauth.

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/fake_secure_message_delegate.h"
 #include "components/proximity_auth/connection.h"
-#include "components/proximity_auth/cryptauth/fake_secure_message_delegate.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 {
@@ skipping 69 matching lines @@
   bool connection_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnection);
 };
 
 // Harness for testing DeviceToDeviceAuthenticator.
 class DeviceToDeviceAuthenticatorForTest : public DeviceToDeviceAuthenticator {
  public:
   DeviceToDeviceAuthenticatorForTest(
       Connection* connection,
-      std::unique_ptr<SecureMessageDelegate> secure_message_delegate)
+      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:
   // DeviceToDeviceAuthenticator:
@@ skipping 14 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DeviceToDeviceAuthenticatorForTest);
 };
 
 }  // namespace
 
 class ProximityAuthDeviceToDeviceAuthenticatorTest : public testing::Test {
  public:
   ProximityAuthDeviceToDeviceAuthenticatorTest()
       : remote_device_(CreateClassicRemoteDeviceForTest()),
         connection_(remote_device_),
-        secure_message_delegate_(new FakeSecureMessageDelegate),
+        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,
                               base::Base64UrlDecodePolicy::REQUIRE_PADDING,
                               &local_session_public_key_));
@@ skipping 69 matching lines @@
   MOCK_METHOD1(OnAuthenticationResultProxy, void(Authenticator::Result result));
 
   // Contains information about the remote device.
   const RemoteDevice remote_device_;
 
   // Simulates the connection to the remote device.
   FakeConnection connection_;
 
   // The SecureMessageDelegate used by the authenticator.
   // Owned by |authenticator_|.
-  FakeSecureMessageDelegate* secure_message_delegate_;
+  cryptauth::FakeSecureMessageDelegate* secure_message_delegate_;
 
   // The DeviceToDeviceAuthenticator under test.
   DeviceToDeviceAuthenticatorForTest authenticator_;
 
   // The session keys in play during authentication.
   std::string local_session_public_key_;
   std::string remote_session_public_key_;
   std::string remote_session_private_key_;
   std::string session_symmetric_key_;
 
@@ skipping 99 matching lines @@
   WireMessage wire_message(base::RandBytesAsString(300u));
   connection_.SendMessage(
       base::MakeUnique<WireMessage>(base::RandBytesAsString(300u)));
   connection_.OnBytesReceived(wire_message.Serialize());
   connection_.SendMessage(
       base::MakeUnique<WireMessage>(base::RandBytesAsString(300u)));
   connection_.OnBytesReceived(wire_message.Serialize());
 }
 
 }  // namespace proximity_auth