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

components/proximity_auth/bluetooth_connection_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/bluetooth_connection.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
+#include "components/cryptauth/cryptauth_test_util.h"
 #include "components/cryptauth/remote_device.h"
-#include "components/proximity_auth/proximity_auth_test_util.h"
-#include "components/proximity_auth/wire_message.h"
+#include "components/cryptauth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_socket.h"
 #include "net/base/io_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
@@ skipping 21 matching lines @@
 // Create a buffer for testing received data.
 scoped_refptr<net::IOBuffer> CreateReceiveBuffer() {
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kReceiveBufferSize);
   memcpy(buffer->data(), kReceiveBufferContents, kReceiveBufferSize);
   return buffer;
 }
 
 class MockBluetoothConnection : public BluetoothConnection {
  public:
   MockBluetoothConnection()
-      : BluetoothConnection(CreateClassicRemoteDeviceForTest(),
+      : BluetoothConnection(cryptauth::CreateClassicRemoteDeviceForTest(),
                             device::BluetoothUUID(kUuid)) {}
 
   // Calls back into the parent Connection class.
   MOCK_METHOD1(SetStatusProxy, void(Status status));
   MOCK_METHOD1(OnBytesReceived, void(const std::string& bytes));
   MOCK_METHOD2(OnDidSendMessage,
-               void(const WireMessage& message, bool success));
+               void(const cryptauth::WireMessage& message, bool success));
 
   void SetStatus(Status status) override {
     SetStatusProxy(status);
     BluetoothConnection::SetStatus(status);
   }
 
   using BluetoothConnection::status;
   using BluetoothConnection::Connect;
   using BluetoothConnection::DeviceChanged;
   using BluetoothConnection::DeviceRemoved;
   using BluetoothConnection::Disconnect;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothConnection);
 };
 
