Skip to content

GitLab

T
tangled
Commit 05a1565a authored by Kyle Horimoto's avatar Kyle Horimoto Committed by Commit Bot
Browse files
Options

[CrOS PhoneHub] Handle pending Nearby connection requests 

This CL implements a TODO in PendingConnectionManagerImpl to handle
incoming requests for connections via the Nearby Connections library.
When a request is received, we create a NearbyInitiatorConnectionAttempt
(if one does not already exist), then add a new
PendingNearbyInitiatorConnectionRequest to it.

Additionally, this CL updates the initialization flow for the
SecureChannel service so that it now creates an instance of
NearbyConnectionManager.

Bug: 1106937
Change-Id: Ibe56476babfb201b748beed1fefc80efda7e304e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2419374
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: default avatarJames Vecore <vecore@google.com>
Cr-Commit-Position: refs/heads/master@{#809534}
parent da6b36bc
Hide whitespace changes
Inline Side-by-side
Showing with 683 additions and 175 deletions
chromeos/services/secure_channel/pending_connection_manager_impl.cc
View file @ 05a1565a
......@@ -10,8 +10,10 @@
#include "chromeos/services/secure_channel/authenticated_channel.h"
#include "chromeos/services/secure_channel/ble_initiator_connection_attempt.h"
#include "chromeos/services/secure_channel/ble_listener_connection_attempt.h"
#include "chromeos/services/secure_channel/nearby_initiator_connection_attempt.h"
#include "chromeos/services/secure_channel/pending_ble_initiator_connection_request.h"
#include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
#include "chromeos/services/secure_channel/pending_nearby_initiator_connection_request.h"
namespace chromeos {
......@@ -26,14 +28,17 @@ std::unique_ptr<PendingConnectionManager>
PendingConnectionManagerImpl::Factory::Create(
Delegate* delegate,
BleConnectionManager* ble_connection_manager,
NearbyConnectionManager* nearby_connection_manager,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) {
if (test_factory_) {
return test_factory_->CreateInstance(delegate, ble_connection_manager,
nearby_connection_manager,
bluetooth_adapter);
}
return base::WrapUnique(new PendingConnectionManagerImpl(
delegate, ble_connection_manager, bluetooth_adapter));
delegate, ble_connection_manager, nearby_connection_manager,
bluetooth_adapter));
}
// static
......@@ -47,9 +52,11 @@ PendingConnectionManagerImpl::Factory::~Factory() = default;
PendingConnectionManagerImpl::PendingConnectionManagerImpl(
Delegate* delegate,
BleConnectionManager* ble_connection_manager,
NearbyConnectionManager* nearby_connection_manager,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
: PendingConnectionManager(delegate),
ble_connection_manager_(ble_connection_manager),
nearby_connection_manager_(nearby_connection_manager),
bluetooth_adapter_(bluetooth_adapter) {}
PendingConnectionManagerImpl::~PendingConnectionManagerImpl() = default;
......@@ -114,22 +121,8 @@ void PendingConnectionManagerImpl::OnConnectionAttemptSucceeded(
// connection attempt, add them to |all_clients|, and remove the associated
// map entries.
for (const auto& connection_attempt_details : to_process) {
std::vector<std::unique_ptr<ClientConnectionParameters>> clients_in_loop;
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole:
clients_in_loop = ConnectionAttempt<BleInitiatorFailureType>::
ExtractClientConnectionParameters(
std::move(id_pair_to_ble_initiator_connection_attempts_
[connection_attempt_details.device_id_pair()]));
break;
case ConnectionRole::kListenerRole:
clients_in_loop = ConnectionAttempt<BleListenerFailureType>::
ExtractClientConnectionParameters(
std::move(id_pair_to_ble_listener_connection_attempts_
[connection_attempt_details.device_id_pair()]));
break;
}
std::vector<std::unique_ptr<ClientConnectionParameters>> clients_in_loop =
ExtractClientConnectionParameters(connection_attempt_details);
// Move elements in |clients_in_list| to |all_clients|.
all_clients.insert(all_clients.end(),
......@@ -238,7 +231,9 @@ void PendingConnectionManagerImpl::HandleNearbyRequest(
ConnectionPriority connection_priority) {
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole:
// TODO(khorimoto): Attempt Nearby Connection.
HandleNearbyInitiatorRequest(connection_attempt_details,
std::move(client_connection_parameters),
connection_priority);
break;
case ConnectionRole::kListenerRole:
NOTREACHED()
......@@ -248,46 +243,89 @@ void PendingConnectionManagerImpl::HandleNearbyRequest(
}
}
void PendingConnectionManagerImpl::HandleNearbyInitiatorRequest(
const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority) {
// If no ConnectionAttempt exists to this device in the initiator role, create
// one.
if (!base::Contains(id_pair_to_nearby_initiator_connection_attempts_,
connection_attempt_details.device_id_pair())) {
id_pair_to_nearby_initiator_connection_attempts_[connection_attempt_details
.device_id_pair()] =
NearbyInitiatorConnectionAttempt::Factory::Create(
nearby_connection_manager_, this /* delegate */,
connection_attempt_details);
}
auto& connection_attempt = id_pair_to_nearby_initiator_connection_attempts_
[connection_attempt_details.device_id_pair()];
bool success = connection_attempt->AddPendingConnectionRequest(
PendingNearbyInitiatorConnectionRequest::Factory::Create(
std::move(client_connection_parameters), connection_priority,
connection_attempt.get() /* delegate */, bluetooth_adapter_));
if (!success) {
PA_LOG(ERROR)
<< "PendingConnectionManagerImpl::"
<< "HandleNearbyInitiatorRequest(): Not able to handle request. "
<< "Details: " << connection_attempt_details
<< ", Client parameters: " << *client_connection_parameters;
NOTREACHED();
}
}
std::vector<std::unique_ptr<ClientConnectionParameters>>
PendingConnectionManagerImpl::ExtractClientConnectionParameters(
const ConnectionAttemptDetails& connection_attempt_details) {
switch (connection_attempt_details.connection_medium()) {
case ConnectionMedium::kBluetoothLowEnergy:
switch (connection_attempt_details.connection_role()) {
// BLE initiator:
case ConnectionRole::kInitiatorRole:
return ConnectionAttempt<BleInitiatorFailureType>::
ExtractClientConnectionParameters(
std::move(id_pair_to_ble_initiator_connection_attempts_
[connection_attempt_details.device_id_pair()]));
// BLE listener:
case ConnectionRole::kListenerRole:
return ConnectionAttempt<BleListenerFailureType>::
ExtractClientConnectionParameters(
std::move(id_pair_to_ble_listener_connection_attempts_
[connection_attempt_details.device_id_pair()]));
}
case ConnectionMedium::kNearbyConnections:
switch (connection_attempt_details.connection_role()) {
// Nearby initiator:
case ConnectionRole::kInitiatorRole:
return ConnectionAttempt<NearbyInitiatorFailureType>::
ExtractClientConnectionParameters(
std::move(id_pair_to_nearby_initiator_connection_attempts_
[connection_attempt_details.device_id_pair()]));
// Nearby listener:
case ConnectionRole::kListenerRole:
NOTREACHED() << "Nearby listener connections are not implemented.";
return std::vector<std::unique_ptr<ClientConnectionParameters>>();
}
}
}
void PendingConnectionManagerImpl::RemoveMapEntriesForFinishedConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
// Make a copy of |connection_attempt_details|, since it belongs to the
// ConnectionAttempt which is about to be deleted below.
ConnectionAttemptDetails connection_attempt_details_copy =
connection_attempt_details;
switch (connection_attempt_details_copy.connection_role()) {
case ConnectionRole::kInitiatorRole: {
size_t num_deleted = id_pair_to_ble_initiator_connection_attempts_.erase(
connection_attempt_details_copy.device_id_pair());
if (num_deleted != 1u) {
PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
<< "RemoveMapEntriesForFinishedConnectionAttempt(): "
<< "Tried to remove failed initiator ConnectionAttempt, "
<< "but it was not present in the map. Details: "
<< connection_attempt_details_copy;
NOTREACHED();
}
break;
}
case ConnectionRole::kListenerRole: {
size_t num_deleted = id_pair_to_ble_listener_connection_attempts_.erase(
connection_attempt_details_copy.device_id_pair());
if (num_deleted != 1u) {
PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
<< "RemoveMapEntriesForFinishedConnectionAttempt(): "
<< "Tried to remove failed listener ConnectionAttempt, "
<< "but it was not present in the map. Details: "
<< connection_attempt_details_copy;
NOTREACHED();
}
break;
}
}
ConnectionDetails connection_details =
connection_attempt_details_copy.GetAssociatedConnectionDetails();
RemoveIdPairToConnectionAttemptMapEntriesForFinishedConnectionAttempt(
connection_attempt_details_copy);
size_t num_deleted =
details_to_attempt_details_map_[connection_details].erase(
connection_attempt_details_copy);
......@@ -306,6 +344,66 @@ void PendingConnectionManagerImpl::RemoveMapEntriesForFinishedConnectionAttempt(
details_to_attempt_details_map_.erase(connection_details);
}
void PendingConnectionManagerImpl::
RemoveIdPairToConnectionAttemptMapEntriesForFinishedConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
switch (connection_attempt_details.connection_medium()) {
case ConnectionMedium::kBluetoothLowEnergy:
switch (connection_attempt_details.connection_role()) {
// BLE initiator.
case ConnectionRole::kInitiatorRole: {
size_t num_deleted =
id_pair_to_ble_initiator_connection_attempts_.erase(
connection_attempt_details.device_id_pair());
if (num_deleted != 1u) {
PA_LOG(ERROR) << "Tried to remove failed BLE initiator "
<< "ConnectionAttempt, but it was not present in the "
<< "map. Details: " << connection_attempt_details;
NOTREACHED();
}
break;
}
// BLE listener.
case ConnectionRole::kListenerRole: {
size_t num_deleted =
id_pair_to_ble_listener_connection_attempts_.erase(
connection_attempt_details.device_id_pair());
if (num_deleted != 1u) {
PA_LOG(ERROR) << "Tried to remove failed BLE listener "
<< "ConnectionAttempt, but it was not present in the "
<< "map. Details: " << connection_attempt_details;
NOTREACHED();
}
break;
}
}
break;
case ConnectionMedium::kNearbyConnections:
switch (connection_attempt_details.connection_role()) {
// Nearby initiator.
case ConnectionRole::kInitiatorRole: {
size_t num_deleted =
id_pair_to_nearby_initiator_connection_attempts_.erase(
connection_attempt_details.device_id_pair());
if (num_deleted != 1u) {
PA_LOG(ERROR) << "Tried to remove failed Nearby initiator "
<< "ConnectionAttempt, but it was not present in the "
<< "map. Details: " << connection_attempt_details;
NOTREACHED();
}
break;
}
case ConnectionRole::kListenerRole:
NOTREACHED();
break;
}
break;
}
}
} // namespace secure_channel
} // namespace chromeos
chromeos/services/secure_channel/pending_connection_manager_impl.h
View file @ 05a1565a
......@@ -18,6 +18,7 @@
#include "chromeos/services/secure_channel/connection_attempt_delegate.h"
#include "chromeos/services/secure_channel/connection_role.h"
#include "chromeos/services/secure_channel/device_id_pair.h"
#include "chromeos/services/secure_channel/nearby_initiator_failure_type.h"
#include "chromeos/services/secure_channel/pending_connection_manager.h"
#include "chromeos/services/secure_channel/public/cpp/shared/connection_medium.h"
#include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
......@@ -28,6 +29,7 @@ namespace chromeos {
namespace secure_channel {
class BleConnectionManager;
class NearbyConnectionManager;
// Concrete PendingConnectionManager implementation. This class creates one
// ConnectionAttempt per ConnectionAttemptDetails requested; if more than one
......@@ -45,6 +47,7 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
static std::unique_ptr<PendingConnectionManager> Create(
Delegate* delegate,
BleConnectionManager* ble_connection_manager,
NearbyConnectionManager* nearby_connection_manager,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
static void SetFactoryForTesting(Factory* test_factory);
......@@ -53,6 +56,7 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
virtual std::unique_ptr<PendingConnectionManager> CreateInstance(
Delegate* delegate,
BleConnectionManager* ble_connection_manager,
NearbyConnectionManager* nearby_connection_manager,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) = 0;
private:
......@@ -65,6 +69,7 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
PendingConnectionManagerImpl(
Delegate* delegate,
BleConnectionManager* ble_connection_manager,
NearbyConnectionManager* nearby_connection_manager,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
// PendingConnectionManager:
......@@ -97,9 +102,29 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority);
void HandleNearbyInitiatorRequest(
const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority);
// Retrieves ClientConnectionParameters for a given connection attempt.
// Because a single connection attempt may have multiple client requests
// (e.g., when multiple clients requets a connection at the same time), this
// function returns a vector.
//
// Note that this function std::move()s results from the |id_pair_to_*_| maps
// below, so these maps will end up having "empty" values after the function
// is called. This function is expected to be used in conjunction with
// RemoveMapEntriesForFinishedConnectionAttempt(), which cleans up those empty
// values.
std::vector<std::unique_ptr<ClientConnectionParameters>>
ExtractClientConnectionParameters(
const ConnectionAttemptDetails& connection_attempt_details);
void RemoveMapEntriesForFinishedConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details);
void RemoveIdPairToConnectionAttemptMapEntriesForFinishedConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details);
base::flat_map<DeviceIdPair,
std::unique_ptr<ConnectionAttempt<BleInitiatorFailureType>>>
......@@ -109,10 +134,15 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
std::unique_ptr<ConnectionAttempt<BleListenerFailureType>>>
id_pair_to_ble_listener_connection_attempts_;
base::flat_map<DeviceIdPair,
std::unique_ptr<ConnectionAttempt<NearbyInitiatorFailureType>>>
id_pair_to_nearby_initiator_connection_attempts_;
base::flat_map<ConnectionDetails, base::flat_set<ConnectionAttemptDetails>>
details_to_attempt_details_map_;
BleConnectionManager* ble_connection_manager_;
NearbyConnectionManager* nearby_connection_manager_;
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
DISALLOW_COPY_AND_ASSIGN(PendingConnectionManagerImpl);
......
chromeos/services/secure_channel/pending_connection_manager_impl_unittest.cc
View file @ 05a1565a
......@@ -18,10 +18,13 @@
#include "chromeos/services/secure_channel/fake_ble_connection_manager.h"
#include "chromeos/services/secure_channel/fake_client_connection_parameters.h"
#include "chromeos/services/secure_channel/fake_connection_attempt.h"
#include "chromeos/services/secure_channel/fake_nearby_connection_manager.h"
#include "chromeos/services/secure_channel/fake_pending_connection_manager.h"
#include "chromeos/services/secure_channel/fake_pending_connection_request.h"
#include "chromeos/services/secure_channel/nearby_initiator_connection_attempt.h"
#include "chromeos/services/secure_channel/pending_ble_initiator_connection_request.h"
#include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
#include "chromeos/services/secure_channel/pending_nearby_initiator_connection_request.h"
#include "device/bluetooth/test/mock_bluetooth_adapter.h"
#include "testing/gtest/include/gtest/gtest.h"
......@@ -187,6 +190,84 @@ class FakeBleListenerConnectionAttemptFactory
DISALLOW_COPY_AND_ASSIGN(FakeBleListenerConnectionAttemptFactory);
};
class FakeNearbyInitiatorConnectionAttemptFactory
: public NearbyInitiatorConnectionAttempt::Factory {
public:
FakeNearbyInitiatorConnectionAttemptFactory(
FakeNearbyConnectionManager* expected_nearby_connection_manager)
: expected_nearby_connection_manager_(
expected_nearby_connection_manager) {}
~FakeNearbyInitiatorConnectionAttemptFactory() override = default;
void set_expected_connection_attempt_details(
const ConnectionAttemptDetails& expected_connection_attempt_details) {
expected_connection_attempt_details_ = expected_connection_attempt_details;
}
base::flat_map<ConnectionAttemptDetails,
FakeConnectionAttempt<NearbyInitiatorFailureType>*>&
details_to_active_attempt_map() {
return details_to_active_attempt_map_;
}
size_t num_instances_created() const { return num_instances_created_; }
size_t num_instances_deleted() const { return num_instances_deleted_; }
FakeConnectionAttempt<NearbyInitiatorFailureType>* last_created_instance() {
return last_created_instance_;
}
private:
// NearbyInitiatorConnectionAttempt::Factory:
std::unique_ptr<ConnectionAttempt<NearbyInitiatorFailureType>> CreateInstance(
NearbyConnectionManager* nearby_connection_manager,
ConnectionAttemptDelegate* delegate,
const ConnectionAttemptDetails& connection_attempt_details) override {
EXPECT_EQ(ConnectionRole::kInitiatorRole,
connection_attempt_details.connection_role());
EXPECT_EQ(expected_nearby_connection_manager_, nearby_connection_manager);
EXPECT_EQ(*expected_connection_attempt_details_,
connection_attempt_details);
auto instance =
std::make_unique<FakeConnectionAttempt<NearbyInitiatorFailureType>>(
delegate, connection_attempt_details,
base::BindOnce(
&FakeNearbyInitiatorConnectionAttemptFactory::OnAttemptDeleted,
base::Unretained(this), connection_attempt_details));
++num_instances_created_;
last_created_instance_ = instance.get();
details_to_active_attempt_map_[connection_attempt_details] =
last_created_instance_;
return instance;
}
void OnAttemptDeleted(
const ConnectionAttemptDetails& connection_attempt_details) {
size_t num_erased =
details_to_active_attempt_map_.erase(connection_attempt_details);
EXPECT_EQ(1u, num_erased);
++num_instances_deleted_;
}
FakeNearbyConnectionManager* expected_nearby_connection_manager_;
base::Optional<ConnectionAttemptDetails> expected_connection_attempt_details_;
base::flat_map<ConnectionAttemptDetails,
FakeConnectionAttempt<NearbyInitiatorFailureType>*>
details_to_active_attempt_map_;
size_t num_instances_created_ = 0u;
size_t num_instances_deleted_ = 0u;
FakeConnectionAttempt<NearbyInitiatorFailureType>* last_created_instance_ =
nullptr;
DISALLOW_COPY_AND_ASSIGN(FakeNearbyInitiatorConnectionAttemptFactory);
};
class FakePendingBleInitiatorConnectionRequestFactory
: public PendingBleInitiatorConnectionRequest::Factory {
public:
......@@ -281,6 +362,53 @@ class FakePendingBleListenerConnectionRequestFactory
DISALLOW_COPY_AND_ASSIGN(FakePendingBleListenerConnectionRequestFactory);
};
class FakePendingNearbyInitiatorConnectionRequestFactory
: public PendingNearbyInitiatorConnectionRequest::Factory {
public:
FakePendingNearbyInitiatorConnectionRequestFactory() = default;
~FakePendingNearbyInitiatorConnectionRequestFactory() override = default;
void SetExpectationsForNextCall(
ClientConnectionParameters* expected_client_connection_parameters,
ConnectionPriority expected_connection_priority) {
expected_client_connection_parameters_ =
expected_client_connection_parameters;
expected_connection_priority_ = expected_connection_priority;
}
FakePendingConnectionRequest<NearbyInitiatorFailureType>*
last_created_instance() {
return last_created_instance_;
}
private:
// PendingNearbyInitiatorConnectionRequest::Factory:
std::unique_ptr<PendingConnectionRequest<NearbyInitiatorFailureType>>
CreateInstance(
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority,
PendingConnectionRequestDelegate* delegate,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) override {
EXPECT_EQ(expected_client_connection_parameters_,
client_connection_parameters.get());
EXPECT_EQ(*expected_connection_priority_, connection_priority);
auto instance = std::make_unique<
FakePendingConnectionRequest<NearbyInitiatorFailureType>>(
delegate, connection_priority);
last_created_instance_ = instance.get();
return instance;
}
ClientConnectionParameters* expected_client_connection_parameters_ = nullptr;
base::Optional<ConnectionPriority> expected_connection_priority_;
FakePendingConnectionRequest<NearbyInitiatorFailureType>*
last_created_instance_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(FakePendingNearbyInitiatorConnectionRequestFactory);
};
std::vector<std::unique_ptr<ClientConnectionParameters>>
GenerateFakeClientParameters(size_t num_to_generate) {
std::vector<std::unique_ptr<ClientConnectionParameters>> client_parameters;
......@@ -317,6 +445,8 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
void SetUp() override {
fake_delegate_ = std::make_unique<FakePendingConnectionManagerDelegate>();
fake_ble_connection_manager_ = std::make_unique<FakeBleConnectionManager>();
fake_nearby_connection_manager_ =
std::make_unique<FakeNearbyConnectionManager>();
fake_ble_initiator_connection_attempt_factory_ =
std::make_unique<FakeBleInitiatorConnectionAttemptFactory>(
......@@ -330,6 +460,12 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
BleListenerConnectionAttempt::Factory::SetFactoryForTesting(
fake_ble_listener_connection_attempt_factory_.get());
fake_nearby_initiator_connection_attempt_factory_ =
std::make_unique<FakeNearbyInitiatorConnectionAttemptFactory>(
fake_nearby_connection_manager_.get());
NearbyInitiatorConnectionAttempt::Factory::SetFactoryForTesting(
fake_nearby_initiator_connection_attempt_factory_.get());
fake_pending_ble_initiator_connection_request_factory_ =
std::make_unique<FakePendingBleInitiatorConnectionRequestFactory>();
PendingBleInitiatorConnectionRequest::Factory::SetFactoryForTesting(
......@@ -340,20 +476,28 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
PendingBleListenerConnectionRequest::Factory::SetFactoryForTesting(
fake_pending_ble_listener_connection_request_factory_.get());
fake_pending_nearby_initiator_connection_request_factory_ =
std::make_unique<FakePendingNearbyInitiatorConnectionRequestFactory>();
PendingNearbyInitiatorConnectionRequest::Factory::SetFactoryForTesting(
fake_pending_nearby_initiator_connection_request_factory_.get());
mock_adapter_ =
base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
manager_ = PendingConnectionManagerImpl::Factory::Create(
fake_delegate_.get(), fake_ble_connection_manager_.get(),
mock_adapter_);
fake_nearby_connection_manager_.get(), mock_adapter_);
}
void TearDown() override {
BleInitiatorConnectionAttempt::Factory::SetFactoryForTesting(nullptr);
BleListenerConnectionAttempt::Factory::SetFactoryForTesting(nullptr);
NearbyInitiatorConnectionAttempt::Factory::SetFactoryForTesting(nullptr);
PendingBleInitiatorConnectionRequest::Factory::SetFactoryForTesting(
nullptr);
PendingBleListenerConnectionRequest::Factory::SetFactoryForTesting(nullptr);
PendingNearbyInitiatorConnectionRequest::Factory::SetFactoryForTesting(
nullptr);
}
void HandleCanceledRequestAndVerifyNoInstancesCreated(
......@@ -365,6 +509,10 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
FakeConnectionAttempt<
BleListenerFailureType>* last_ble_listener_attempt_before_call =
fake_ble_listener_connection_attempt_factory_->last_created_instance();
FakeConnectionAttempt<NearbyInitiatorFailureType>*
last_nearby_initiator_attempt_before_call =
fake_nearby_initiator_connection_attempt_factory_
->last_created_instance();
FakePendingConnectionRequest<BleInitiatorFailureType>*
last_ble_initiator_request_before_call =
fake_pending_ble_initiator_connection_request_factory_
......@@ -373,6 +521,10 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
last_ble_listener_request_before_call =
fake_pending_ble_listener_connection_request_factory_
->last_created_instance();
FakePendingConnectionRequest<NearbyInitiatorFailureType>*
last_nearby_initiator_request_before_call =
fake_pending_nearby_initiator_connection_request_factory_
->last_created_instance();
HandleConnectionRequest(connection_attempt_details, connection_priority,
true /* cancel_request_before_adding */);
......@@ -385,12 +537,18 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
EXPECT_EQ(
last_ble_listener_attempt_before_call,
fake_ble_listener_connection_attempt_factory_->last_created_instance());
EXPECT_EQ(last_nearby_initiator_attempt_before_call,
fake_nearby_initiator_connection_attempt_factory_
->last_created_instance());
EXPECT_EQ(last_ble_initiator_request_before_call,
fake_pending_ble_initiator_connection_request_factory_
->last_created_instance());
EXPECT_EQ(last_ble_listener_request_before_call,
fake_pending_ble_listener_connection_request_factory_
->last_created_instance());
EXPECT_EQ(last_nearby_initiator_request_before_call,
fake_pending_nearby_initiator_connection_request_factory_
->last_created_instance());
}
void HandleRequestAndVerifyHandledByConnectionAttempt(
......@@ -398,59 +556,92 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
ConnectionPriority connection_priority) {
HandleConnectionRequest(connection_attempt_details, connection_priority,
false /* cancel_request_before_adding */);
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole: {
FakeConnectionAttempt<BleInitiatorFailureType>* active_attempt =
GetActiveInitiatorAttempt(connection_attempt_details);
base::UnguessableToken token_for_last_init_request =
fake_pending_ble_initiator_connection_request_factory_
->last_created_instance()
->GetRequestId();
EXPECT_TRUE(base::Contains(active_attempt->id_to_request_map(),
token_for_last_init_request));
switch (connection_attempt_details.connection_medium()) {
case ConnectionMedium::kBluetoothLowEnergy:
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole: {
FakeConnectionAttempt<BleInitiatorFailureType>* active_attempt =
GetActiveBleInitiatorAttempt(connection_attempt_details);
base::UnguessableToken token_for_last_init_request =
fake_pending_ble_initiator_connection_request_factory_
->last_created_instance()
->GetRequestId();
EXPECT_TRUE(base::Contains(active_attempt->id_to_request_map(),
token_for_last_init_request));
break;
}
case ConnectionRole::kListenerRole: {
FakeConnectionAttempt<BleListenerFailureType>* active_attempt =
GetActiveBleListenerAttempt(connection_attempt_details);
base::UnguessableToken token_for_last_listen_request =
fake_pending_ble_listener_connection_request_factory_
->last_created_instance()
->GetRequestId();
EXPECT_TRUE(base::Contains(active_attempt->id_to_request_map(),
token_for_last_listen_request));
break;
}
}
break;
}
case ConnectionRole::kListenerRole: {
FakeConnectionAttempt<BleListenerFailureType>* active_attempt =
GetActiveListenerAttempt(connection_attempt_details);
base::UnguessableToken token_for_last_listen_request =
fake_pending_ble_listener_connection_request_factory_
->last_created_instance()
->GetRequestId();
EXPECT_TRUE(base::Contains(active_attempt->id_to_request_map(),
token_for_last_listen_request));
case ConnectionMedium::kNearbyConnections:
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole: {
FakeConnectionAttempt<NearbyInitiatorFailureType>* active_attempt =
GetActiveNearbyInitiatorAttempt(connection_attempt_details);
base::UnguessableToken token_for_last_init_request =
fake_pending_nearby_initiator_connection_request_factory_
->last_created_instance()
->GetRequestId();
EXPECT_TRUE(base::Contains(active_attempt->id_to_request_map(),
token_for_last_init_request));
break;
}
case ConnectionRole::kListenerRole:
NOTREACHED();
}
break;
}
}
}
void FinishInitiatorAttemptWithoutConnection(
void FinishBleInitiatorAttemptWithoutConnection(
FakeConnectionAttempt<BleInitiatorFailureType>* attempt) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveInitiatorAttempt(details_for_attempt), attempt);
EXPECT_EQ(GetActiveBleInitiatorAttempt(details_for_attempt), attempt);
attempt->OnConnectionAttemptFinishedWithoutConnection();
EXPECT_FALSE(GetActiveInitiatorAttempt(details_for_attempt));
EXPECT_FALSE(GetActiveBleInitiatorAttempt(details_for_attempt));
}
void FinishListenerAttemptWithoutConnection(
void FinishBleListenerAttemptWithoutConnection(
FakeConnectionAttempt<BleListenerFailureType>* attempt) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveListenerAttempt(details_for_attempt), attempt);
EXPECT_EQ(GetActiveBleListenerAttempt(details_for_attempt), attempt);
attempt->OnConnectionAttemptFinishedWithoutConnection();
EXPECT_FALSE(GetActiveBleListenerAttempt(details_for_attempt));
}
void FinishNearbyInitiatorAttemptWithoutConnection(
FakeConnectionAttempt<NearbyInitiatorFailureType>* attempt) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveNearbyInitiatorAttempt(details_for_attempt), attempt);
attempt->OnConnectionAttemptFinishedWithoutConnection();
EXPECT_FALSE(GetActiveListenerAttempt(details_for_attempt));
EXPECT_FALSE(GetActiveNearbyInitiatorAttempt(details_for_attempt));
}
void FinishInitiatorAttemptWithConnection(
void FinishBleInitiatorAttemptWithConnection(
FakeConnectionAttempt<BleInitiatorFailureType>* attempt,
size_t num_extracted_clients_to_generate) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveInitiatorAttempt(details_for_attempt), attempt);
EXPECT_EQ(GetActiveBleInitiatorAttempt(details_for_attempt), attempt);
FakePendingConnectionManagerDelegate::ReceivedConnectionsList&
received_connections = fake_delegate_->received_connections_list();
......@@ -469,7 +660,7 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
attempt->set_client_data_for_extraction(std::move(clients_to_send));
attempt->OnConnectionAttemptSucceeded(move(fake_authenticated_channel));
EXPECT_FALSE(GetActiveInitiatorAttempt(details_for_attempt));
EXPECT_FALSE(GetActiveBleInitiatorAttempt(details_for_attempt));
EXPECT_EQ(num_received_connections_before_call + 1u,
received_connections.size());
EXPECT_EQ(fake_authenticated_channel_raw,
......@@ -480,12 +671,47 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
std::get<2>(received_connections.back()));
}
void FinishListenerAttemptWithConnection(
void FinishBleListenerAttemptWithConnection(
FakeConnectionAttempt<BleListenerFailureType>* attempt,
size_t num_extracted_clients_to_generate) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveListenerAttempt(details_for_attempt), attempt);
EXPECT_EQ(GetActiveBleListenerAttempt(details_for_attempt), attempt);
FakePendingConnectionManagerDelegate::ReceivedConnectionsList&
received_connections = fake_delegate_->received_connections_list();
size_t num_received_connections_before_call = received_connections.size();
auto fake_authenticated_channel =
std::make_unique<FakeAuthenticatedChannel>();
FakeAuthenticatedChannel* fake_authenticated_channel_raw =
fake_authenticated_channel.get();
std::vector<std::unique_ptr<ClientConnectionParameters>> clients_to_send =
GenerateFakeClientParameters(num_extracted_clients_to_generate);
std::vector<ClientConnectionParameters*> raw_client_list =
ClientParamsListToRawPtrs(clients_to_send);
attempt->set_client_data_for_extraction(std::move(clients_to_send));
attempt->OnConnectionAttemptSucceeded(move(fake_authenticated_channel));
EXPECT_FALSE(GetActiveBleListenerAttempt(details_for_attempt));
EXPECT_EQ(num_received_connections_before_call + 1u,
received_connections.size());
EXPECT_EQ(fake_authenticated_channel_raw,
std::get<0>(received_connections.back()).get());
EXPECT_EQ(raw_client_list, ClientParamsListToRawPtrs(
std::get<1>(received_connections.back())));
EXPECT_EQ(details_for_attempt.GetAssociatedConnectionDetails(),
std::get<2>(received_connections.back()));
}
void FinishNearbyInitiatorAttemptWithConnection(
FakeConnectionAttempt<NearbyInitiatorFailureType>* attempt,
size_t num_extracted_clients_to_generate) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveNearbyInitiatorAttempt(details_for_attempt), attempt);
FakePendingConnectionManagerDelegate::ReceivedConnectionsList&
received_connections = fake_delegate_->received_connections_list();
......@@ -504,7 +730,7 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
attempt->set_client_data_for_extraction(std::move(clients_to_send));
attempt->OnConnectionAttemptSucceeded(move(fake_authenticated_channel));
EXPECT_FALSE(GetActiveListenerAttempt(details_for_attempt));
EXPECT_FALSE(GetActiveNearbyInitiatorAttempt(details_for_attempt));
EXPECT_EQ(num_received_connections_before_call + 1u,
received_connections.size());
EXPECT_EQ(fake_authenticated_channel_raw,
......@@ -515,38 +741,55 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
std::get<2>(received_connections.back()));
}
FakeConnectionAttempt<BleInitiatorFailureType>* GetActiveInitiatorAttempt(
FakeConnectionAttempt<BleInitiatorFailureType>* GetActiveBleInitiatorAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
return fake_ble_initiator_connection_attempt_factory_
->details_to_active_attempt_map()[connection_attempt_details];
}
FakeConnectionAttempt<BleListenerFailureType>* GetActiveListenerAttempt(
FakeConnectionAttempt<BleListenerFailureType>* GetActiveBleListenerAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
return fake_ble_listener_connection_attempt_factory_
->details_to_active_attempt_map()[connection_attempt_details];
}
size_t GetNumInitiatorAttemptsCreated() {
FakeConnectionAttempt<NearbyInitiatorFailureType>*
GetActiveNearbyInitiatorAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
return fake_nearby_initiator_connection_attempt_factory_
->details_to_active_attempt_map()[connection_attempt_details];
}
size_t GetNumBleInitiatorAttemptsCreated() {
return fake_ble_initiator_connection_attempt_factory_
->num_instances_created();
}
size_t GetNumListenerAttemptsCreated() {
size_t GetNumBleListenerAttemptsCreated() {
return fake_ble_listener_connection_attempt_factory_
->num_instances_created();
}
size_t GetNumInitiatorAttemptsDeleted() {
size_t GetNumNearbyInitiatorAttemptsCreated() {
return fake_nearby_initiator_connection_attempt_factory_
->num_instances_created();
}
size_t GetNumBleInitiatorAttemptsDeleted() {
return fake_ble_initiator_connection_attempt_factory_
->num_instances_deleted();
}
size_t GetNumListenerAttemptsDeleted() {
size_t GetNumBleListenerAttemptsDeleted() {
return fake_ble_listener_connection_attempt_factory_
->num_instances_deleted();
}
size_t GetNumNearbyInitiatorAttemptsDeleted() {
return fake_nearby_initiator_connection_attempt_factory_
->num_instances_deleted();
}
private:
void HandleConnectionRequest(
const ConnectionAttemptDetails& connection_attempt_details,
......@@ -560,23 +803,47 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
if (cancel_request_before_adding) {
fake_client_connection_parameters->CancelClientRequest();
} else {
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole:
fake_ble_initiator_connection_attempt_factory_
->set_expected_connection_attempt_details(
connection_attempt_details);
fake_pending_ble_initiator_connection_request_factory_
->SetExpectationsForNextCall(
fake_client_connection_parameters_raw, connection_priority);
switch (connection_attempt_details.connection_medium()) {
case ConnectionMedium::kBluetoothLowEnergy:
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole:
fake_ble_initiator_connection_attempt_factory_
->set_expected_connection_attempt_details(
connection_attempt_details);
fake_pending_ble_initiator_connection_request_factory_
->SetExpectationsForNextCall(
fake_client_connection_parameters_raw,
connection_priority);
break;
case ConnectionRole::kListenerRole:
fake_ble_listener_connection_attempt_factory_
->set_expected_connection_attempt_details(
connection_attempt_details);
fake_pending_ble_listener_connection_request_factory_
->SetExpectationsForNextCall(
fake_client_connection_parameters_raw,
connection_priority);
break;
}
break;
case ConnectionRole::kListenerRole:
fake_ble_listener_connection_attempt_factory_
->set_expected_connection_attempt_details(
connection_attempt_details);
fake_pending_ble_listener_connection_request_factory_
->SetExpectationsForNextCall(
fake_client_connection_parameters_raw, connection_priority);
case ConnectionMedium::kNearbyConnections:
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole:
fake_nearby_initiator_connection_attempt_factory_
->set_expected_connection_attempt_details(
connection_attempt_details);
fake_pending_nearby_initiator_connection_request_factory_
->SetExpectationsForNextCall(
fake_client_connection_parameters_raw,
connection_priority);
break;
case ConnectionRole::kListenerRole:
NOTREACHED();
break;
}
break;
}
}
......@@ -590,15 +857,20 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
std::unique_ptr<FakePendingConnectionManagerDelegate> fake_delegate_;
std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
std::unique_ptr<FakeNearbyConnectionManager> fake_nearby_connection_manager_;
std::unique_ptr<FakeBleInitiatorConnectionAttemptFactory>
fake_ble_initiator_connection_attempt_factory_;
std::unique_ptr<FakeBleListenerConnectionAttemptFactory>
fake_ble_listener_connection_attempt_factory_;
std::unique_ptr<FakeNearbyInitiatorConnectionAttemptFactory>
fake_nearby_initiator_connection_attempt_factory_;
std::unique_ptr<FakePendingBleInitiatorConnectionRequestFactory>
fake_pending_ble_initiator_connection_request_factory_;
std::unique_ptr<FakePendingBleListenerConnectionRequestFactory>
fake_pending_ble_listener_connection_request_factory_;
std::unique_ptr<FakePendingNearbyInitiatorConnectionRequestFactory>
fake_pending_nearby_initiator_connection_request_factory_;
scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
std::unique_ptr<PendingConnectionManager> manager_;
......@@ -608,23 +880,30 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
TEST_F(SecureChannelPendingConnectionManagerImplTest,
CanceledRequestNotProcessed) {
// Initiator.
// BLE initiator.
HandleCanceledRequestAndVerifyNoInstancesCreated(
ConnectionAttemptDetails("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole),
ConnectionPriority::kLow);
// Listener.
// BLE listener.
HandleCanceledRequestAndVerifyNoInstancesCreated(
ConnectionAttemptDetails("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole),
ConnectionPriority::kLow);
// Nearby initiator.
HandleCanceledRequestAndVerifyNoInstancesCreated(
ConnectionAttemptDetails("remoteDeviceId", "localDeviceId",
ConnectionMedium::kNearbyConnections,
ConnectionRole::kInitiatorRole),
ConnectionPriority::kLow);
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptFinishesWithoutConnection_Initiator) {
AttemptFinishesWithoutConnection_BleInitiator) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
......@@ -632,20 +911,22 @@ TEST_F(SecureChannelPendingConnectionManagerImplTest,
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishInitiatorAttemptWithoutConnection(GetActiveInitiatorAttempt(details));
EXPECT_EQ(1u, GetNumInitiatorAttemptsCreated());
FinishBleInitiatorAttemptWithoutConnection(
GetActiveBleInitiatorAttempt(details));
EXPECT_EQ(1u, GetNumBleInitiatorAttemptsCreated());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishInitiatorAttemptWithoutConnection(GetActiveInitiatorAttempt(details));
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
FinishBleInitiatorAttemptWithoutConnection(
GetActiveBleInitiatorAttempt(details));
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptFinishesWithoutConnection_Listener) {
AttemptFinishesWithoutConnection_BleListener) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
......@@ -653,20 +934,45 @@ TEST_F(SecureChannelPendingConnectionManagerImplTest,
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishListenerAttemptWithoutConnection(GetActiveListenerAttempt(details));
EXPECT_EQ(1u, GetNumListenerAttemptsCreated());
FinishBleListenerAttemptWithoutConnection(
GetActiveBleListenerAttempt(details));
EXPECT_EQ(1u, GetNumBleListenerAttemptsCreated());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishBleListenerAttemptWithoutConnection(
GetActiveBleListenerAttempt(details));
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptFinishesWithoutConnection_NearbyInitiator) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kNearbyConnections,
ConnectionRole::kInitiatorRole);
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishNearbyInitiatorAttemptWithoutConnection(
GetActiveNearbyInitiatorAttempt(details));
EXPECT_EQ(1u, GetNumNearbyInitiatorAttemptsCreated());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishListenerAttemptWithoutConnection(GetActiveListenerAttempt(details));
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
FinishNearbyInitiatorAttemptWithoutConnection(
GetActiveNearbyInitiatorAttempt(details));
EXPECT_EQ(2u, GetNumNearbyInitiatorAttemptsCreated());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptSucceeds_Initiator) {
AttemptSucceeds_BleInitiator) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
......@@ -674,26 +980,26 @@ TEST_F(SecureChannelPendingConnectionManagerImplTest,
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details),
FinishBleInitiatorAttemptWithConnection(
GetActiveBleInitiatorAttempt(details),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(1u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(1u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumBleInitiatorAttemptsDeleted());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details),
FinishBleInitiatorAttemptWithConnection(
GetActiveBleInitiatorAttempt(details),
2u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptSucceeds_Listener) {
AttemptSucceeds_BleListener) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
......@@ -701,22 +1007,49 @@ TEST_F(SecureChannelPendingConnectionManagerImplTest,
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details),
FinishBleListenerAttemptWithConnection(
GetActiveBleListenerAttempt(details),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(1u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(1u, GetNumBleListenerAttemptsDeleted());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishBleListenerAttemptWithConnection(
GetActiveBleListenerAttempt(details),
2u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleListenerAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptSucceeds_NearbyInitiator) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kNearbyConnections,
ConnectionRole::kInitiatorRole);
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishNearbyInitiatorAttemptWithConnection(
GetActiveNearbyInitiatorAttempt(details),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(1u, GetNumListenerAttemptsCreated());
EXPECT_EQ(1u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumNearbyInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumNearbyInitiatorAttemptsDeleted());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details),
FinishNearbyInitiatorAttemptWithConnection(
GetActiveNearbyInitiatorAttempt(details),
2u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumNearbyInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumNearbyInitiatorAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
......@@ -744,22 +1077,22 @@ TEST_F(SecureChannelPendingConnectionManagerImplTest,
local_device_2_initiator_details, ConnectionPriority::kHigh);
HandleRequestAndVerifyHandledByConnectionAttempt(
local_device_2_listener_details, ConnectionPriority::kLow);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(0u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(0u, GetNumBleInitiatorAttemptsDeleted());
// Find a connection, arbitrarily choosing |local_device_1_initiator_details|
// as the request which produces the connection. Since all 4 of these requests
// were to the same remote device, all 4 of them should be deleted when the
// connection is established.
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(local_device_1_initiator_details),
FinishBleInitiatorAttemptWithConnection(
GetActiveBleInitiatorAttempt(local_device_1_initiator_details),
4u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
......@@ -787,47 +1120,47 @@ TEST_F(SecureChannelPendingConnectionManagerImplTest,
ConnectionPriority::kHigh);
HandleRequestAndVerifyHandledByConnectionAttempt(details_4,
ConnectionPriority::kLow);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(0u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(0u, GetNumBleInitiatorAttemptsDeleted());
// Find a connection for |details_1|; only one ConnectionAttempt should have
// been deleted.
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details_1),
FinishBleInitiatorAttemptWithConnection(
GetActiveBleInitiatorAttempt(details_1),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumBleInitiatorAttemptsDeleted());
// Find a connection for |details_2|.
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details_2),
FinishBleListenerAttemptWithConnection(
GetActiveBleListenerAttempt(details_2),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumBleInitiatorAttemptsDeleted());
// |details_3|.
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details_3),
FinishBleInitiatorAttemptWithConnection(
GetActiveBleInitiatorAttempt(details_3),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsDeleted());
// |details_4|.
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details_4),
FinishBleListenerAttemptWithConnection(
GetActiveBleListenerAttempt(details_4),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumBleListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumBleInitiatorAttemptsDeleted());
}
} // namespace secure_channel
......
chromeos/services/secure_channel/secure_channel_impl.cc
View file @ 05a1565a
......@@ -18,6 +18,7 @@
#include "chromeos/services/secure_channel/bluetooth_helper_impl.h"
#include "chromeos/services/secure_channel/client_connection_parameters_impl.h"
#include "chromeos/services/secure_channel/device_id_pair.h"
#include "chromeos/services/secure_channel/nearby_connection_manager_impl.h"
#include "chromeos/services/secure_channel/pending_connection_manager_impl.h"
#include "chromeos/services/secure_channel/timer_factory_impl.h"
#include "device/bluetooth/bluetooth_adapter.h"
......@@ -80,9 +81,12 @@ SecureChannelImpl::SecureChannelImpl(
ble_synchronizer_.get(),
ble_scanner_.get(),
timer_factory_.get())),
nearby_connection_manager_(
NearbyConnectionManagerImpl::Factory::Create()),
pending_connection_manager_(PendingConnectionManagerImpl::Factory::Create(
this /* delegate */,
ble_connection_manager_.get(),
nearby_connection_manager_.get(),
bluetooth_adapter_)),
active_connection_manager_(
ActiveConnectionManagerImpl::Factory::Create(this /* delegate */)) {}
......
chromeos/services/secure_channel/secure_channel_impl.h
View file @ 05a1565a
......@@ -32,6 +32,7 @@ class BleConnectionManager;
class BleScanner;
class BluetoothHelper;
class BleSynchronizerBase;
class NearbyConnectionManager;
class TimerFactory;
// Concrete SecureChannelImpl implementation, which contains three pieces:
......@@ -178,6 +179,7 @@ class SecureChannelImpl : public mojom::SecureChannel,
std::unique_ptr<BleSynchronizerBase> ble_synchronizer_;
std::unique_ptr<BleScanner> ble_scanner_;
std::unique_ptr<BleConnectionManager> ble_connection_manager_;
std::unique_ptr<NearbyConnectionManager> nearby_connection_manager_;
std::unique_ptr<PendingConnectionManager> pending_connection_manager_;
std::unique_ptr<ActiveConnectionManager> active_connection_manager_;
......
chromeos/services/secure_channel/secure_channel_service_unittest.cc
View file @ 05a1565a
......@@ -28,8 +28,10 @@
#include "chromeos/services/secure_channel/fake_bluetooth_helper.h"
#include "chromeos/services/secure_channel/fake_client_connection_parameters.h"
#include "chromeos/services/secure_channel/fake_connection_delegate.h"
#include "chromeos/services/secure_channel/fake_nearby_connection_manager.h"
#include "chromeos/services/secure_channel/fake_pending_connection_manager.h"
#include "chromeos/services/secure_channel/fake_timer_factory.h"
#include "chromeos/services/secure_channel/nearby_connection_manager_impl.h"
#include "chromeos/services/secure_channel/pending_connection_manager_impl.h"
#include "chromeos/services/secure_channel/public/cpp/shared/connection_priority.h"
#include "chromeos/services/secure_channel/public/mojom/secure_channel.mojom.h"
......@@ -236,13 +238,39 @@ class FakeBleConnectionManagerFactory
DISALLOW_COPY_AND_ASSIGN(FakeBleConnectionManagerFactory);
};
class FakeNearbyConnectionManagerFactory
: public NearbyConnectionManagerImpl::Factory {
public:
FakeNearbyConnectionManagerFactory() = default;
~FakeNearbyConnectionManagerFactory() override = default;
FakeNearbyConnectionManager* instance() { return instance_; }
private:
// NearbyConnectionManagerImpl::Factory:
std::unique_ptr<NearbyConnectionManager> CreateInstance() override {
EXPECT_FALSE(instance_);
auto instance = std::make_unique<FakeNearbyConnectionManager>();
instance_ = instance.get();
return instance;
}
FakeNearbyConnectionManager* instance_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(FakeNearbyConnectionManagerFactory);
};
class FakePendingConnectionManagerFactory
: public PendingConnectionManagerImpl::Factory {
public:
FakePendingConnectionManagerFactory(
FakeBleConnectionManagerFactory* fake_ble_connection_manager_factory)
FakeBleConnectionManagerFactory* fake_ble_connection_manager_factory,
FakeNearbyConnectionManagerFactory*
fake_nearby_connection_manager_factory)
: fake_ble_connection_manager_factory_(
fake_ble_connection_manager_factory) {}
fake_ble_connection_manager_factory),
fake_nearby_connection_manager_factory_(
fake_nearby_connection_manager_factory) {}
~FakePendingConnectionManagerFactory() override = default;
......@@ -253,10 +281,13 @@ class FakePendingConnectionManagerFactory
std::unique_ptr<PendingConnectionManager> CreateInstance(
PendingConnectionManager::Delegate* delegate,
BleConnectionManager* ble_connection_manager,
NearbyConnectionManager* nearby_connection_manager,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter) override {
EXPECT_FALSE(instance_);
EXPECT_EQ(fake_ble_connection_manager_factory_->instance(),
ble_connection_manager);
EXPECT_EQ(fake_nearby_connection_manager_factory_->instance(),
nearby_connection_manager);
auto instance = std::make_unique<FakePendingConnectionManager>(delegate);
instance_ = instance.get();
......@@ -264,6 +295,7 @@ class FakePendingConnectionManagerFactory
}
FakeBleConnectionManagerFactory* fake_ble_connection_manager_factory_;
FakeNearbyConnectionManagerFactory* fake_nearby_connection_manager_factory_;
FakePendingConnectionManager* instance_ = nullptr;
......@@ -447,9 +479,15 @@ class SecureChannelServiceTest : public testing::Test {
BleConnectionManagerImpl::Factory::SetFactoryForTesting(
fake_ble_connection_manager_factory_.get());
fake_nearby_connection_manager_factory_ =
std::make_unique<FakeNearbyConnectionManagerFactory>();
NearbyConnectionManagerImpl::Factory::SetFactoryForTesting(
fake_nearby_connection_manager_factory_.get());
fake_pending_connection_manager_factory_ =
std::make_unique<FakePendingConnectionManagerFactory>(
fake_ble_connection_manager_factory_.get());
fake_ble_connection_manager_factory_.get(),
fake_nearby_connection_manager_factory_.get());
PendingConnectionManagerImpl::Factory::SetFactoryForTesting(
fake_pending_connection_manager_factory_.get());
......@@ -481,6 +519,7 @@ class SecureChannelServiceTest : public testing::Test {
BleSynchronizer::Factory::SetFactoryForTesting(nullptr);
BleScannerImpl::Factory::SetFactoryForTesting(nullptr);
BleConnectionManagerImpl::Factory::SetFactoryForTesting(nullptr);
NearbyConnectionManagerImpl::Factory::SetFactoryForTesting(nullptr);
PendingConnectionManagerImpl::Factory::SetFactoryForTesting(nullptr);
ActiveConnectionManagerImpl::Factory::SetFactoryForTesting(nullptr);
SecureChannelInitializer::Factory::SetFactoryForTesting(nullptr);
......@@ -957,6 +996,8 @@ class SecureChannelServiceTest : public testing::Test {
std::unique_ptr<FakeBleScannerFactory> fake_ble_scanner_factory_;
std::unique_ptr<FakeBleConnectionManagerFactory>
fake_ble_connection_manager_factory_;
std::unique_ptr<FakeNearbyConnectionManagerFactory>
fake_nearby_connection_manager_factory_;
std::unique_ptr<FakePendingConnectionManagerFactory>
fake_pending_connection_manager_factory_;
std::unique_ptr<FakeActiveConnectionManagerFactory>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment