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

components/proximity_auth/ble/bluetooth_low_energy_connection_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/ble/bluetooth_low_energy_connection.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
+#include "components/cryptauth/ble/bluetooth_low_energy_characteristics_finder.h"
+#include "components/cryptauth/bluetooth_throttler.h"
+#include "components/cryptauth/connection_finder.h"
+#include "components/cryptauth/cryptauth_test_util.h"
 #include "components/cryptauth/remote_device.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
-#include "components/proximity_auth/bluetooth_throttler.h"
-#include "components/proximity_auth/connection_finder.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_remote_gatt_characteristic.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_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 20 matching lines @@
 const device::BluetoothRemoteGattCharacteristic::Properties
     kCharacteristicProperties =
         device::BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST |
         device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
         device::BluetoothRemoteGattCharacteristic::
             PROPERTY_WRITE_WITHOUT_RESPONSE |
         device::BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE;
 
 const int kMaxNumberOfTries = 3;
 
-class MockBluetoothThrottler : public BluetoothThrottler {
+class MockBluetoothThrottler : public cryptauth::BluetoothThrottler {
  public:
   MockBluetoothThrottler() {}
   ~MockBluetoothThrottler() override {}
 
   MOCK_CONST_METHOD0(GetDelay, base::TimeDelta());
-  MOCK_METHOD1(OnConnection, void(Connection* connection));
+  MOCK_METHOD1(OnConnection, void(cryptauth::Connection* connection));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothThrottler);
 };
 
 class MockBluetoothLowEnergyCharacteristicsFinder
-    : public BluetoothLowEnergyCharacteristicsFinder {
+    : public cryptauth::BluetoothLowEnergyCharacteristicsFinder {
  public:
   MockBluetoothLowEnergyCharacteristicsFinder() {}
   ~MockBluetoothLowEnergyCharacteristicsFinder() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyCharacteristicsFinder);
 };
 
 class MockBluetoothLowEnergyConnection : public BluetoothLowEnergyConnection {
  public:
   MockBluetoothLowEnergyConnection(
       const cryptauth::RemoteDevice& remote_device,
       scoped_refptr<device::BluetoothAdapter> adapter,
       const device::BluetoothUUID remote_service_uuid,
-      BluetoothThrottler* bluetooth_throttler,
+      cryptauth::BluetoothThrottler* bluetooth_throttler,
       int max_number_of_write_attempts)
       : BluetoothLowEnergyConnection(remote_device,
                                      adapter,
                                      remote_service_uuid,
                                      bluetooth_throttler,
                                      max_number_of_write_attempts) {}
 
   ~MockBluetoothLowEnergyConnection() override {}
 
-  MOCK_METHOD2(
-      CreateCharacteristicsFinder,
-      BluetoothLowEnergyCharacteristicsFinder*(
-          const BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
-              success,
-          const BluetoothLowEnergyCharacteristicsFinder::ErrorCallback& error));
+  MOCK_METHOD2(CreateCharacteristicsFinder,
+               cryptauth::BluetoothLowEnergyCharacteristicsFinder*(
+                   const cryptauth::BluetoothLowEnergyCharacteristicsFinder::
+                       SuccessCallback& success,
+                   const cryptauth::BluetoothLowEnergyCharacteristicsFinder::
+                       ErrorCallback& error));
 
   MOCK_METHOD2(OnDidSendMessage,
-               void(const WireMessage& message, bool success));
+               void(const cryptauth::WireMessage& message, bool success));
   MOCK_METHOD1(OnBytesReceived, void(const std::string& bytes));
 
   // Exposing inherited protected methods for testing.
   using BluetoothLowEnergyConnection::GattCharacteristicValueChanged;
   using BluetoothLowEnergyConnection::SetTaskRunnerForTesting;
 
   // Exposing inherited protected fields for testing.
   using BluetoothLowEnergyConnection::status;
   using BluetoothLowEnergyConnection::sub_status;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyConnection);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothLowEnergyConnectionTest : public testing::Test {
  public:
   ProximityAuthBluetoothLowEnergyConnectionTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
-        remote_device_(CreateLERemoteDeviceForTest()),
+        remote_device_(cryptauth::CreateLERemoteDeviceForTest()),
         service_uuid_(device::BluetoothUUID(kServiceUUID)),
         to_peripheral_char_uuid_(device::BluetoothUUID(kToPeripheralCharUUID)),
         from_peripheral_char_uuid_(
             device::BluetoothUUID(kFromPeripheralCharUUID)),
         notify_session_alias_(NULL),
         bluetooth_throttler_(new NiceMock<MockBluetoothThrottler>),
         task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
     device_ = base::MakeUnique<NiceMock<device::MockBluetoothDevice>>(
-        adapter_.get(), 0, kTestRemoteDeviceName,
-        kTestRemoteDeviceBluetoothAddress, false, false);
+        adapter_.get(), 0, cryptauth::kTestRemoteDeviceName,
+        cryptauth::kTestRemoteDeviceBluetoothAddress, false, false);
 
     service_ = base::MakeUnique<NiceMock<device::MockBluetoothGattService>>(
         device_.get(), kServiceID, service_uuid_, true, false);
     to_peripheral_char_ =
         base::MakeUnique<NiceMock<device::MockBluetoothGattCharacteristic>>(
             service_.get(), kToPeripheralCharID, to_peripheral_char_uuid_,
             false, kCharacteristicProperties,
             device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE);
 
     from_peripheral_char_ =
         base::MakeUnique<NiceMock<device::MockBluetoothGattCharacteristic>>(
             service_.get(), kFromPeripheralCharID, from_peripheral_char_uuid_,
             false, kCharacteristicProperties,
             device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE);
 
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     std::vector<const device::BluetoothDevice*> devices;
     devices.push_back(device_.get());
     ON_CALL(*adapter_, GetDevices()).WillByDefault(Return(devices));
