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

components/proximity_auth/messenger_impl_unittest.cc

 // Copyright 2014 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/messenger_impl.h"
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "components/cryptauth/connection.h"
+#include "components/cryptauth/fake_connection.h"
 #include "components/cryptauth/remote_device.h"
-#include "components/proximity_auth/connection.h"
-#include "components/proximity_auth/fake_connection.h"
+#include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/fake_secure_context.h"
 #include "components/proximity_auth/messenger_observer.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/remote_status_update.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::AllOf;
 using testing::Eq;
 using testing::Field;
 using testing::NiceMock;
 using testing::Pointee;
 using testing::Return;
@@ skipping 26 matching lines @@
  private:
   // The messenger that |this| instance observes.
   Messenger* const messenger_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMessengerObserver);
 };
 
 class TestMessenger : public MessengerImpl {
  public:
   TestMessenger()
-      : MessengerImpl(base::MakeUnique<FakeConnection>(
+      : MessengerImpl(base::MakeUnique<cryptauth::FakeConnection>(
                           CreateClassicRemoteDeviceForTest()),
                       base::MakeUnique<FakeSecureContext>()) {}
   ~TestMessenger() override {}
 
   // Simple getters for the mock objects owned by |this| messenger.
-  FakeConnection* GetFakeConnection() {
-    return static_cast<FakeConnection*>(connection());
+  cryptauth::FakeConnection* GetFakeConnection() {
+    return static_cast<cryptauth::FakeConnection*>(connection());
   }
   FakeSecureContext* GetFakeSecureContext() {
     return static_cast<FakeSecureContext*>(GetSecureContext());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestMessenger);
 };
 
 }  // namespace
@@ skipping 18 matching lines @@
   MockMessengerObserver observer(&messenger);
 
   EXPECT_CALL(observer, OnDisconnected());
   messenger.GetFakeConnection()->Disconnect();
 }
 
 TEST(ProximityAuthMessengerImplTest, DispatchUnlockEvent_SendsExpectedMessage) {
   TestMessenger messenger;
   messenger.DispatchUnlockEvent();
 
-  WireMessage* message = messenger.GetFakeConnection()->current_message();
+  cryptauth::WireMessage* message =
+      messenger.GetFakeConnection()->current_message();
   ASSERT_TRUE(message);
   EXPECT_EQ(std::string(), message->permit_id());
   EXPECT_EQ(
       "{"
       "\"name\":\"easy_unlock\","
       "\"type\":\"event\""
       "}, but encoded",
       message->payload());
 }
 
@@ skipping 21 matching lines @@
   messenger.GetFakeSecureContext()->set_protocol_version(
       SecureContext::PROTOCOL_VERSION_THREE_ZERO);
   messenger.RequestDecryption(kChallenge);
   EXPECT_FALSE(messenger.GetFakeConnection()->current_message());
 }
 
 TEST(ProximityAuthMessengerImplTest, RequestDecryption_SendsExpectedMessage) {
   TestMessenger messenger;
   messenger.RequestDecryption(kChallenge);
 
-  WireMessage* message = messenger.GetFakeConnection()->current_message();
+  cryptauth::WireMessage* message =
+      messenger.GetFakeConnection()->current_message();
   ASSERT_TRUE(message);
   EXPECT_EQ(std::string(), message->permit_id());
   EXPECT_EQ(
       "{"
       "\"encrypted_data\":\"YSBtb3N0IGRpZmZpY3VsdCBjaGFsbGVuZ2U=\","
       "\"type\":\"decrypt_request\""
       "}, but encoded",
       message->payload());
 }
 
 TEST(ProximityAuthMessengerImplTest,
      RequestDecryption_SendsExpectedMessage_UsingBase64UrlEncoding) {
   TestMessenger messenger;
   messenger.RequestDecryption("\xFF\xE6");
 
-  WireMessage* message = messenger.GetFakeConnection()->current_message();
+  cryptauth::WireMessage* message =
+      messenger.GetFakeConnection()->current_message();
   ASSERT_TRUE(message);
   EXPECT_EQ(std::string(), message->permit_id());
   EXPECT_EQ(
       "{"
       "\"encrypted_data\":\"_-Y=\","
       "\"type\":\"decrypt_request\""
       "}, but encoded",
       message->payload());
 }
 
@@ skipping 80 matching lines @@
   messenger.GetFakeSecureContext()->set_protocol_version(
       SecureContext::PROTOCOL_VERSION_THREE_ZERO);
   messenger.RequestUnlock();
   EXPECT_FALSE(messenger.GetFakeConnection()->current_message());
 }
 
 TEST(ProximityAuthMessengerImplTest, RequestUnlock_SendsExpectedMessage) {
   TestMessenger messenger;
   messenger.RequestUnlock();
 
-  WireMessage* message = messenger.GetFakeConnection()->current_message();
+  cryptauth::WireMessage* message =
+      messenger.GetFakeConnection()->current_message();
   ASSERT_TRUE(message);
   EXPECT_EQ(std::string(), message->permit_id());
   EXPECT_EQ("{\"type\":\"unlock_request\"}, but encoded", message->payload());
 }
 
 TEST(ProximityAuthMessengerImplTest, RequestUnlock_SendMessageFails) {
   TestMessenger messenger;
   MockMessengerObserver observer(&messenger);
   messenger.RequestUnlock();
 
@@ skipping 150 matching lines @@
       "\"data\":\"YSB3aW5uZXIgaXMgeW91\""
       "}, but encoded");
 
   // The unlock request should have remained buffered, and should only now be
   // sent.
   EXPECT_CALL(observer, OnUnlockResponse(false));
   messenger.GetFakeConnection()->FinishSendingMessageWithSuccess(false);
 }
 
 }  // namespace proximity_auth