Substituting legacy protocol with uWeave protocol

components/proximity_auth/ble/bluetooth_low_energy_weave_client_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 "components/proximity_auth/ble/bluetooth_low_energy_weave_client_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/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/remote_device.h"
 #include "components/proximity_auth/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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 using testing::SaveArg;
 
 namespace proximity_auth {
 namespace {
 
+class MockBluetoothThrottler : public BluetoothThrottler {
+ public:
+  MockBluetoothThrottler() {}
+  ~MockBluetoothThrottler() override {}
+
+  MOCK_CONST_METHOD0(GetDelay, base::TimeDelta());
+  MOCK_METHOD1(OnConnection, void(Connection* connection));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockBluetoothThrottler);
+};
+
+class MockBluetoothLowEnergyCharacteristicsFinder
+    : public BluetoothLowEnergyCharacteristicsFinder {
+ public:
+  MockBluetoothLowEnergyCharacteristicsFinder() {}
+  ~MockBluetoothLowEnergyCharacteristicsFinder() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyCharacteristicsFinder);
+};
+
+}  // namespace
+
+namespace weave {
+namespace {
+
+typedef BluetoothLowEnergyWeaveClientConnection::SubStatus SubStatus;
+typedef BluetoothLowEnergyWeavePacketReceiver::State ReceiverState;
+typedef BluetoothLowEnergyWeavePacketReceiver::ReceiverError ReceiverError;
+typedef BluetoothLowEnergyWeavePacketReceiver::ReceiverType ReceiverType;
+
 const char kServiceUUID[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEEF";
-const char kToPeripheralCharUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
-const char kFromPeripheralCharUUID[] = "f4b904a2-a030-43b3-98a8-221c536c03cb";
+const char kTXCharacteristicUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
+const char kRXCharacteristicUUID[] = "f4b904a2-a030-43b3-98a8-221c536c03cb";
 
 const char kServiceID[] = "service id";
-const char kToPeripheralCharID[] = "to peripheral char id";
-const char kFromPeripheralCharID[] = "from peripheral char id";
+const char kTXCharacteristicID[] = "TX characteristic id";
+const char kRXCharacteristicID[] = "RX characteristic id";
 
 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;
+const uint16_t kLargeMaxPacketSize = 30;
 
-class MockBluetoothThrottler : public BluetoothThrottler {
+const uint8_t kDataHeader = 0;
+const uint8_t kConnectionRequestHeader = 1;
+const uint8_t kSmallConnectionResponseHeader = 2;
+const uint8_t kLargeConnectionResponseHeader = 3;
+
+const std::string kSmallMessage = "bb";
+const std::string kLargeMessage = "aaabbb";
+
+const Packet kConnectionRequest{kConnectionRequestHeader};
+const Packet kSmallConnectionResponse{kSmallConnectionResponseHeader};
+const Packet kLargeConnectionResponse{kLargeConnectionResponseHeader};
+
+const std::vector<Packet> kSmallPackets{Packet{kDataHeader, 'b', 'b'}};
+const std::vector<Packet> kLargePackets{Packet{kDataHeader, 'a', 'a', 'a'},
+                                        Packet{kDataHeader, 'b', 'b', 'b'}};
+
+class MockBluetoothLowEnergyWeavePacketGenerator
+    : public BluetoothLowEnergyWeavePacketGenerator {
  public:
-  MockBluetoothThrottler() {}
-  ~MockBluetoothThrottler() override {}
+  MockBluetoothLowEnergyWeavePacketGenerator()
+      : max_packet_size_(kDefaultMaxPacketSize) {}
 
-  MOCK_CONST_METHOD0(GetDelay, base::TimeDelta());
-  MOCK_METHOD1(OnConnection, void(Connection* connection));
+  Packet CreateConnectionRequest() override { return kConnectionRequest; }
+
+  Packet CreateConnectionResponse() override {
+    if (max_packet_size_ == kDefaultMaxPacketSize) {
+      return kSmallConnectionResponse;
+    } else {
+      return kLargeConnectionResponse;
+    }
+  }
+
+  Packet CreateConnectionClose(ReasonForClose reason_for_close) override {
+    return Packet{static_cast<uint8_t>(reason_for_close)};
+  }
+
+  void SetMaxPacketSize(uint16_t size) override { max_packet_size_ = size; }
+
+  std::vector<Packet> EncodeDataMessage(std::string message) override {
+    if (max_packet_size_ == kDefaultMaxPacketSize) {
+      return kSmallPackets;
+    } else {
+      return kLargePackets;
+    }
+  }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothThrottler);
+  uint16_t max_packet_size_;
 };
 
-class MockBluetoothLowEnergyCharacteristicsFinder
-    : public BluetoothLowEnergyCharacteristicsFinder {
+class MockBluetoothLowEnergyWeavePacketReceiver
+    : public BluetoothLowEnergyWeavePacketReceiver {
  public:
-  MockBluetoothLowEnergyCharacteristicsFinder() {}
-  ~MockBluetoothLowEnergyCharacteristicsFinder() override {}
+  MockBluetoothLowEnergyWeavePacketReceiver()
+      : BluetoothLowEnergyWeavePacketReceiver(ReceiverType::CLIENT),
+        state_(State::CONNECTING),
+        max_packet_size_(kDefaultMaxPacketSize) {}
+
+  ReceiverState GetState() override { return state_; }
+
+  uint16_t GetMaxPacketSize() override { return max_packet_size_; }
+
+  ReasonForClose GetReasonForClose() override {
+    return ReasonForClose::CLOSE_WITHOUT_ERROR;
+  }
+
+  ReasonForClose GetReasonToClose() override {
+    return ReasonForClose::UNKNOWN_ERROR;
+  }
+
+  std::string GetDataMessage() override {
+    if (max_packet_size_ == kDefaultMaxPacketSize) {
+      return kSmallMessage;
+    } else {
+      return kLargeMessage;
+    }
+  }
+
+  ReceiverError GetReceiverError() override {
+    return ReceiverError::NO_ERROR_DETECTED;
+  }
+
+  ReceiverState ReceivePacket(const Packet& packet) override {
+    switch (packet[0]) {
+      case kSmallConnectionResponseHeader:
+        max_packet_size_ = kDefaultMaxPacketSize;
+        state_ = ReceiverState::WAITING;
+        break;
+      case kLargeConnectionResponseHeader:
+        max_packet_size_ = kLargeMaxPacketSize;
+        state_ = ReceiverState::WAITING;
+        break;
+      case kDataHeader:
+        if (packet[1] == 'b') {
+          state_ = ReceiverState::DATA_READY;
+        } else {
+          state_ = ReceiverState::RECEIVING_DATA;
+        }
+        break;
+      default:
+        NOTREACHED();
+    }
+    return state_;
+  }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyCharacteristicsFinder);
+  ReceiverState state_;
+  uint16_t max_packet_size_;
 };
 
-class MockBluetoothLowEnergyConnection : public BluetoothLowEnergyConnection {
+class MockBluetoothLowEnergyWeavePacketGeneratorFactory
+    : public BluetoothLowEnergyWeavePacketGenerator::Factory {
+ private:
+  std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> BuildInstance()
+      override {
+    return std::unique_ptr<MockBluetoothLowEnergyWeavePacketGenerator>(
+        new MockBluetoothLowEnergyWeavePacketGenerator());
+  }
+};
+
+class MockBluetoothLowEnergyWeavePacketReceiverFactory
+    : public BluetoothLowEnergyWeavePacketReceiver::Factory {
+ private:
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> BuildInstance(
+      ReceiverType receiver_type) override {
+    return std::unique_ptr<MockBluetoothLowEnergyWeavePacketReceiver>(
+        new MockBluetoothLowEnergyWeavePacketReceiver());
+  }
+};
+
+class TestBluetoothLowEnergyWeaveClientConnection
+    : public BluetoothLowEnergyWeaveClientConnection {
  public:
-  MockBluetoothLowEnergyConnection(
+  TestBluetoothLowEnergyWeaveClientConnection(
       const RemoteDevice& remote_device,
       scoped_refptr<device::BluetoothAdapter> adapter,
       const device::BluetoothUUID remote_service_uuid,
       BluetoothThrottler* bluetooth_throttler,
       int max_number_of_write_attempts)
-      : BluetoothLowEnergyConnection(remote_device,
-                                     adapter,
-                                     remote_service_uuid,
-                                     bluetooth_throttler,
-                                     max_number_of_write_attempts) {}
+      : BluetoothLowEnergyWeaveClientConnection(remote_device,
+                                                adapter,
+                                                remote_service_uuid,
+                                                bluetooth_throttler,
+                                                max_number_of_write_attempts) {}
 
-  ~MockBluetoothLowEnergyConnection() override {}
+  ~TestBluetoothLowEnergyWeaveClientConnection() override {}
 
   MOCK_METHOD2(
       CreateCharacteristicsFinder,
       BluetoothLowEnergyCharacteristicsFinder*(
           const BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
               success,
           const BluetoothLowEnergyCharacteristicsFinder::ErrorCallback& error));
 
   MOCK_METHOD2(OnDidSendMessage,
                void(const WireMessage& message, bool success));
   MOCK_METHOD1(OnBytesReceived, void(const std::string& bytes));
 
   // Exposing inherited protected methods for testing.
-  using BluetoothLowEnergyConnection::GattCharacteristicValueChanged;
-  using BluetoothLowEnergyConnection::SetTaskRunnerForTesting;
+  using BluetoothLowEnergyWeaveClientConnection::GattCharacteristicValueChanged;
+  using BluetoothLowEnergyWeaveClientConnection::SetTaskRunnerForTesting;
 
   // Exposing inherited protected fields for testing.
-  using BluetoothLowEnergyConnection::status;
-  using BluetoothLowEnergyConnection::sub_status;
+  using BluetoothLowEnergyWeaveClientConnection::status;
+  using BluetoothLowEnergyWeaveClientConnection::sub_status;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyConnection);
+  DISALLOW_COPY_AND_ASSIGN(TestBluetoothLowEnergyWeaveClientConnection);
 };
 
 }  // namespace
 
-class ProximityAuthBluetoothLowEnergyConnectionTest : public testing::Test {
+class ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest
+    : public testing::Test {
  public:
-  ProximityAuthBluetoothLowEnergyConnectionTest()
+  ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
         remote_device_(CreateLERemoteDeviceForTest()),
         service_uuid_(device::BluetoothUUID(kServiceUUID)),
-        to_peripheral_char_uuid_(device::BluetoothUUID(kToPeripheralCharUUID)),
-        from_peripheral_char_uuid_(
-            device::BluetoothUUID(kFromPeripheralCharUUID)),
+        tx_characteristic_uuid_(device::BluetoothUUID(kTXCharacteristicUUID)),
+        rx_characteristic_uuid_(device::BluetoothUUID(kRXCharacteristicUUID)),
         notify_session_alias_(NULL),
         bluetooth_throttler_(new NiceMock<MockBluetoothThrottler>),
         task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
     device_ = base::WrapUnique(new NiceMock<device::MockBluetoothDevice>(
         adapter_.get(), 0, kTestRemoteDeviceName,
         kTestRemoteDeviceBluetoothAddress, false, false));
 
     service_ = base::WrapUnique(new NiceMock<device::MockBluetoothGattService>(
         device_.get(), kServiceID, service_uuid_, true, false));
-    to_peripheral_char_ =
+    tx_characteristic_ =
         base::WrapUnique(new NiceMock<device::MockBluetoothGattCharacteristic>(
-            service_.get(), kToPeripheralCharID, to_peripheral_char_uuid_,
-            false, kCharacteristicProperties,
+            service_.get(), kTXCharacteristicID, tx_characteristic_uuid_, false,
+            kCharacteristicProperties,
             device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
-    from_peripheral_char_ =
+    rx_characteristic_ =
         base::WrapUnique(new NiceMock<device::MockBluetoothGattCharacteristic>(
-            service_.get(), kFromPeripheralCharID, from_peripheral_char_uuid_,
-            false, kCharacteristicProperties,
+            service_.get(), kRXCharacteristicID, rx_characteristic_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))
         .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()));
+    ON_CALL(*service_, GetCharacteristic(kRXCharacteristicID))
+        .WillByDefault(Return(rx_characteristic_.get()));
+    ON_CALL(*service_, GetCharacteristic(kTXCharacteristicID))
+        .WillByDefault(Return(tx_characteristic_.get()));
   }
 
-  // Creates a BluetoothLowEnergyConnection and verifies it's in DISCONNECTED
-  // state.
-  std::unique_ptr<MockBluetoothLowEnergyConnection> CreateConnection() {
+  // Creates a BluetoothLowEnergyWeaveClientConnection and verifies it's in
+  // DISCONNECTED state.
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection>
+  CreateConnection() {
     EXPECT_CALL(*adapter_, AddObserver(_));
     EXPECT_CALL(*adapter_, RemoveObserver(_));
 
-    std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
-        new MockBluetoothLowEnergyConnection(
+    BluetoothLowEnergyWeavePacketGenerator::Factory::SetInstanceForTesting(
+        &generator_factory_);
+    BluetoothLowEnergyWeavePacketReceiver::Factory::SetInstanceForTesting(
+        &receiver_factory_);
+
+    std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
+        new TestBluetoothLowEnergyWeaveClientConnection(
             remote_device_, adapter_, service_uuid_, bluetooth_throttler_.get(),
             kMaxNumberOfTries));
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+    EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
     EXPECT_EQ(connection->status(), 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) {
+  void ConnectGatt(TestBluetoothLowEnergyWeaveClientConnection* 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->sub_status(), SubStatus::WAITING_GATT_CONNECTION);
     EXPECT_EQ(connection->status(), 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::WrapUnique(new NiceMock<device::MockBluetoothGattConnection>(
             adapter_, kTestRemoteDeviceBluetoothAddress)));
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::WAITING_CHARACTERISTICS);
+    EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_CHARACTERISTICS);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_CHARACTERISTICS to
   // WAITING_NOTIFY_SESSION state.
-  void CharacteristicsFound(MockBluetoothLowEnergyConnection* connection) {
-    EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _))
+  void CharacteristicsFound(
+      TestBluetoothLowEnergyWeaveClientConnection* connection) {
+    EXPECT_CALL(*rx_characteristic_, 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});
+        {tx_characteristic_uuid_, kTXCharacteristicID},
+        {rx_characteristic_uuid_, kRXCharacteristicID});
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::WAITING_NOTIFY_SESSION);
+    EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_NOTIFY_SESSION);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_NOTIFY_SESSION to
-  // WAITING_RESPONSE_SIGNAL state.
-  void NotifySessionStarted(MockBluetoothLowEnergyConnection* connection) {
-    EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  // WAITING_CONNECTION_RESPONSE state.
+  void NotifySessionStarted(
+      TestBluetoothLowEnergyWeaveClientConnection* connection) {
+    EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
         .WillOnce(
-            DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+            DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                   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>(
-            kToPeripheralCharID));
+            kTXCharacteristicID));
     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->sub_status(), SubStatus::WAITING_CONNECTION_RESPONSE);
     EXPECT_EQ(connection->status(), 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);