-    ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
+    ON_CALL(*adapter_, GetDevice(cryptauth::kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(device_.get()));
     ON_CALL(*device_, GetGattService(kServiceID))
         .WillByDefault(Return(service_.get()));
     ON_CALL(*service_, GetCharacteristic(kFromPeripheralCharID))
         .WillByDefault(Return(from_peripheral_char_.get()));
     ON_CALL(*service_, GetCharacteristic(kToPeripheralCharID))
         .WillByDefault(Return(to_peripheral_char_.get()));
   }
 
   // Creates a BluetoothLowEnergyConnection and verifies it's in DISCONNECTED
   // state.
   std::unique_ptr<MockBluetoothLowEnergyConnection> CreateConnection() {
     EXPECT_CALL(*adapter_, AddObserver(_));
     EXPECT_CALL(*adapter_, RemoveObserver(_));
 
     std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
         new MockBluetoothLowEnergyConnection(
             remote_device_, adapter_, service_uuid_, bluetooth_throttler_.get(),
             kMaxNumberOfTries));
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
-    EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::DISCONNECTED);
 
     connection->SetTaskRunnerForTesting(task_runner_);
 
     return connection;
   }
 
   // Transitions |connection| from DISCONNECTED to WAITING_CHARACTERISTICS
   // state, without an existing GATT connection.
   void ConnectGatt(MockBluetoothLowEnergyConnection* connection) {
     // Preparing |connection| for a CreateGattConnection call.
     EXPECT_CALL(*device_, CreateGattConnection(_, _))
         .WillOnce(DoAll(SaveArg<0>(&create_gatt_connection_success_callback_),
                         SaveArg<1>(&create_gatt_connection_error_callback_)));
 
     // No throttling by default
     EXPECT_CALL(*bluetooth_throttler_, GetDelay())
         .WillOnce(Return(base::TimeDelta()));
 
     connection->Connect();
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_GATT_CONNECTION);
-    EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::IN_PROGRESS);
 
     // Preparing |connection| to run |create_gatt_connection_success_callback_|.
     EXPECT_FALSE(create_gatt_connection_error_callback_.is_null());
     ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
     EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
         .WillOnce(DoAll(
             SaveArg<0>(&characteristics_finder_success_callback_),
             SaveArg<1>(&characteristics_finder_error_callback_),
             Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
     create_gatt_connection_success_callback_.Run(
         base::MakeUnique<NiceMock<device::MockBluetoothGattConnection>>(
-            adapter_, kTestRemoteDeviceBluetoothAddress));
+            adapter_, cryptauth::kTestRemoteDeviceBluetoothAddress));
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_CHARACTERISTICS);
-    EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_CHARACTERISTICS to
   // WAITING_NOTIFY_SESSION state.
   void CharacteristicsFound(MockBluetoothLowEnergyConnection* connection) {
     EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _))
         .WillOnce(DoAll(SaveArg<0>(&notify_session_success_callback_),
                         SaveArg<1>(&notify_session_error_callback_)));
     EXPECT_FALSE(characteristics_finder_error_callback_.is_null());
     ASSERT_FALSE(characteristics_finder_success_callback_.is_null());
 
     characteristics_finder_success_callback_.Run(
         {service_uuid_, kServiceID},
         {to_peripheral_char_uuid_, kToPeripheralCharID},
         {from_peripheral_char_uuid_, kFromPeripheralCharID});
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_NOTIFY_SESSION);
-    EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_NOTIFY_SESSION to
   // WAITING_RESPONSE_SIGNAL state.
   void NotifySessionStarted(MockBluetoothLowEnergyConnection* connection) {
     EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
         .WillOnce(
             DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                   SaveArg<1>(&write_remote_characteristic_success_callback_),
                   SaveArg<2>(&write_remote_characteristic_error_callback_)));
     EXPECT_FALSE(notify_session_error_callback_.is_null());
     ASSERT_FALSE(notify_session_success_callback_.is_null());
 
     // Store an alias for the notify session passed |connection|.
     std::unique_ptr<device::MockBluetoothGattNotifySession> notify_session(
         new NiceMock<device::MockBluetoothGattNotifySession>(
             to_peripheral_char_->GetWeakPtr()));
     notify_session_alias_ = notify_session.get();
 
     notify_session_success_callback_.Run(std::move(notify_session));
     task_runner_->RunUntilIdle();
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_RESPONSE_SIGNAL);
-    EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_RESPONSE_SIGNAL to CONNECTED state.
   void ResponseSignalReceived(MockBluetoothLowEnergyConnection* connection) {
     // Written value contains only the
     // BluetoothLowEneryConnection::ControlSignal::kInviteToConnectSignal.
     const std::vector<uint8_t> kInviteToConnectSignal = ToByteVector(
         static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
                                   kInviteToConnectSignal));
     EXPECT_EQ(last_value_written_on_to_peripheral_char_,
               kInviteToConnectSignal);
 
     EXPECT_CALL(*connection, OnDidSendMessage(_, _)).Times(0);
     RunWriteCharacteristicSuccessCallback();
 
     // Received the
     // BluetoothLowEneryConnection::ControlSignal::kInvitationResponseSignal.
     const std::vector<uint8_t> kInvitationResponseSignal = ToByteVector(
         static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
                                   kInvitationResponseSignal));
     connection->GattCharacteristicValueChanged(
         adapter_.get(), from_peripheral_char_.get(), kInvitationResponseSignal);
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::CONNECTED);
-    EXPECT_EQ(connection->status(), Connection::CONNECTED);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::CONNECTED);
   }
 
   // Transitions |connection| to a DISCONNECTED state regardless of its initial
   // state.
   void Disconnect(MockBluetoothLowEnergyConnection* connection) {
     // A notify session was previously set.
     if (notify_session_alias_)
       EXPECT_CALL(*notify_session_alias_, Stop(_));
 
     connection->Disconnect();
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
-    EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
+    EXPECT_EQ(connection->status(), cryptauth::Connection::DISCONNECTED);
   }
 
   void InitializeConnection(MockBluetoothLowEnergyConnection* connection) {
     ConnectGatt(connection);
     CharacteristicsFound(connection);
     NotifySessionStarted(connection);
     ResponseSignalReceived(connection);
   }
 
   void RunWriteCharacteristicSuccessCallback() {
@@ skipping 45 matching lines @@
   std::unique_ptr<MockBluetoothThrottler> bluetooth_throttler_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::MessageLoop message_loop_;
 
   // Callbacks
   device::BluetoothDevice::GattConnectionCallback
       create_gatt_connection_success_callback_;
   device::BluetoothDevice::ConnectErrorCallback
       create_gatt_connection_error_callback_;
 
-  BluetoothLowEnergyCharacteristicsFinder::SuccessCallback
+  cryptauth::BluetoothLowEnergyCharacteristicsFinder::SuccessCallback
       characteristics_finder_success_callback_;
-  BluetoothLowEnergyCharacteristicsFinder::ErrorCallback
+  cryptauth::BluetoothLowEnergyCharacteristicsFinder::ErrorCallback
       characteristics_finder_error_callback_;
 
   device::BluetoothRemoteGattCharacteristic::NotifySessionCallback
       notify_session_success_callback_;
   device::BluetoothRemoteGattCharacteristic::ErrorCallback
       notify_session_error_callback_;
 
   base::Closure write_remote_characteristic_success_callback_;
   device::BluetoothRemoteGattCharacteristic::ErrorCallback
       write_remote_characteristic_error_callback_;
@@ skipping 66 matching lines @@
   EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _)).Times(0);
   EXPECT_FALSE(characteristics_finder_success_callback_.is_null());
   ASSERT_FALSE(characteristics_finder_error_callback_.is_null());
 
   characteristics_finder_error_callback_.Run(
       {to_peripheral_char_uuid_, kToPeripheralCharID},
       {from_peripheral_char_uuid_, kFromPeripheralCharID});
 
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
-  EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
+  EXPECT_EQ(connection->status(), cryptauth::Connection::DISCONNECTED);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        Connect_Fails_NotifySessionError) {
   std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
 
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .Times(0);
   EXPECT_FALSE(notify_session_success_callback_.is_null());
   ASSERT_FALSE(notify_session_error_callback_.is_null());
 
   notify_session_error_callback_.Run(
       device::BluetoothRemoteGattService::GATT_ERROR_UNKNOWN);
 
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
-  EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
+  EXPECT_EQ(connection->status(), cryptauth::Connection::DISCONNECTED);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        Connect_Fails_ErrorSendingInviteToConnectSignal) {
   std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
 
@@ skipping 16 matching lines @@
     EXPECT_EQ(last_value_written_on_to_peripheral_char_,
               kInviteToConnectSignal);
     ASSERT_FALSE(write_remote_characteristic_error_callback_.is_null());
     EXPECT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_error_callback_.Run(
         device::BluetoothRemoteGattService::GATT_ERROR_UNKNOWN);
   }
 
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
-  EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
+  EXPECT_EQ(connection->status(), cryptauth::Connection::DISCONNECTED);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        Receive_MessageSmallerThanCharacteristicSize) {
   std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
       CreateConnection());
   InitializeConnection(connection.get());
 
   std::string received_bytes;
   EXPECT_CALL(*connection, OnBytesReceived(_))