-class TestWireMessage : public WireMessage {
+class TestWireMessage : public cryptauth::WireMessage {
  public:
-  TestWireMessage() : WireMessage("permit id", "payload") {}
+  TestWireMessage() : cryptauth::WireMessage("permit id", "payload") {}
   ~TestWireMessage() override {}
 
   std::string Serialize() const override { return kSerializedMessage; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestWireMessage);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothConnectionTest : public testing::Test {
  public:
   ProximityAuthBluetoothConnectionTest()
       : adapter_(new device::MockBluetoothAdapter),
         device_(adapter_.get(),
                 0,
-                kTestRemoteDeviceName,
-                kTestRemoteDeviceBluetoothAddress,
+                cryptauth::kTestRemoteDeviceName,
+                cryptauth::kTestRemoteDeviceBluetoothAddress,
                 true,
                 true),
         socket_(new StrictMock<device::MockBluetoothSocket>),
         uuid_(kUuid) {
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     // Suppress uninteresting Gmock call warnings.
     EXPECT_CALL(*adapter_, GetDevice(_)).Times(AnyNumber());
   }
 
   // Transition the connection into an in-progress state.
   void BeginConnecting(MockBluetoothConnection* connection) {
-    EXPECT_EQ(Connection::DISCONNECTED, connection->status());
+    EXPECT_EQ(cryptauth::Connection::DISCONNECTED, connection->status());
     ON_CALL(device_, IsConnected()).WillByDefault(Return(false));
 
     ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
-    EXPECT_CALL(*connection, SetStatusProxy(Connection::IN_PROGRESS));
+    EXPECT_CALL(*connection,
+                SetStatusProxy(cryptauth::Connection::IN_PROGRESS));
     EXPECT_CALL(*adapter_, AddObserver(connection));
     EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _));
     connection->Connect();
 
-    EXPECT_EQ(Connection::IN_PROGRESS, connection->status());
+    EXPECT_EQ(cryptauth::Connection::IN_PROGRESS, connection->status());
   }
 
   // Transition the connection into a connected state.
   // Saves the success and error callbacks passed into OnReceive(), which can be
   // accessed via receive_callback() and receive_success_callback().
   void Connect(MockBluetoothConnection* connection) {
-    EXPECT_EQ(Connection::DISCONNECTED, connection->status());
+    EXPECT_EQ(cryptauth::Connection::DISCONNECTED, connection->status());
 
     device::BluetoothDevice::ConnectToServiceCallback callback;
     ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
-    EXPECT_CALL(*connection, SetStatusProxy(Connection::IN_PROGRESS));
+    EXPECT_CALL(*connection,
+                SetStatusProxy(cryptauth::Connection::IN_PROGRESS));
     EXPECT_CALL(*adapter_, AddObserver(connection));
     EXPECT_CALL(device_, ConnectToServiceInsecurely(_, _, _))
         .WillOnce(SaveArg<1>(&callback));
     connection->Connect();
     ASSERT_FALSE(callback.is_null());
 
-    EXPECT_CALL(*connection, SetStatusProxy(Connection::CONNECTED));
+    EXPECT_CALL(*connection, SetStatusProxy(cryptauth::Connection::CONNECTED));
     EXPECT_CALL(*socket_, Receive(_, _, _))
         .WillOnce(DoAll(SaveArg<1>(&receive_callback_),
                         SaveArg<2>(&receive_error_callback_)));
     callback.Run(socket_);
 
-    EXPECT_EQ(Connection::CONNECTED, connection->status());
+    EXPECT_EQ(cryptauth::Connection::CONNECTED, connection->status());
     ON_CALL(device_, IsConnected()).WillByDefault(Return(true));
   }
 
   device::BluetoothSocket::ReceiveCompletionCallback* receive_callback() {
     return &receive_callback_;
   }
   device::BluetoothSocket::ReceiveErrorCompletionCallback*
   receive_error_callback() {
     return &receive_error_callback_;
   }
@@ skipping 50 matching lines @@
 
   StrictMock<MockBluetoothConnection> connection;
   EXPECT_CALL(connection, SetStatusProxy(_)).Times(0);
   connection.Connect();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, Connect_DeviceMissing) {
   StrictMock<MockBluetoothConnection> connection;
 
   ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(nullptr));