+  // Transitions |connection| from WAITING_CONNECTION_RESPONSE to CONNECTED.
+  void ConnectionResponseReceived(
+      TestBluetoothLowEnergyWeaveClientConnection* connection,
+      uint16_t selected_packet_size) {
+    // Written value contains only the mock Connection Request.
+    EXPECT_EQ(last_value_written_on_tx_characteristic_, kConnectionRequest);
 
     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);
+    // Received Connection Response.
+    if (selected_packet_size == kDefaultMaxPacketSize) {
+      connection->GattCharacteristicValueChanged(
+          adapter_.get(), rx_characteristic_.get(), kSmallConnectionResponse);
+    } else {
+      connection->GattCharacteristicValueChanged(
+          adapter_.get(), rx_characteristic_.get(), kLargeConnectionResponse);
+    }
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::CONNECTED);
+    EXPECT_EQ(connection->sub_status(), SubStatus::CONNECTED);
     EXPECT_EQ(connection->status(), Connection::CONNECTED);
   }
 
   // Transitions |connection| to a DISCONNECTED state regardless of its initial
   // state.
-  void Disconnect(MockBluetoothLowEnergyConnection* connection) {
+  void Disconnect(TestBluetoothLowEnergyWeaveClientConnection* 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->sub_status(), SubStatus::DISCONNECTED);
     EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
   }
 