@@ skipping 56 matching lines @@
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
           DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   // Message (bytes) that is going to be sent.
   int message_size = 100;
   std::string message(message_size, 'A');
   message[0] = 'B';
-  connection->SendMessage(base::MakeUnique<FakeWireMessage>(message));
+  connection->SendMessage(
+      base::MakeUnique<cryptauth::FakeWireMessage>(message));
 
   // Expecting that |kSendSignal| + |message_size| + |message| was written.
   EXPECT_EQ(last_value_written_on_to_peripheral_char_,
             CreateFirstCharacteristicValue(message, message.size()));
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
 
   RunWriteCharacteristicSuccessCallback();
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        SendMessage_LagerThanCharacteristicSize) {
   std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
       CreateConnection());
   InitializeConnection(connection.get());
 
   // Expecting a first call of WriteRemoteCharacteristic, after SendMessage is
   // called.
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
           DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   // Message (bytes) that is going to be sent.
   int message_size = 600;
   std::string message(message_size, 'A');
   message[0] = 'B';
-  connection->SendMessage(base::MakeUnique<FakeWireMessage>(message));
+  connection->SendMessage(
+      base::MakeUnique<cryptauth::FakeWireMessage>(message));
 
   // Expecting that |kSendSignal| + |message_size| was written in the first 8
   // bytes.
   std::vector<uint8_t> prefix(
       last_value_written_on_to_peripheral_char_.begin(),
       last_value_written_on_to_peripheral_char_.begin() + 8);
   EXPECT_EQ(prefix, CreateSendSignalWithSize(message_size));
   std::vector<uint8_t> bytes_received(
       last_value_written_on_to_peripheral_char_.begin() + 8,
       last_value_written_on_to_peripheral_char_.end());
