Skip to content

GitLab

T
tangled
Commit 25034fc9 authored by Findit's avatar Findit
Browse files
Options

Revert "[CrOS MultiDevice] Implement PendingConnectionManagerImpl." 

This reverts commit 8828e090.

Reason for revert:

Findit (https://goo.gl/kROfz5) identified CL at revision 568352 as the
culprit for failures in the build cycles as shown on:
https://findit-for-me.appspot.com/waterfall/culprit?key=ag9zfmZpbmRpdC1mb3ItbWVyRAsSDVdmU3VzcGVjdGVkQ0wiMWNocm9taXVtLzg4MjhlMDkwM2U4Y2QxNzIyZDE0ZjI3Zjg3YjgxYTllZWQxOGQ1NWMM

Sample Failed Build: https://ci.chromium.org/buildbot/chromium.memory/Linux%20ChromiumOS%20MSan%20Tests/7673

Sample Failed Step: chromeos_unittests

Original change's description:
> [CrOS MultiDevice] Implement PendingConnectionManagerImpl.
> 
> This class creates one ConnectionAttempt per ConnectionAttemptDetails
> requested; if more than one request shares the same
> ConnectionAttemptDetails, a single ConnectionAttempt attempts a
> connection for all associated requests.
> 
> If a ConnectionAttempt successfully creates a channel, this class
> extracts client data from all requests to the same remote device and
> alerts its delegate, deleting all associated ConnectionAttempts when it
> is finished.
> 
> Bug: 824568, 752273
> Change-Id: If9790549157919209e3e96f4a0b11d04fda2870c
> Reviewed-on: https://chromium-review.googlesource.com/1103669
> Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
> Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#568352}

Change-Id: Idd35a8b968324aafbf283868ff79fa49d9f879e5
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 824568, 752273
Reviewed-on: https://chromium-review.googlesource.com/1105897
Cr-Commit-Position: refs/heads/master@{#568396}
parent ce24c5ff
Hide whitespace changes
Inline Side-by-side
Showing with 15 additions and 1070 deletions
chromeos/services/secure_channel/pending_connection_manager_impl.cc
View file @ 25034fc9
...@@ -4,15 +4,8 @@ ...@@ -4,15 +4,8 @@
#include "chromeos/services/secure_channel/pending_connection_manager_impl.h" #include "chromeos/services/secure_channel/pending_connection_manager_impl.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h" #include "base/memory/ptr_util.h"
#include "base/no_destructor.h" #include "base/no_destructor.h"
#include "base/stl_util.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/pending_ble_initiator_connection_request.h"
#include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
#include "chromeos/services/secure_channel/public/cpp/shared/authenticated_channel.h"
namespace chromeos { namespace chromeos {
...@@ -41,18 +34,12 @@ void PendingConnectionManagerImpl::Factory::SetFactoryForTesting( ...@@ -41,18 +34,12 @@ void PendingConnectionManagerImpl::Factory::SetFactoryForTesting(
PendingConnectionManagerImpl::Factory::~Factory() = default; PendingConnectionManagerImpl::Factory::~Factory() = default;
std::unique_ptr<PendingConnectionManager> std::unique_ptr<PendingConnectionManager>
PendingConnectionManagerImpl::Factory::BuildInstance( PendingConnectionManagerImpl::Factory::BuildInstance(Delegate* delegate) {
Delegate* delegate, return base::WrapUnique(new PendingConnectionManagerImpl(delegate));
BleConnectionManager* ble_connection_manager) {
return base::WrapUnique(
new PendingConnectionManagerImpl(delegate, ble_connection_manager));
} }
PendingConnectionManagerImpl::PendingConnectionManagerImpl( PendingConnectionManagerImpl::PendingConnectionManagerImpl(Delegate* delegate)
Delegate* delegate, : PendingConnectionManager(delegate) {}
BleConnectionManager* ble_connection_manager)
: PendingConnectionManager(delegate),
ble_connection_manager_(ble_connection_manager) {}
PendingConnectionManagerImpl::~PendingConnectionManagerImpl() = default; PendingConnectionManagerImpl::~PendingConnectionManagerImpl() = default;
...@@ -60,214 +47,7 @@ void PendingConnectionManagerImpl::HandleConnectionRequest( ...@@ -60,214 +47,7 @@ void PendingConnectionManagerImpl::HandleConnectionRequest(
const ConnectionAttemptDetails& connection_attempt_details, const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters, std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority) { ConnectionPriority connection_priority) {
DCHECK_EQ(ConnectionMedium::kBluetoothLowEnergy, NOTIMPLEMENTED();
connection_attempt_details.connection_medium());
// If the client has canceled the request, it does not need to be processed.
if (!client_connection_parameters->IsClientWaitingForResponse()) {
PA_LOG(INFO) << "PendingConnectionManagerImpl::HandleConnectionRequest(): "
<< "Request was canceled by the client before being passed to "
<< "PendingConnectionManager; ignoring. Details: "
<< connection_attempt_details
<< ", Parameters: " << *client_connection_parameters
<< ", Priority: " << connection_priority;
return;
}
// Insert the entry into the ConnectionDetails to ConnectionAttemptDetails
// map.
ConnectionDetails connection_details =
connection_attempt_details.GetAssociatedConnectionDetails();
details_to_attempt_details_map_[connection_details].insert(
connection_attempt_details);
// Process the role-specific details.
switch (connection_attempt_details.connection_role()) {
case ConnectionRole::kInitiatorRole:
HandleBleInitiatorRequest(connection_attempt_details,
std::move(client_connection_parameters),
connection_priority);
break;
case ConnectionRole::kListenerRole:
HandleBleListenerRequest(connection_attempt_details,
std::move(client_connection_parameters),
connection_priority);
break;
}
}
void PendingConnectionManagerImpl::OnConnectionAttemptSucceeded(
const ConnectionDetails& connection_details,
std::unique_ptr<AuthenticatedChannel> authenticated_channel) {
if (!base::ContainsKey(details_to_attempt_details_map_, connection_details)) {
PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
<< "OnConnectionAttemptSucceeded(): Attempt succeeded, but "
<< "there was no corresponding map entry. "
<< "Details: " << connection_details;
NOTREACHED();
}
std::vector<std::unique_ptr<ClientConnectionParameters>> all_clients;
// Make a copy of the ConnectionAttemptDetails to process to prevent modifying
// the set during iteration.
base::flat_set<ConnectionAttemptDetails> to_process =
details_to_attempt_details_map_[connection_details];
// For each associated ConnectionAttemptDetails, extract clients from the
// 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;
}
// Move elements in |clients_in_list| to |all_clients|.
all_clients.insert(all_clients.end(),
std::make_move_iterator(clients_in_loop.begin()),
std::make_move_iterator(clients_in_loop.end()));
RemoveMapEntriesForFinishedConnectionAttempt(connection_attempt_details);
}
NotifyOnConnection(std::move(authenticated_channel), std::move(all_clients),
connection_details);
}
void PendingConnectionManagerImpl::OnConnectionAttemptFinishedWithoutConnection(
const ConnectionAttemptDetails& connection_attempt_details) {
RemoveMapEntriesForFinishedConnectionAttempt(connection_attempt_details);
}
void PendingConnectionManagerImpl::HandleBleInitiatorRequest(
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::ContainsKey(id_pair_to_ble_initiator_connection_attempts_,
connection_attempt_details.device_id_pair())) {
id_pair_to_ble_initiator_connection_attempts_[connection_attempt_details
.device_id_pair()] =
BleInitiatorConnectionAttempt::Factory::Get()->BuildInstance(
ble_connection_manager_, this /* delegate */,
connection_attempt_details);
}
auto& connection_attempt =
id_pair_to_ble_initiator_connection_attempts_[connection_attempt_details
.device_id_pair()];
bool success = connection_attempt->AddPendingConnectionRequest(
PendingBleInitiatorConnectionRequest::Factory::Get()->BuildInstance(
std::move(client_connection_parameters), connection_priority,
connection_attempt.get() /* delegate */));
if (!success) {
PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
<< "HandleBleInitiatorRequest(): Not able to handle request. "
<< "Details: " << connection_attempt_details
<< ", Client parameters: " << *client_connection_parameters;
NOTREACHED();
}
}
void PendingConnectionManagerImpl::HandleBleListenerRequest(
const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority) {
// If no ConnectionAttempt exists to this device in the listener role, create
// one.
if (!base::ContainsKey(id_pair_to_ble_listener_connection_attempts_,
connection_attempt_details.device_id_pair())) {
id_pair_to_ble_listener_connection_attempts_[connection_attempt_details
.device_id_pair()] =
BleListenerConnectionAttempt::Factory::Get()->BuildInstance(
ble_connection_manager_, this /* delegate */,
connection_attempt_details);
}
auto& connection_attempt =
id_pair_to_ble_listener_connection_attempts_[connection_attempt_details
.device_id_pair()];
bool success = connection_attempt->AddPendingConnectionRequest(
PendingBleListenerConnectionRequest::Factory::Get()->BuildInstance(
std::move(client_connection_parameters), connection_priority,
connection_attempt.get() /* delegate */));
if (!success) {
PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
<< "HandleBleListenerRequest(): Not able to handle request. "
<< "Details: " << connection_attempt_details
<< ", Client parameters: " << *client_connection_parameters;
NOTREACHED();
}
}
void PendingConnectionManagerImpl::RemoveMapEntriesForFinishedConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
switch (connection_attempt_details.connection_role()) {
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) << "PendingConnectionManagerImpl::"
<< "RemoveMapEntriesForFinishedConnectionAttempt(): "
<< "Tried to remove failed initiator ConnectionAttempt, "
<< "but it was not present in the map. Details: "
<< connection_attempt_details;
NOTREACHED();
}
break;
}
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) << "PendingConnectionManagerImpl::"
<< "RemoveMapEntriesForFinishedConnectionAttempt(): "
<< "Tried to remove failed listener ConnectionAttempt, "
<< "but it was not present in the map. Details: "
<< connection_attempt_details;
NOTREACHED();
}
break;
}
}
ConnectionDetails connection_details =
connection_attempt_details.GetAssociatedConnectionDetails();
size_t num_deleted =
details_to_attempt_details_map_[connection_details].erase(
connection_attempt_details);
if (num_deleted != 1u) {
PA_LOG(ERROR) << "PendingConnectionManagerImpl::"
<< "RemoveMapEntriesForFinishedConnectionAttempt(): "
<< "Tried to remove ConnectionAttemptDetails, but they were"
<< "not present in the map. Details: "
<< connection_attempt_details;
NOTREACHED();
}
// If |connection_attempt_details| was the last entry, remove the entire set.
if (details_to_attempt_details_map_[connection_details].empty())
details_to_attempt_details_map_.erase(connection_details);
} }
} // namespace secure_channel } // namespace secure_channel
......
chromeos/services/secure_channel/pending_connection_manager_impl.h
View file @ 25034fc9
...@@ -8,14 +8,8 @@ ...@@ -8,14 +8,8 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/macros.h" #include "base/macros.h"
#include "chromeos/services/secure_channel/ble_initiator_failure_type.h"
#include "chromeos/services/secure_channel/ble_listener_failure_type.h"
#include "chromeos/services/secure_channel/client_connection_parameters.h" #include "chromeos/services/secure_channel/client_connection_parameters.h"
#include "chromeos/services/secure_channel/connection_attempt.h"
#include "chromeos/services/secure_channel/connection_attempt_delegate.h"
#include "chromeos/services/secure_channel/connection_medium.h" #include "chromeos/services/secure_channel/connection_medium.h"
#include "chromeos/services/secure_channel/connection_role.h" #include "chromeos/services/secure_channel/connection_role.h"
#include "chromeos/services/secure_channel/device_id_pair.h" #include "chromeos/services/secure_channel/device_id_pair.h"
...@@ -26,18 +20,9 @@ namespace chromeos { ...@@ -26,18 +20,9 @@ namespace chromeos {
namespace secure_channel { namespace secure_channel {
class BleConnectionManager; // Concrete PendingConnectionManager implementation.
// TODO(khorimoto): Implement.
// Concrete PendingConnectionManager implementation. This class creates one class PendingConnectionManagerImpl : public PendingConnectionManager {
// ConnectionAttempt per ConnectionAttemptDetails requested; if more than one
// request shares the same ConnectionAttemptDetails, a single ConnectionAttempt
// attempts a connection for all associated requests.
//
// If a ConnectionAttempt successfully creates a channel, this class extracts
// client data from all requests to the same remote device and alerts its
// delegate, deleting all associated ConnectionAttempts when it is finished.
class PendingConnectionManagerImpl : public PendingConnectionManager,
public ConnectionAttemptDelegate {
public: public:
class Factory { class Factory {
public: public:
...@@ -45,8 +30,7 @@ class PendingConnectionManagerImpl : public PendingConnectionManager, ...@@ -45,8 +30,7 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
static void SetFactoryForTesting(Factory* test_factory); static void SetFactoryForTesting(Factory* test_factory);
virtual ~Factory(); virtual ~Factory();
virtual std::unique_ptr<PendingConnectionManager> BuildInstance( virtual std::unique_ptr<PendingConnectionManager> BuildInstance(
Delegate* delegate, Delegate* delegate);
BleConnectionManager* ble_connection_manager);
private: private:
static Factory* test_factory_; static Factory* test_factory_;
...@@ -55,47 +39,13 @@ class PendingConnectionManagerImpl : public PendingConnectionManager, ...@@ -55,47 +39,13 @@ class PendingConnectionManagerImpl : public PendingConnectionManager,
~PendingConnectionManagerImpl() override; ~PendingConnectionManagerImpl() override;
private: private:
PendingConnectionManagerImpl(Delegate* delegate, PendingConnectionManagerImpl(Delegate* delegate);
BleConnectionManager* ble_connection_manager);
// PendingConnectionManager:
void HandleConnectionRequest( void HandleConnectionRequest(
const ConnectionAttemptDetails& connection_attempt_details, const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters, std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority) override; ConnectionPriority connection_priority) override;
// ConnectionAttemptDelegate:
void OnConnectionAttemptSucceeded(
const ConnectionDetails& connection_details,
std::unique_ptr<AuthenticatedChannel> authenticated_channel) override;
void OnConnectionAttemptFinishedWithoutConnection(
const ConnectionAttemptDetails& connection_attempt_details) override;
void HandleBleInitiatorRequest(
const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority);
void HandleBleListenerRequest(
const ConnectionAttemptDetails& connection_attempt_details,
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority);
void RemoveMapEntriesForFinishedConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details);
base::flat_map<DeviceIdPair,
std::unique_ptr<ConnectionAttempt<BleInitiatorFailureType>>>
id_pair_to_ble_initiator_connection_attempts_;
base::flat_map<DeviceIdPair,
std::unique_ptr<ConnectionAttempt<BleListenerFailureType>>>
id_pair_to_ble_listener_connection_attempts_;
base::flat_map<ConnectionDetails, base::flat_set<ConnectionAttemptDetails>>
details_to_attempt_details_map_;
BleConnectionManager* ble_connection_manager_;
DISALLOW_COPY_AND_ASSIGN(PendingConnectionManagerImpl); DISALLOW_COPY_AND_ASSIGN(PendingConnectionManagerImpl);
}; };
......
chromeos/services/secure_channel/pending_connection_manager_impl_unittest.cc
View file @ 25034fc9
...@@ -5,306 +5,16 @@ ...@@ -5,306 +5,16 @@
#include "chromeos/services/secure_channel/pending_connection_manager_impl.h" #include "chromeos/services/secure_channel/pending_connection_manager_impl.h"
#include <memory> #include <memory>
#include <sstream>
#include "base/bind.h"
#include "base/containers/flat_map.h"
#include "base/macros.h" #include "base/macros.h"
#include "base/optional.h"
#include "base/test/scoped_task_environment.h" #include "base/test/scoped_task_environment.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/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_pending_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/pending_ble_initiator_connection_request.h"
#include "chromeos/services/secure_channel/pending_ble_listener_connection_request.h"
#include "chromeos/services/secure_channel/public/cpp/shared/fake_authenticated_channel.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
namespace chromeos { namespace chromeos {
namespace secure_channel { namespace secure_channel {
namespace {
const char kTestFeature[] = "testFeature";
class FakeBleInitiatorConnectionAttemptFactory
: public BleInitiatorConnectionAttempt::Factory {
public:
FakeBleInitiatorConnectionAttemptFactory(
FakeBleConnectionManager* expected_ble_connection_manager)
: expected_ble_connection_manager_(expected_ble_connection_manager) {}
~FakeBleInitiatorConnectionAttemptFactory() 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<BleInitiatorFailureType>*>&
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<BleInitiatorFailureType>* last_created_instance() {
return last_created_instance_;
}
private:
// BleInitiatorConnectionAttempt::Factory:
std::unique_ptr<ConnectionAttempt<BleInitiatorFailureType>> BuildInstance(
BleConnectionManager* ble_connection_manager,
ConnectionAttemptDelegate* delegate,
const ConnectionAttemptDetails& connection_attempt_details) override {
EXPECT_EQ(ConnectionRole::kInitiatorRole,
connection_attempt_details.connection_role());
EXPECT_EQ(expected_ble_connection_manager_, ble_connection_manager);
EXPECT_EQ(*expected_connection_attempt_details_,
connection_attempt_details);
auto instance =
std::make_unique<FakeConnectionAttempt<BleInitiatorFailureType>>(
delegate, connection_attempt_details,
base::BindOnce(
&FakeBleInitiatorConnectionAttemptFactory::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_;
}
FakeBleConnectionManager* expected_ble_connection_manager_;
base::Optional<ConnectionAttemptDetails> expected_connection_attempt_details_;
base::flat_map<ConnectionAttemptDetails,
FakeConnectionAttempt<BleInitiatorFailureType>*>
details_to_active_attempt_map_;
size_t num_instances_created_ = 0u;
size_t num_instances_deleted_ = 0u;
FakeConnectionAttempt<BleInitiatorFailureType>* last_created_instance_ =
nullptr;
DISALLOW_COPY_AND_ASSIGN(FakeBleInitiatorConnectionAttemptFactory);
};
class FakeBleListenerConnectionAttemptFactory
: public BleListenerConnectionAttempt::Factory {
public:
FakeBleListenerConnectionAttemptFactory(
FakeBleConnectionManager* expected_ble_connection_manager)
: expected_ble_connection_manager_(expected_ble_connection_manager) {}
~FakeBleListenerConnectionAttemptFactory() 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<BleListenerFailureType>*>&
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<BleListenerFailureType>* last_created_instance() {
return last_created_instance_;
}
private:
// BleListenerConnectionAttempt::Factory:
std::unique_ptr<ConnectionAttempt<BleListenerFailureType>> BuildInstance(
BleConnectionManager* ble_connection_manager,
ConnectionAttemptDelegate* delegate,
const ConnectionAttemptDetails& connection_attempt_details) override {
EXPECT_EQ(ConnectionRole::kListenerRole,
connection_attempt_details.connection_role());
EXPECT_EQ(expected_ble_connection_manager_, ble_connection_manager);
EXPECT_EQ(*expected_connection_attempt_details_,
connection_attempt_details);
auto instance =
std::make_unique<FakeConnectionAttempt<BleListenerFailureType>>(
delegate, connection_attempt_details,
base::BindOnce(
&FakeBleListenerConnectionAttemptFactory::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_;
}
FakeBleConnectionManager* expected_ble_connection_manager_;
base::Optional<ConnectionAttemptDetails> expected_connection_attempt_details_;
base::flat_map<ConnectionAttemptDetails,
FakeConnectionAttempt<BleListenerFailureType>*>
details_to_active_attempt_map_;
size_t num_instances_created_ = 0u;
size_t num_instances_deleted_ = 0u;
FakeConnectionAttempt<BleListenerFailureType>* last_created_instance_ =
nullptr;
DISALLOW_COPY_AND_ASSIGN(FakeBleListenerConnectionAttemptFactory);
};
class FakePendingBleInitiatorConnectionRequestFactory
: public PendingBleInitiatorConnectionRequest::Factory {
public:
FakePendingBleInitiatorConnectionRequestFactory() = default;
~FakePendingBleInitiatorConnectionRequestFactory() 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<BleInitiatorFailureType>*
last_created_instance() {
return last_created_instance_;
}
private:
// PendingBleInitiatorConnectionRequest::Factory:
std::unique_ptr<PendingConnectionRequest<BleInitiatorFailureType>>
BuildInstance(
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority,
PendingConnectionRequestDelegate* delegate) override {
EXPECT_EQ(expected_client_connection_parameters_,
client_connection_parameters.get());
EXPECT_EQ(*expected_connection_priority_, connection_priority);
auto instance =
std::make_unique<FakePendingConnectionRequest<BleInitiatorFailureType>>(
delegate, connection_priority);
last_created_instance_ = instance.get();
return instance;
}
ClientConnectionParameters* expected_client_connection_parameters_ = nullptr;
base::Optional<ConnectionPriority> expected_connection_priority_;
FakePendingConnectionRequest<BleInitiatorFailureType>*
last_created_instance_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(FakePendingBleInitiatorConnectionRequestFactory);
};
class FakePendingBleListenerConnectionRequestFactory
: public PendingBleListenerConnectionRequest::Factory {
public:
FakePendingBleListenerConnectionRequestFactory() = default;
~FakePendingBleListenerConnectionRequestFactory() 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<BleListenerFailureType>*
last_created_instance() {
return last_created_instance_;
}
private:
// PendingBleListenerConnectionRequest::Factory:
std::unique_ptr<PendingConnectionRequest<BleListenerFailureType>>
BuildInstance(
std::unique_ptr<ClientConnectionParameters> client_connection_parameters,
ConnectionPriority connection_priority,
PendingConnectionRequestDelegate* delegate) override {
EXPECT_EQ(expected_client_connection_parameters_,
client_connection_parameters.get());
EXPECT_EQ(*expected_connection_priority_, connection_priority);
auto instance =
std::make_unique<FakePendingConnectionRequest<BleListenerFailureType>>(
delegate, connection_priority);
last_created_instance_ = instance.get();
return instance;
}
ClientConnectionParameters* expected_client_connection_parameters_ = nullptr;
base::Optional<ConnectionPriority> expected_connection_priority_;
FakePendingConnectionRequest<BleListenerFailureType>* last_created_instance_ =
nullptr;
DISALLOW_COPY_AND_ASSIGN(FakePendingBleListenerConnectionRequestFactory);
};
std::vector<std::unique_ptr<ClientConnectionParameters>>
GenerateFakeClientParameters(size_t num_to_generate) {
std::vector<std::unique_ptr<ClientConnectionParameters>> client_parameters;
for (size_t i = 0; i < num_to_generate; ++i) {
// Generate a unique feature name.
std::stringstream ss;
ss << kTestFeature << "_" << i;
client_parameters.push_back(
std::make_unique<FakeClientConnectionParameters>(ss.str()));
}
return client_parameters;
}
std::vector<ClientConnectionParameters*> ClientParamsListToRawPtrs(
const std::vector<std::unique_ptr<ClientConnectionParameters>>&
unique_ptr_list) {
std::vector<ClientConnectionParameters*> raw_ptr_list;
std::transform(unique_ptr_list.begin(), unique_ptr_list.end(),
std::back_inserter(raw_ptr_list),
[](const auto& unique_ptr) { return unique_ptr.get(); });
return raw_ptr_list;
}
} // namespace
class SecureChannelPendingConnectionManagerImplTest : public testing::Test { class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
protected: protected:
SecureChannelPendingConnectionManagerImplTest() = default; SecureChannelPendingConnectionManagerImplTest() = default;
...@@ -313,513 +23,23 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test { ...@@ -313,513 +23,23 @@ class SecureChannelPendingConnectionManagerImplTest : public testing::Test {
// testing::Test: // testing::Test:
void SetUp() override { void SetUp() override {
fake_delegate_ = std::make_unique<FakePendingConnectionManagerDelegate>(); fake_delegate_ = std::make_unique<FakePendingConnectionManagerDelegate>();
fake_ble_connection_manager_ = std::make_unique<FakeBleConnectionManager>();
fake_ble_initiator_connection_attempt_factory_ =
std::make_unique<FakeBleInitiatorConnectionAttemptFactory>(
fake_ble_connection_manager_.get());
BleInitiatorConnectionAttempt::Factory::SetFactoryForTesting(
fake_ble_initiator_connection_attempt_factory_.get());
fake_ble_listener_connection_attempt_factory_ =
std::make_unique<FakeBleListenerConnectionAttemptFactory>(
fake_ble_connection_manager_.get());
BleListenerConnectionAttempt::Factory::SetFactoryForTesting(
fake_ble_listener_connection_attempt_factory_.get());
fake_pending_ble_initiator_connection_request_factory_ =
std::make_unique<FakePendingBleInitiatorConnectionRequestFactory>();
PendingBleInitiatorConnectionRequest::Factory::SetFactoryForTesting(
fake_pending_ble_initiator_connection_request_factory_.get());
fake_pending_ble_listener_connection_request_factory_ =
std::make_unique<FakePendingBleListenerConnectionRequestFactory>();
PendingBleListenerConnectionRequest::Factory::SetFactoryForTesting(
fake_pending_ble_listener_connection_request_factory_.get());
manager_ = PendingConnectionManagerImpl::Factory::Get()->BuildInstance( manager_ = PendingConnectionManagerImpl::Factory::Get()->BuildInstance(
fake_delegate_.get(), fake_ble_connection_manager_.get()); fake_delegate_.get());
}
void TearDown() override {
BleInitiatorConnectionAttempt::Factory::SetFactoryForTesting(nullptr);
BleListenerConnectionAttempt::Factory::SetFactoryForTesting(nullptr);
PendingBleInitiatorConnectionRequest::Factory::SetFactoryForTesting(
nullptr);
PendingBleListenerConnectionRequest::Factory::SetFactoryForTesting(nullptr);
}
void HandleCanceledRequestAndVerifyNoInstancesCreated(
const ConnectionAttemptDetails& connection_attempt_details,
ConnectionPriority connection_priority) {
FakeConnectionAttempt<
BleInitiatorFailureType>* last_ble_initiator_attempt_before_call =
fake_ble_initiator_connection_attempt_factory_->last_created_instance();
FakeConnectionAttempt<
BleListenerFailureType>* last_ble_listener_attempt_before_call =
fake_ble_listener_connection_attempt_factory_->last_created_instance();
FakePendingConnectionRequest<BleInitiatorFailureType>*
last_ble_initiator_request_before_call =
fake_pending_ble_initiator_connection_request_factory_
->last_created_instance();
FakePendingConnectionRequest<BleListenerFailureType>*
last_ble_listener_request_before_call =
fake_pending_ble_listener_connection_request_factory_
->last_created_instance();
HandleConnectionRequest(connection_attempt_details, connection_priority,
true /* cancel_request_before_adding */);
// Since the request was canceled before it was added, no new attempts or
// operations should have been created.
EXPECT_EQ(last_ble_initiator_attempt_before_call,
fake_ble_initiator_connection_attempt_factory_
->last_created_instance());
EXPECT_EQ(
last_ble_listener_attempt_before_call,
fake_ble_listener_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());
}
void HandleRequestAndVerifyHandledByConnectionAttempt(
const ConnectionAttemptDetails& connection_attempt_details,
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::ContainsKey(active_attempt->id_to_request_map(),
token_for_last_init_request));
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::ContainsKey(active_attempt->id_to_request_map(),
token_for_last_listen_request));
break;
}
}
}
void FinishInitiatorAttemptWithoutConnection(
FakeConnectionAttempt<BleInitiatorFailureType>* attempt) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveInitiatorAttempt(details_for_attempt), attempt);
attempt->OnConnectionAttemptFinishedWithoutConnection();
EXPECT_FALSE(GetActiveInitiatorAttempt(details_for_attempt));
}
void FinishListenerAttemptWithoutConnection(
FakeConnectionAttempt<BleListenerFailureType>* attempt) {
ConnectionAttemptDetails details_for_attempt =
attempt->connection_attempt_details();
EXPECT_EQ(GetActiveListenerAttempt(details_for_attempt), attempt);
attempt->OnConnectionAttemptFinishedWithoutConnection();
EXPECT_FALSE(GetActiveListenerAttempt(details_for_attempt));
}
void FinishInitiatorAttemptWithConnection(
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);
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(GetActiveInitiatorAttempt(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 FinishListenerAttemptWithConnection(
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);
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(GetActiveListenerAttempt(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()));
}
FakeConnectionAttempt<BleInitiatorFailureType>* GetActiveInitiatorAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
return fake_ble_initiator_connection_attempt_factory_
->details_to_active_attempt_map()[connection_attempt_details];
}
FakeConnectionAttempt<BleListenerFailureType>* GetActiveListenerAttempt(
const ConnectionAttemptDetails& connection_attempt_details) {
return fake_ble_listener_connection_attempt_factory_
->details_to_active_attempt_map()[connection_attempt_details];
}
size_t GetNumInitiatorAttemptsCreated() {
return fake_ble_initiator_connection_attempt_factory_
->num_instances_created();
}
size_t GetNumListenerAttemptsCreated() {
return fake_ble_listener_connection_attempt_factory_
->num_instances_created();
}
size_t GetNumInitiatorAttemptsDeleted() {
return fake_ble_initiator_connection_attempt_factory_
->num_instances_deleted();
}
size_t GetNumListenerAttemptsDeleted() {
return fake_ble_listener_connection_attempt_factory_
->num_instances_deleted();
} }
private: private:
void HandleConnectionRequest(
const ConnectionAttemptDetails& connection_attempt_details,
ConnectionPriority connection_priority,
bool cancel_request_before_adding) {
auto fake_client_connection_parameters =
std::make_unique<FakeClientConnectionParameters>(kTestFeature);
FakeClientConnectionParameters* fake_client_connection_parameters_raw =
fake_client_connection_parameters.get();
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);
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;
}
}
manager_->HandleConnectionRequest(
connection_attempt_details,
std::move(fake_client_connection_parameters), connection_priority);
}
const base::test::ScopedTaskEnvironment scoped_task_environment_; const base::test::ScopedTaskEnvironment scoped_task_environment_;
std::unique_ptr<FakePendingConnectionManagerDelegate> fake_delegate_; std::unique_ptr<FakePendingConnectionManagerDelegate> fake_delegate_;
std::unique_ptr<FakeBleConnectionManager> fake_ble_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<FakePendingBleInitiatorConnectionRequestFactory>
fake_pending_ble_initiator_connection_request_factory_;
std::unique_ptr<FakePendingBleListenerConnectionRequestFactory>
fake_pending_ble_listener_connection_request_factory_;
std::unique_ptr<PendingConnectionManager> manager_; std::unique_ptr<PendingConnectionManager> manager_;
DISALLOW_COPY_AND_ASSIGN(SecureChannelPendingConnectionManagerImplTest); DISALLOW_COPY_AND_ASSIGN(SecureChannelPendingConnectionManagerImplTest);
}; };
TEST_F(SecureChannelPendingConnectionManagerImplTest, TEST_F(SecureChannelPendingConnectionManagerImplTest, Test) {
CanceledRequestNotProcessed) { // TODO(khorimoto): Add tests once implementation is complete.
// Initiator.
HandleCanceledRequestAndVerifyNoInstancesCreated(
ConnectionAttemptDetails("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole),
ConnectionPriority::kLow);
// Listener.
HandleCanceledRequestAndVerifyNoInstancesCreated(
ConnectionAttemptDetails("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole),
ConnectionPriority::kLow);
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptFinishesWithoutConnection_Initiator) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishInitiatorAttemptWithoutConnection(GetActiveInitiatorAttempt(details));
EXPECT_EQ(1u, GetNumInitiatorAttemptsCreated());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishInitiatorAttemptWithoutConnection(GetActiveInitiatorAttempt(details));
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptFinishesWithoutConnection_Listener) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishListenerAttemptWithoutConnection(GetActiveListenerAttempt(details));
EXPECT_EQ(1u, GetNumListenerAttemptsCreated());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishListenerAttemptWithoutConnection(GetActiveListenerAttempt(details));
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptSucceeds_Initiator) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(1u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumInitiatorAttemptsDeleted());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details),
2u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
AttemptSucceeds_Listener) {
ConnectionAttemptDetails details("remoteDeviceId", "localDeviceId",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
// One request by itself.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kLow);
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(1u, GetNumListenerAttemptsCreated());
EXPECT_EQ(1u, GetNumListenerAttemptsDeleted());
// Two requests at the same time.
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details,
ConnectionPriority::kHigh);
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details),
2u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumListenerAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
SimultaneousRequestsToSameRemoteDevice) {
// Four ConnectionDetails objects, which all share the same remote device.
ConnectionAttemptDetails local_device_1_initiator_details(
"remoteDeviceId", "localDeviceId1", ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
ConnectionAttemptDetails local_device_1_listener_details(
"remoteDeviceId", "localDeviceId1", ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
ConnectionAttemptDetails local_device_2_initiator_details(
"remoteDeviceId", "localDeviceId2", ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
ConnectionAttemptDetails local_device_2_listener_details(
"remoteDeviceId", "localDeviceId2", ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
// Register all of them.
HandleRequestAndVerifyHandledByConnectionAttempt(
local_device_1_initiator_details, ConnectionPriority::kLow);
HandleRequestAndVerifyHandledByConnectionAttempt(
local_device_1_listener_details, ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(
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());
// 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),
4u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
}
TEST_F(SecureChannelPendingConnectionManagerImplTest,
SimultaneousRequestsToDifferentDevices) {
// Four ConnectionDetails objects, which all have different remote devices.
ConnectionAttemptDetails details_1("remoteDeviceId1", "localDeviceId1",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
ConnectionAttemptDetails details_2("remoteDeviceId2", "localDeviceId2",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
ConnectionAttemptDetails details_3("remoteDeviceId3", "localDeviceId3",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kInitiatorRole);
ConnectionAttemptDetails details_4("remoteDeviceId4", "localDeviceId4",
ConnectionMedium::kBluetoothLowEnergy,
ConnectionRole::kListenerRole);
// Register all of them.
HandleRequestAndVerifyHandledByConnectionAttempt(details_1,
ConnectionPriority::kLow);
HandleRequestAndVerifyHandledByConnectionAttempt(details_2,
ConnectionPriority::kMedium);
HandleRequestAndVerifyHandledByConnectionAttempt(details_3,
ConnectionPriority::kHigh);
HandleRequestAndVerifyHandledByConnectionAttempt(details_4,
ConnectionPriority::kLow);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(0u, GetNumInitiatorAttemptsDeleted());
// Find a connection for |details_1|; only one ConnectionAttempt should have
// been deleted.
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details_1),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(0u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumInitiatorAttemptsDeleted());
// Find a connection for |details_2|.
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details_2),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(1u, GetNumInitiatorAttemptsDeleted());
// |details_3|.
FinishInitiatorAttemptWithConnection(
GetActiveInitiatorAttempt(details_3),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(1u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
// |details_4|.
FinishListenerAttemptWithConnection(
GetActiveListenerAttempt(details_4),
1u /* num_extracted_clients_to_generate */);
EXPECT_EQ(2u, GetNumListenerAttemptsCreated());
EXPECT_EQ(2u, GetNumInitiatorAttemptsCreated());
EXPECT_EQ(2u, GetNumListenerAttemptsDeleted());
EXPECT_EQ(2u, GetNumInitiatorAttemptsDeleted());
} }
} // namespace secure_channel } // namespace secure_channel
......
chromeos/services/secure_channel/secure_channel_impl.cc
View file @ 25034fc9
...@@ -70,9 +70,7 @@ SecureChannelImpl::SecureChannelImpl() ...@@ -70,9 +70,7 @@ SecureChannelImpl::SecureChannelImpl()
this /* delegate */)), this /* delegate */)),
pending_connection_manager_( pending_connection_manager_(
PendingConnectionManagerImpl::Factory::Get()->BuildInstance( PendingConnectionManagerImpl::Factory::Get()->BuildInstance(
this /* delegate */, this /* delegate */)),
// TODO(khorimoto): Pass the actual BleConnectionManager here.
nullptr /* ble_connection_manager */)),
remote_device_cache_( remote_device_cache_(
cryptauth::RemoteDeviceCache::Factory::Get()->BuildInstance()) {} cryptauth::RemoteDeviceCache::Factory::Get()->BuildInstance()) {}
......
chromeos/services/secure_channel/secure_channel_service_unittest.cc
View file @ 25034fc9
...@@ -68,10 +68,7 @@ class FakePendingConnectionManagerFactory ...@@ -68,10 +68,7 @@ class FakePendingConnectionManagerFactory
private: private:
std::unique_ptr<PendingConnectionManager> BuildInstance( std::unique_ptr<PendingConnectionManager> BuildInstance(
PendingConnectionManager::Delegate* delegate, PendingConnectionManager::Delegate* delegate) override {
BleConnectionManager* ble_connection_manager) override {
// TODO(khorimoto): Verify that |ble_connection_manager| is correctly passed
// to this factory.
EXPECT_FALSE(instance_); EXPECT_FALSE(instance_);
auto instance = std::make_unique<FakePendingConnectionManager>(delegate); auto instance = std::make_unique<FakePendingConnectionManager>(delegate);
instance_ = instance.get(); instance_ = instance.get();
......
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