-  void InitializeConnection(MockBluetoothLowEnergyConnection* connection) {
+  void InitializeConnection(
+      TestBluetoothLowEnergyWeaveClientConnection* connection,
+      uint32_t selected_packet_size) {
     ConnectGatt(connection);
     CharacteristicsFound(connection);
     NotifySessionStarted(connection);
-    ResponseSignalReceived(connection);
+    ConnectionResponseReceived(connection, selected_packet_size);
   }
 
   void RunWriteCharacteristicSuccessCallback() {
     EXPECT_FALSE(write_remote_characteristic_error_callback_.is_null());
     ASSERT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_success_callback_.Run();
   }
 
-  std::vector<uint8_t> CreateSendSignalWithSize(int message_size) {
-    std::vector<uint8_t> value = ToByteVector(static_cast<uint32_t>(
-        BluetoothLowEnergyConnection::ControlSignal::kSendSignal));
-    std::vector<uint8_t> size =
-        ToByteVector(static_cast<uint32_t>(message_size));
-    value.insert(value.end(), size.begin(), size.end());
-    return value;
-  }
-
-  std::vector<uint8_t> CreateFirstCharacteristicValue(
-      const std::string& message,
-      int size) {
-    std::vector<uint8_t> value(CreateSendSignalWithSize(size));
-    std::vector<uint8_t> bytes(message.begin(), message.end());
-    value.insert(value.end(), bytes.begin(), bytes.end());
-    return value;
-  }
-
-  std::vector<uint8_t> ToByteVector(uint32_t value) {
-    std::vector<uint8_t> bytes(4, 0);
-    bytes[0] = static_cast<uint8_t>(value);
-    bytes[1] = static_cast<uint8_t>(value >> 8);
-    bytes[2] = static_cast<uint8_t>(value >> 16);
-    bytes[3] = static_cast<uint8_t>(value >> 24);
-    return bytes;
-  }
-
  protected:
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
   RemoteDevice remote_device_;
   device::BluetoothUUID service_uuid_;
-  device::BluetoothUUID to_peripheral_char_uuid_;
-  device::BluetoothUUID from_peripheral_char_uuid_;
+  device::BluetoothUUID tx_characteristic_uuid_;
+  device::BluetoothUUID rx_characteristic_uuid_;
   std::unique_ptr<device::MockBluetoothDevice> device_;
   std::unique_ptr<device::MockBluetoothGattService> service_;
-  std::unique_ptr<device::MockBluetoothGattCharacteristic> to_peripheral_char_;
-  std::unique_ptr<device::MockBluetoothGattCharacteristic>
-      from_peripheral_char_;
-  std::vector<uint8_t> last_value_written_on_to_peripheral_char_;
+  std::unique_ptr<device::MockBluetoothGattCharacteristic> tx_characteristic_;
+  std::unique_ptr<device::MockBluetoothGattCharacteristic> rx_characteristic_;
+  std::vector<uint8_t> last_value_written_on_tx_characteristic_;
   device::MockBluetoothGattNotifySession* notify_session_alias_;
   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
       characteristics_finder_success_callback_;
   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_;
+
+  MockBluetoothLowEnergyWeavePacketGeneratorFactory generator_factory_;
+  MockBluetoothLowEnergyWeavePacketReceiverFactory receiver_factory_;
 };
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       CreateAndDestroyWithouthConnectCallDoesntCrash) {
-  BluetoothLowEnergyConnection connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       CreateAndDestroyWithoutConnectCallDoesntCrash) {
+  BluetoothLowEnergyWeaveClientConnection connection(
       remote_device_, adapter_, service_uuid_, bluetooth_throttler_.get(),
       kMaxNumberOfTries);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Disconect_WithoutConnectDoesntCrash) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       DisconectWithoutConnectDoesntCrash) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest, Connect_Success) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectSuccess) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