-  EXPECT_CALL(connection, SetStatusProxy(Connection::IN_PROGRESS));
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::IN_PROGRESS));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   connection.Connect();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Connect_DeviceRemovedWhileConnecting) {
   // Create an in-progress connection.
   StrictMock<MockBluetoothConnection> connection;
   BeginConnecting(&connection);
 
   // Remove the device while the connection is in-progress. This should cause
   // the connection to disconnect.
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.DeviceRemoved(adapter_.get(), &device_);
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Connect_OtherDeviceRemovedWhileConnecting) {
   // Create an in-progress connection.
   StrictMock<MockBluetoothConnection> connection;
   BeginConnecting(&connection);
 
   // Remove a device other than the one that is being connected to. This should
   // not have any effect on the connection.
   NiceMock<device::MockBluetoothDevice> other_device(
       adapter_.get(), 0, kOtherDeviceName, kOtherBluetoothAddress, true, true);
   EXPECT_CALL(connection, SetStatusProxy(_)).Times(0);
   connection.DeviceRemoved(adapter_.get(), &other_device);
 
   // The connection removes itself as an observer when it is destroyed.
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, Connect_ConnectionFails) {
   StrictMock<MockBluetoothConnection> connection;
 
   device::BluetoothDevice::ConnectToServiceErrorCallback error_callback;
   ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
-  EXPECT_CALL(connection, SetStatusProxy(Connection::IN_PROGRESS));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::IN_PROGRESS));
   EXPECT_CALL(*adapter_, AddObserver(&connection));
   EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _))
       .WillOnce(SaveArg<2>(&error_callback));
   connection.Connect();
   ASSERT_FALSE(error_callback.is_null());
 
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   error_callback.Run("super descriptive error message");
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, Connect_ConnectionSucceeds) {
   StrictMock<MockBluetoothConnection> connection;
   Connect(&connection);
 
   // The connection disconnects and unregisters as an observer upon destruction.
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Connect_ConnectionSucceeds_ThenDeviceRemoved) {
   StrictMock<MockBluetoothConnection> connection;
   Connect(&connection);
 
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.DeviceRemoved(adapter_.get(), &device_);
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Connect_ConnectionSucceeds_ReceiveData) {
   StrictMock<MockBluetoothConnection> connection;
   Connect(&connection);
   ASSERT_TRUE(receive_callback() && !receive_callback()->is_null());
@@ skipping 52 matching lines @@
   EXPECT_CALL(connection, SetStatusProxy(_)).Times(0);
   connection.Disconnect();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Disconnect_ConnectionWasInProgress) {
   // Create an in-progress connection.
   StrictMock<MockBluetoothConnection> connection;
   BeginConnecting(&connection);
 
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.Disconnect();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Disconnect_ConnectionWasConnected) {
   // Create a connected connection.
   StrictMock<MockBluetoothConnection> connection;
   Connect(&connection);
 
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.Disconnect();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Connect_ThenDisconnectWhileInProgress_ThenBackingConnectionSucceeds) {
   StrictMock<MockBluetoothConnection> connection;
   device::BluetoothDevice::ConnectToServiceCallback callback;
   ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
-  EXPECT_CALL(connection, SetStatusProxy(Connection::IN_PROGRESS));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::IN_PROGRESS));
   EXPECT_CALL(*adapter_, AddObserver(&connection));
   EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _))
       .WillOnce(SaveArg<1>(&callback));
   connection.Connect();
   ASSERT_FALSE(callback.is_null());
 
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.Disconnect();
 
   EXPECT_CALL(connection, SetStatusProxy(_)).Times(0);
   EXPECT_CALL(*socket_, Receive(_, _, _)).Times(0);
   callback.Run(socket_);
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        SendMessage_SendsExpectedDataOverTheWire) {
@@ skipping 45 matching lines @@
   std::unique_ptr<TestWireMessage> wire_message(new TestWireMessage);
   // Ownership will be transfered below, so grab a reference here.
   TestWireMessage* expected_wire_message = wire_message.get();
 
   device::BluetoothSocket::ErrorCompletionCallback error_callback;
   EXPECT_CALL(*socket_, Send(_, _, _, _)).WillOnce(SaveArg<3>(&error_callback));
   connection.SendMessage(std::move(wire_message));
 
   ASSERT_FALSE(error_callback.is_null());
   EXPECT_CALL(connection, OnDidSendMessage(Ref(*expected_wire_message), false));
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   error_callback.Run("The most helpful of error messages");
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, DeviceChanged_Disconnected) {
   // Create a connected connection.
   StrictMock<MockBluetoothConnection> connection;
   Connect(&connection);
   EXPECT_TRUE(connection.IsConnected());
 
   // If the remote device disconnects, |connection| should also disconnect.
   ON_CALL(device_, IsConnected()).WillByDefault(Return(false));
-  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(connection, SetStatusProxy(cryptauth::Connection::DISCONNECTED));
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.DeviceChanged(adapter_.get(), &device_);
   EXPECT_FALSE(connection.IsConnected());
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, DeviceChanged_NotDisconnected) {
   // Nothing should happen if DeviceChanged is called, but the remote device is
   // not disconnected.
   StrictMock<MockBluetoothConnection> connection;
   Connect(&connection);
   EXPECT_TRUE(connection.IsConnected());
   connection.DeviceChanged(adapter_.get(), &device_);
   EXPECT_TRUE(connection.IsConnected());
 
   // The connection disconnects and unregisters as an observer upon destruction.
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
 }
 
 }  // namespace proximity_auth