@@ skipping 28 matching lines @@
   EXPECT_CALL(*bluetooth_throttler_, GetDelay())
       .WillOnce(Return(base::TimeDelta(base::TimeDelta::FromSeconds(1))));
   EXPECT_CALL(*device_, CreateGattConnection(_, _))
       .WillOnce(DoAll(SaveArg<0>(&create_gatt_connection_success_callback_),
                       SaveArg<1>(&create_gatt_connection_error_callback_)));
 
   // No GATT connection should be created before the delay.
   connection->Connect();
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::WAITING_GATT_CONNECTION);
-  EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
+  EXPECT_EQ(connection->status(), cryptauth::Connection::IN_PROGRESS);
   EXPECT_TRUE(create_gatt_connection_error_callback_.is_null());
   EXPECT_TRUE(create_gatt_connection_success_callback_.is_null());
 
   // A GATT connection should be created after the delay.
   task_runner_->RunUntilIdle();
   EXPECT_FALSE(create_gatt_connection_error_callback_.is_null());
   ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
 
   // Preparing |connection| to run |create_gatt_connection_success_callback_|.
   EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
       .WillOnce(DoAll(
           SaveArg<0>(&characteristics_finder_success_callback_),
           SaveArg<1>(&characteristics_finder_error_callback_),
           Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
   create_gatt_connection_success_callback_.Run(
       base::MakeUnique<NiceMock<device::MockBluetoothGattConnection>>(
-          adapter_, kTestRemoteDeviceBluetoothAddress));
+          adapter_, cryptauth::kTestRemoteDeviceBluetoothAddress));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   ResponseSignalReceived(connection.get());
 }
 
 }  // namespace proximity_auth