-  ResponseSignalReceived(connection.get());
+  ConnectionResponseReceived(connection.get(), kDefaultMaxPacketSize);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Success_Disconnect) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectSuccessDisconnect) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+  InitializeConnection(connection.get(), kDefaultMaxPacketSize);
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Incomplete_Disconnect_FromWaitingCharacteristicsState) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectIncompleteDisconnectFromWaitingCharacteristicsState) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Incomplete_Disconnect_FromWaitingNotifySessionState) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectIncompleteDisconnectFromWaitingNotifySessionState) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Incomplete_Disconnect_FromWaitingResponseSignalState) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectIncompleteDisconnectFromWaitingConnectionResponseState) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Fails_CharacteristicsNotFound) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectFailsCharacteristicsNotFound) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
 
-  EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _)).Times(0);
+  EXPECT_CALL(*rx_characteristic_, 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});
+      {tx_characteristic_uuid_, kTXCharacteristicID},
+      {rx_characteristic_uuid_, kRXCharacteristicID});
 
-  EXPECT_EQ(connection->sub_status(),
-            BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+  EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Fails_NotifySessionError) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectFailsNotifySessionError) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
 
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
-      .Times(0);
+  EXPECT_CALL(*tx_characteristic_, 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->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Fails_ErrorSendingInviteToConnectSignal) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectFailsErrorSendingConnectionRequest) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
 
   // |connection| will call WriteRemoteCharacteristics(_,_) to try to send the
   // message |kMaxNumberOfTries| times. There is alredy one EXPECTA_CALL for
   // WriteRemoteCharacteristic(_,_,_) in NotifySessionStated, that's why we use
   // |kMaxNumberOfTries-1| in the EXPECT_CALL statement.
   EXPECT_CALL(*connection, OnDidSendMessage(_, _)).Times(0);
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .Times(kMaxNumberOfTries - 1)
       .WillRepeatedly(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   for (int i = 0; i < kMaxNumberOfTries; i++) {
-    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_EQ(last_value_written_on_tx_characteristic_, kConnectionRequest);
     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->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Receive_MessageSmallerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ReceiveMessageSmallerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+  InitializeConnection(connection.get(), kDefaultMaxPacketSize);
 
   std::string received_bytes;
   EXPECT_CALL(*connection, OnBytesReceived(_))
       .WillOnce(SaveArg<0>(&received_bytes));
 
-  // Message (bytes) that is going to be received.
-  std::string message(100, 'A');
+  connection->GattCharacteristicValueChanged(
+      adapter_.get(), rx_characteristic_.get(), kSmallPackets[0]);
 
-  // Sending the |kSendSignal| + |message_size| + |message|.
-  connection->GattCharacteristicValueChanged(
-      adapter_.get(), from_peripheral_char_.get(),
-      CreateFirstCharacteristicValue(message, message.size()));
-
-  EXPECT_EQ(received_bytes, message);
+  EXPECT_EQ(received_bytes, kSmallMessage);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Receive_MessageLargerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ReceiveMessageLargerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+
+  const uint32_t selected_packet_size = 500;
+  InitializeConnection(connection.get(), selected_packet_size);
 
   std::string received_bytes;
-  int chunk_size = 500;
   EXPECT_CALL(*connection, OnBytesReceived(_))
       .WillOnce(SaveArg<0>(&received_bytes));
 
-  // Message (bytes) that is going to be received.
-  int message_size = 600;
-  std::string message(message_size, 'A');
+  std::vector<Packet> packets = kLargePackets;
 
-  // Sending the |kSendSignal| + |message_size| + |message| (truncated at
-  // |chunk_size|).
-  int first_write_payload_size =
-      chunk_size - CreateSendSignalWithSize(message_size).size();
-  connection->GattCharacteristicValueChanged(
-      adapter_.get(), from_peripheral_char_.get(),
-      CreateFirstCharacteristicValue(
-          message.substr(0, first_write_payload_size), message.size()));
-
-  // Sending the remaining bytes.
-  std::vector<uint8_t> value;
-  value.push_back(0);
-  value.insert(value.end(), message.begin() + first_write_payload_size,
-               message.end());
-  connection->GattCharacteristicValueChanged(
-      adapter_.get(), from_peripheral_char_.get(), value);
-
-  EXPECT_EQ(received_bytes, message);
+  for (auto packet : packets) {
+    connection->GattCharacteristicValueChanged(
+        adapter_.get(), rx_characteristic_.get(), packet);
+  }
+  EXPECT_EQ(received_bytes, kLargeMessage);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       SendMessage_SmallerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       SendMessageSmallerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+  InitializeConnection(connection.get(), kDefaultMaxPacketSize);
 
   // Expecting a first call of WriteRemoteCharacteristic, after SendMessage is
   // called.
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 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::WrapUnique(new FakeWireMessage(message)));
+  connection->SendMessage(base::WrapUnique(new FakeWireMessage(kSmallMessage)));
 
-  // Expecting that |kSendSignal| + |message_size| + |message| was written.
-  EXPECT_EQ(last_value_written_on_to_peripheral_char_,
-            CreateFirstCharacteristicValue(message, message.size()));
+  EXPECT_EQ(last_value_written_on_tx_characteristic_, kSmallPackets[0]);
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
 
   RunWriteCharacteristicSuccessCallback();
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       SendMessage_LagerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       SendMessageLargerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+
+  const uint32_t selected_packet_size = 500;
+  InitializeConnection(connection.get(), selected_packet_size);
 
   // Expecting a first call of WriteRemoteCharacteristic, after SendMessage is
   // called.
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 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::WrapUnique(new FakeWireMessage(message)));
+  connection->SendMessage(base::WrapUnique(new FakeWireMessage(kLargeMessage)));
 
-  // 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));
+  EXPECT_EQ(last_value_written_on_tx_characteristic_, kLargePackets[0]);
   std::vector<uint8_t> bytes_received(
-      last_value_written_on_to_peripheral_char_.begin() + 8,
-      last_value_written_on_to_peripheral_char_.end());
+      last_value_written_on_tx_characteristic_.begin() + 1,
+      last_value_written_on_tx_characteristic_.end());
 
-  // Expecting a second call of WriteRemoteCharacteristic, after success
-  // callback is called.
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   RunWriteCharacteristicSuccessCallback();
   bytes_received.insert(bytes_received.end(),
-                        last_value_written_on_to_peripheral_char_.begin() + 1,
-                        last_value_written_on_to_peripheral_char_.end());
+                        last_value_written_on_tx_characteristic_.begin() + 1,
+                        last_value_written_on_tx_characteristic_.end());
 
-  // Expecting that the message was written.
-  std::vector<uint8_t> expected_value(message.begin(), message.end());
-  EXPECT_EQ(expected_value.size(), bytes_received.size());
-  EXPECT_EQ(expected_value, bytes_received);
+  std::vector<uint8_t> expected(kLargeMessage.begin(), kLargeMessage.end());
+  EXPECT_EQ(expected, bytes_received);
 
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
   RunWriteCharacteristicSuccessCallback();
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_AfterADelayWhenThrottled) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectAfterDelayWhenThrottled) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
 
   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->sub_status(), SubStatus::WAITING_GATT_CONNECTION);
   EXPECT_EQ(connection->status(), 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::WrapUnique(new NiceMock<device::MockBluetoothGattConnection>(
           adapter_, kTestRemoteDeviceBluetoothAddress)));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
-  ResponseSignalReceived(connection.get());
+  ConnectionResponseReceived(connection.get(), kDefaultMaxPacketSize);
 }
 
+}  // namespace weave
+
 }  // namespace proximity_auth