0

[CrOS PhoneHub] Rename BleServiceDataHelper to BluetoothHelper

This is in preparation for giving this class additional functionality
unrelated to BLE.

Bug: 1106937
Change-Id: Ib060a446580310df97651d0145e6f7e0d0784961
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2412835
Auto-Submit: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: James Vecore <vecore@google.com>
Reviewed-by: James Vecore <vecore@google.com>
Cr-Commit-Position: refs/heads/master@{#807342}
This commit is contained in:
Kyle Horimoto
2020-09-16 05:21:25 +00:00
committed by Commit Bot
parent 6ae6a462af
commit 4f9ea463c9
21 changed files with 209 additions and 233 deletions

@ -47,10 +47,6 @@ static_library("secure_channel") {
"ble_scanner.h",
"ble_scanner_impl.cc",
"ble_scanner_impl.h",
"ble_service_data_helper.cc",
"ble_service_data_helper.h",
"ble_service_data_helper_impl.cc",
"ble_service_data_helper_impl.h",
"ble_synchronizer.cc",
"ble_synchronizer.h",
"ble_synchronizer_base.cc",
@ -62,6 +58,10 @@ static_library("secure_channel") {
"ble_weave_packet_generator.h",
"ble_weave_packet_receiver.cc",
"ble_weave_packet_receiver.h",
"bluetooth_helper.cc",
"bluetooth_helper.h",
"bluetooth_helper_impl.cc",
"bluetooth_helper_impl.h",
"channel_impl.cc",
"channel_impl.h",
"client_connection_parameters.cc",
@ -195,10 +195,10 @@ static_library("test_support") {
"fake_ble_connection_manager.h",
"fake_ble_scanner.cc",
"fake_ble_scanner.h",
"fake_ble_service_data_helper.cc",
"fake_ble_service_data_helper.h",
"fake_ble_synchronizer.cc",
"fake_ble_synchronizer.h",
"fake_bluetooth_helper.cc",
"fake_bluetooth_helper.h",
"fake_channel.cc",
"fake_channel.h",
"fake_client_connection_parameters.cc",
@ -270,11 +270,11 @@ source_set("unit_tests") {
"ble_initiator_operation_unittest.cc",
"ble_listener_operation_unittest.cc",
"ble_scanner_impl_unittest.cc",
"ble_service_data_helper_impl_unittest.cc",
"ble_synchronizer_unittest.cc",
"ble_weave_client_connection_unittest.cc",
"ble_weave_packet_generator_unittest.cc",
"ble_weave_packet_receiver_unittest.cc",
"bluetooth_helper_impl_unittest.cc",
"client_connection_parameters_impl_unittest.cc",
"connect_to_device_operation_base_unittest.cc",
"connection_attempt_base_unittest.cc",

@ -16,12 +16,6 @@ namespace multidevice {
class RemoteDeviceRef;
} // namespace multidevice
namespace tether {
class BleAdvertiserImplTest;
class BleServiceDataHelperImplTest;
class AdHocBleAdvertiserImplTest;
} // namespace tether
namespace secure_channel {
// Generates advertisements for the ProximityAuth BLE advertisement scheme.
@ -45,10 +39,7 @@ class BleAdvertisementGenerator {
private:
friend class SecureChannelBleAdvertisementGeneratorTest;
friend class SecureChannelBleServiceDataHelperImplTest;
friend class tether::BleAdvertiserImplTest;
friend class tether::BleServiceDataHelperImplTest;
friend class tether::AdHocBleAdvertiserImplTest;
friend class SecureChannelBluetoothHelperImplTest;
static BleAdvertisementGenerator* instance_;

@ -11,7 +11,7 @@
#include "base/threading/sequenced_task_runner_handle.h"
#include "base/timer/timer.h"
#include "chromeos/components/multidevice/logging/logging.h"
#include "chromeos/services/secure_channel/ble_service_data_helper.h"
#include "chromeos/services/secure_channel/bluetooth_helper.h"
#include "chromeos/services/secure_channel/error_tolerant_ble_advertisement_impl.h"
#include "chromeos/services/secure_channel/shared_resource_scheduler.h"
#include "chromeos/services/secure_channel/timer_factory.h"
@ -37,19 +37,19 @@ BleAdvertiserImpl::Factory* BleAdvertiserImpl::Factory::test_factory_ = nullptr;
// static
std::unique_ptr<BleAdvertiser> BleAdvertiserImpl::Factory::Create(
Delegate* delegate,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
TimerFactory* timer_factory,
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner) {
if (test_factory_) {
return test_factory_->CreateInstance(delegate, ble_service_data_helper,
return test_factory_->CreateInstance(delegate, bluetooth_helper,
ble_synchronizer_base, timer_factory,
sequenced_task_runner);
}
return base::WrapUnique(new BleAdvertiserImpl(
delegate, ble_service_data_helper, ble_synchronizer_base, timer_factory,
sequenced_task_runner));
return base::WrapUnique(
new BleAdvertiserImpl(delegate, bluetooth_helper, ble_synchronizer_base,
timer_factory, sequenced_task_runner));
}
// static
@ -64,12 +64,12 @@ const int64_t BleAdvertiserImpl::kNumSecondsPerAdvertisementTimeslot = 10;
BleAdvertiserImpl::BleAdvertiserImpl(
Delegate* delegate,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
TimerFactory* timer_factory,
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner)
: BleAdvertiser(delegate),
ble_service_data_helper_(ble_service_data_helper),
bluetooth_helper_(bluetooth_helper),
ble_synchronizer_base_(ble_synchronizer_base),
timer_factory_(timer_factory),
sequenced_task_runner_(sequenced_task_runner),
@ -290,7 +290,7 @@ void BleAdvertiserImpl::AttemptToAddActiveAdvertisement(size_t index_to_add) {
const DeviceIdPair pair =
active_advertisement_requests_[index_to_add]->device_id_pair;
std::unique_ptr<DataWithTimestamp> service_data =
ble_service_data_helper_->GenerateForegroundAdvertisement(pair);
bluetooth_helper_->GenerateForegroundAdvertisement(pair);
// If an advertisement could not be created, the request is immediately
// removed. It's also tracked to prevent future operations from referencing

@ -28,7 +28,7 @@ namespace chromeos {
namespace secure_channel {
class BleServiceDataHelper;
class BluetoothHelper;
class BleSynchronizerBase;
class ErrorTolerantBleAdvertisement;
class SharedResourceScheduler;
@ -56,7 +56,7 @@ class BleAdvertiserImpl : public BleAdvertiser {
public:
static std::unique_ptr<BleAdvertiser> Create(
Delegate* delegate,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
TimerFactory* timer_factory,
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner =
@ -67,7 +67,7 @@ class BleAdvertiserImpl : public BleAdvertiser {
virtual ~Factory();
virtual std::unique_ptr<BleAdvertiser> CreateInstance(
Delegate* delegate,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
TimerFactory* timer_factory,
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner) = 0;
@ -98,7 +98,7 @@ class BleAdvertiserImpl : public BleAdvertiser {
BleAdvertiserImpl(
Delegate* delegate,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
TimerFactory* timer_factory,
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner);
@ -132,7 +132,7 @@ class BleAdvertiserImpl : public BleAdvertiser {
void AttemptToNotifyFailureToGenerateAdvertisement(
const DeviceIdPair& device_id_pair);
BleServiceDataHelper* ble_service_data_helper_;
BluetoothHelper* bluetooth_helper_;
BleSynchronizerBase* ble_synchronizer_base_;
TimerFactory* timer_factory_;

@ -14,8 +14,8 @@
#include "base/test/test_simple_task_runner.h"
#include "chromeos/services/secure_channel/error_tolerant_ble_advertisement_impl.h"
#include "chromeos/services/secure_channel/fake_ble_advertiser.h"
#include "chromeos/services/secure_channel/fake_ble_service_data_helper.h"
#include "chromeos/services/secure_channel/fake_ble_synchronizer.h"
#include "chromeos/services/secure_channel/fake_bluetooth_helper.h"
#include "chromeos/services/secure_channel/fake_error_tolerant_ble_advertisement.h"
#include "chromeos/services/secure_channel/fake_one_shot_timer.h"
#include "chromeos/services/secure_channel/fake_timer_factory.h"
@ -31,9 +31,9 @@ class FakeErrorTolerantBleAdvertisementFactory
: public ErrorTolerantBleAdvertisementImpl::Factory {
public:
FakeErrorTolerantBleAdvertisementFactory(
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base)
: ble_service_data_helper_(ble_service_data_helper),
: bluetooth_helper_(bluetooth_helper),
ble_synchronizer_base_(ble_synchronizer_base) {}
~FakeErrorTolerantBleAdvertisementFactory() override = default;
@ -54,9 +54,9 @@ class FakeErrorTolerantBleAdvertisementFactory
const DeviceIdPair& device_id_pair,
std::unique_ptr<DataWithTimestamp> advertisement_data,
BleSynchronizerBase* ble_synchronizer) override {
EXPECT_EQ(*ble_service_data_helper_->GenerateForegroundAdvertisement(
device_id_pair),
*advertisement_data);
EXPECT_EQ(
*bluetooth_helper_->GenerateForegroundAdvertisement(device_id_pair),
*advertisement_data);
EXPECT_EQ(ble_synchronizer_base_, ble_synchronizer);
++num_instances_created_;
@ -82,7 +82,7 @@ class FakeErrorTolerantBleAdvertisementFactory
EXPECT_EQ(1u, num_deleted);
}
BleServiceDataHelper* ble_service_data_helper_;
BluetoothHelper* bluetooth_helper_;
BleSynchronizerBase* ble_synchronizer_base_;
base::Optional<DeviceIdPair> last_created_device_id_pair_;
@ -106,21 +106,20 @@ class SecureChannelBleAdvertiserImplTest : public testing::Test {
// testing::Test:
void SetUp() override {
fake_delegate_ = std::make_unique<FakeBleAdvertiserDelegate>();
fake_ble_service_data_helper_ =
std::make_unique<FakeBleServiceDataHelper>();
fake_bluetooth_helper_ = std::make_unique<FakeBluetoothHelper>();
fake_ble_synchronizer_ = std::make_unique<FakeBleSynchronizer>();
fake_timer_factory_ = std::make_unique<FakeTimerFactory>();
fake_advertisement_factory_ =
std::make_unique<FakeErrorTolerantBleAdvertisementFactory>(
fake_ble_service_data_helper_.get(), fake_ble_synchronizer_.get());
fake_bluetooth_helper_.get(), fake_ble_synchronizer_.get());
ErrorTolerantBleAdvertisementImpl::Factory::SetFactoryForTesting(
fake_advertisement_factory_.get());
test_runner_ = base::MakeRefCounted<base::TestSimpleTaskRunner>();
advertiser_ = BleAdvertiserImpl::Factory::Create(
fake_delegate_.get(), fake_ble_service_data_helper_.get(),
fake_delegate_.get(), fake_bluetooth_helper_.get(),
fake_ble_synchronizer_.get(), fake_timer_factory_.get(), test_runner_);
}
@ -194,7 +193,7 @@ class SecureChannelBleAdvertiserImplTest : public testing::Test {
// Generate fake service data using the two device IDs.
std::stringstream ss;
ss << request.remote_device_id() << "+" << request.local_device_id();
fake_ble_service_data_helper_->SetAdvertisement(
fake_bluetooth_helper_->SetAdvertisement(
request,
DataWithTimestamp(ss.str() /* data */, kDefaultStartTimestamp,
kDefaultEndTimestamp));
@ -257,15 +256,15 @@ class SecureChannelBleAdvertiserImplTest : public testing::Test {
base::TestSimpleTaskRunner* test_runner() { return test_runner_.get(); }
BleAdvertiser* advertiser() { return advertiser_.get(); }
FakeBleServiceDataHelper* fake_ble_service_data_helper() {
return fake_ble_service_data_helper_.get();
FakeBluetoothHelper* fake_bluetooth_helper() {
return fake_bluetooth_helper_.get();
}
private:
base::test::TaskEnvironment task_environment_;
std::unique_ptr<FakeBleAdvertiserDelegate> fake_delegate_;
std::unique_ptr<FakeBleServiceDataHelper> fake_ble_service_data_helper_;
std::unique_ptr<FakeBluetoothHelper> fake_bluetooth_helper_;
std::unique_ptr<FakeBleSynchronizer> fake_ble_synchronizer_;
std::unique_ptr<FakeTimerFactory> fake_timer_factory_;

@ -57,19 +57,19 @@ BleConnectionManagerImpl::Factory*
// static
std::unique_ptr<BleConnectionManager> BleConnectionManagerImpl::Factory::Create(
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
BleScanner* ble_scanner,
TimerFactory* timer_factory,
base::Clock* clock) {
if (test_factory_) {
return test_factory_->CreateInstance(
bluetooth_adapter, ble_service_data_helper, ble_synchronizer,
ble_scanner, timer_factory, clock);
return test_factory_->CreateInstance(bluetooth_adapter, bluetooth_helper,
ble_synchronizer, ble_scanner,
timer_factory, clock);
}
return base::WrapUnique(new BleConnectionManagerImpl(
bluetooth_adapter, ble_service_data_helper, ble_synchronizer, ble_scanner,
bluetooth_adapter, bluetooth_helper, ble_synchronizer, ble_scanner,
timer_factory, clock));
}
@ -206,7 +206,7 @@ void BleConnectionManagerImpl::ConnectionAttemptTimestamps::
BleConnectionManagerImpl::BleConnectionManagerImpl(
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
BleScanner* ble_scanner,
TimerFactory* timer_factory,
@ -214,11 +214,10 @@ BleConnectionManagerImpl::BleConnectionManagerImpl(
: bluetooth_adapter_(bluetooth_adapter),
clock_(clock),
ble_scanner_(ble_scanner),
ble_advertiser_(
BleAdvertiserImpl::Factory::Create(this /* delegate */,
ble_service_data_helper,
ble_synchronizer,
timer_factory)),
ble_advertiser_(BleAdvertiserImpl::Factory::Create(this /* delegate */,
bluetooth_helper,
ble_synchronizer,
timer_factory)),
secure_channel_disconnector_(
SecureChannelDisconnectorImpl::Factory::Create()) {
ble_scanner_->AddObserver(this);

@ -29,7 +29,7 @@ namespace chromeos {
namespace secure_channel {
class BleServiceDataHelper;
class BluetoothHelper;
class BleSynchronizerBase;
class SecureChannelDisconnector;
class TimerFactory;
@ -48,7 +48,7 @@ class BleConnectionManagerImpl : public BleConnectionManager,
public:
static std::unique_ptr<BleConnectionManager> Create(
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
BleScanner* ble_scanner,
TimerFactory* timer_factory,
@ -59,7 +59,7 @@ class BleConnectionManagerImpl : public BleConnectionManager,
virtual ~Factory();
virtual std::unique_ptr<BleConnectionManager> CreateInstance(
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
BleScanner* ble_scanner,
TimerFactory* timer_factory,
@ -106,7 +106,7 @@ class BleConnectionManagerImpl : public BleConnectionManager,
BleConnectionManagerImpl(
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
BleScanner* ble_scanner,
TimerFactory* timer_factory,

@ -26,8 +26,8 @@
#include "chromeos/services/secure_channel/fake_authenticated_channel.h"
#include "chromeos/services/secure_channel/fake_ble_advertiser.h"
#include "chromeos/services/secure_channel/fake_ble_scanner.h"
#include "chromeos/services/secure_channel/fake_ble_service_data_helper.h"
#include "chromeos/services/secure_channel/fake_ble_synchronizer.h"
#include "chromeos/services/secure_channel/fake_bluetooth_helper.h"
#include "chromeos/services/secure_channel/fake_connection.h"
#include "chromeos/services/secure_channel/fake_secure_channel_connection.h"
#include "chromeos/services/secure_channel/fake_secure_channel_disconnector.h"
@ -56,12 +56,10 @@ constexpr base::TimeDelta kConnectionToAuthenticationTime =
class FakeBleAdvertiserFactory : public BleAdvertiserImpl::Factory {
public:
FakeBleAdvertiserFactory(
FakeBleServiceDataHelper* expected_fake_ble_service_data_helper,
FakeBleSynchronizer* expected_fake_ble_synchronizer,
FakeTimerFactory* expected_fake_timer_factory)
: expected_fake_ble_service_data_helper_(
expected_fake_ble_service_data_helper),
FakeBleAdvertiserFactory(FakeBluetoothHelper* expected_fake_bluetooth_helper,
FakeBleSynchronizer* expected_fake_ble_synchronizer,
FakeTimerFactory* expected_fake_timer_factory)
: expected_fake_bluetooth_helper_(expected_fake_bluetooth_helper),
expected_fake_ble_synchronizer_(expected_fake_ble_synchronizer),
expected_fake_timer_factory_(expected_fake_timer_factory) {}
@ -73,11 +71,11 @@ class FakeBleAdvertiserFactory : public BleAdvertiserImpl::Factory {
// BleAdvertiserImpl::Factory:
std::unique_ptr<BleAdvertiser> CreateInstance(
BleAdvertiser::Delegate* delegate,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
TimerFactory* timer_factory,
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner) override {
EXPECT_EQ(expected_fake_ble_service_data_helper_, ble_service_data_helper);
EXPECT_EQ(expected_fake_bluetooth_helper_, bluetooth_helper);
EXPECT_EQ(expected_fake_ble_synchronizer_, ble_synchronizer_base);
EXPECT_EQ(expected_fake_timer_factory_, timer_factory);
EXPECT_FALSE(instance_);
@ -89,7 +87,7 @@ class FakeBleAdvertiserFactory : public BleAdvertiserImpl::Factory {
FakeBleAdvertiser* instance_ = nullptr;
FakeBleServiceDataHelper* expected_fake_ble_service_data_helper_;
FakeBluetoothHelper* expected_fake_bluetooth_helper_;
FakeBleSynchronizer* expected_fake_ble_synchronizer_;
FakeTimerFactory* expected_fake_timer_factory_;
@ -259,8 +257,7 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
mock_adapter_ =
base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
fake_ble_service_data_helper_ =
std::make_unique<FakeBleServiceDataHelper>();
fake_bluetooth_helper_ = std::make_unique<FakeBluetoothHelper>();
fake_ble_synchronizer_ = std::make_unique<FakeBleSynchronizer>();
fake_ble_scanner_ = std::make_unique<FakeBleScanner>();
@ -270,7 +267,7 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
test_clock_->SetNow(base::Time::UnixEpoch());
fake_ble_advertiser_factory_ = std::make_unique<FakeBleAdvertiserFactory>(
fake_ble_service_data_helper_.get(), fake_ble_synchronizer_.get(),
fake_bluetooth_helper_.get(), fake_ble_synchronizer_.get(),
fake_timer_factory_.get());
BleAdvertiserImpl::Factory::SetFactoryForTesting(
fake_ble_advertiser_factory_.get());
@ -296,7 +293,7 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
fake_authenticated_channel_factory_.get());
manager_ = BleConnectionManagerImpl::Factory::Create(
mock_adapter_, fake_ble_service_data_helper_.get(),
mock_adapter_, fake_bluetooth_helper_.get(),
fake_ble_synchronizer_.get(), fake_ble_scanner_.get(),
fake_timer_factory_.get(), test_clock_.get());
}
@ -795,7 +792,7 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
fake_authenticated_channel_factory_;
scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
std::unique_ptr<FakeBleServiceDataHelper> fake_ble_service_data_helper_;
std::unique_ptr<FakeBluetoothHelper> fake_bluetooth_helper_;
std::unique_ptr<FakeBleSynchronizer> fake_ble_synchronizer_;
std::unique_ptr<FakeBleScanner> fake_ble_scanner_;
std::unique_ptr<FakeTimerFactory> fake_timer_factory_;

@ -25,7 +25,7 @@ namespace secure_channel {
namespace {
// TODO(hansberry): Share this constant with BleServiceDataHelper.
// TODO(hansberry): Share this constant with BluetoothHelper.
const size_t kMinNumBytesInServiceData = 2;
} // namespace
@ -35,16 +35,16 @@ BleScannerImpl::Factory* BleScannerImpl::Factory::test_factory_ = nullptr;
// static
std::unique_ptr<BleScanner> BleScannerImpl::Factory::Create(
BleServiceDataHelper* service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
scoped_refptr<device::BluetoothAdapter> adapter) {
if (test_factory_) {
return test_factory_->CreateInstance(service_data_helper, ble_synchronizer,
return test_factory_->CreateInstance(bluetooth_helper, ble_synchronizer,
adapter);
}
return base::WrapUnique(
new BleScannerImpl(service_data_helper, ble_synchronizer, adapter));
new BleScannerImpl(bluetooth_helper, ble_synchronizer, adapter));
}
// static
@ -63,10 +63,10 @@ BleScannerImpl::ServiceDataProvider::ExtractProximityAuthServiceData(
device::BluetoothUUID(kAdvertisingServiceUuid));
}
BleScannerImpl::BleScannerImpl(BleServiceDataHelper* service_data_helper,
BleScannerImpl::BleScannerImpl(BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
scoped_refptr<device::BluetoothAdapter> adapter)
: service_data_helper_(service_data_helper),
: bluetooth_helper_(bluetooth_helper),
ble_synchronizer_(ble_synchronizer),
adapter_(adapter),
service_data_provider_(std::make_unique<ServiceDataProvider>()) {
@ -202,7 +202,7 @@ void BleScannerImpl::HandleDeviceUpdated(
base::WriteInto(&service_data_str, service_data->size() + 1);
memcpy(string_contents_ptr, service_data->data(), service_data->size());
auto potential_result = service_data_helper_->IdentifyRemoteDevice(
auto potential_result = bluetooth_helper_->IdentifyRemoteDevice(
service_data_str, GetAllDeviceIdPairs());
// There was service data for the ProximityAuth UUID, but it did not apply to
@ -217,7 +217,7 @@ void BleScannerImpl::HandleDeviceUpdated(
void BleScannerImpl::HandlePotentialScanResult(
const std::string& service_data,
const BleServiceDataHelper::DeviceWithBackgroundBool& potential_result,
const BluetoothHelper::DeviceWithBackgroundBool& potential_result,
device::BluetoothDevice* bluetooth_device) {
std::vector<std::pair<ConnectionMedium, ConnectionRole>> results;

@ -12,7 +12,7 @@
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "chromeos/services/secure_channel/ble_scanner.h"
#include "chromeos/services/secure_channel/ble_service_data_helper.h"
#include "chromeos/services/secure_channel/bluetooth_helper.h"
#include "device/bluetooth/bluetooth_adapter.h"
namespace device {
@ -24,7 +24,7 @@ namespace chromeos {
namespace secure_channel {
class BleServiceDataHelper;
class BluetoothHelper;
class BleSynchronizerBase;
// Concrete BleScanner implementation.
@ -34,7 +34,7 @@ class BleScannerImpl : public BleScanner,
class Factory {
public:
static std::unique_ptr<BleScanner> Create(
BleServiceDataHelper* service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
scoped_refptr<device::BluetoothAdapter> adapter);
static void SetFactoryForTesting(Factory* test_factory);
@ -42,7 +42,7 @@ class BleScannerImpl : public BleScanner,
protected:
virtual ~Factory();
virtual std::unique_ptr<BleScanner> CreateInstance(
BleServiceDataHelper* service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
scoped_refptr<device::BluetoothAdapter> adapter) = 0;
@ -65,7 +65,7 @@ class BleScannerImpl : public BleScanner,
device::BluetoothDevice* bluetooth_device);
};
BleScannerImpl(BleServiceDataHelper* service_data_helper,
BleScannerImpl(BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
scoped_refptr<device::BluetoothAdapter> adapter);
@ -94,13 +94,13 @@ class BleScannerImpl : public BleScanner,
void HandleDeviceUpdated(device::BluetoothDevice* bluetooth_device);
void HandlePotentialScanResult(
const std::string& service_data,
const BleServiceDataHelper::DeviceWithBackgroundBool& potential_result,
const BluetoothHelper::DeviceWithBackgroundBool& potential_result,
device::BluetoothDevice* bluetooth_device);
void SetServiceDataProviderForTesting(
std::unique_ptr<ServiceDataProvider> service_data_provider);
BleServiceDataHelper* service_data_helper_;
BluetoothHelper* bluetooth_helper_;
BleSynchronizerBase* ble_synchronizer_;
scoped_refptr<device::BluetoothAdapter> adapter_;

@ -17,8 +17,8 @@
#include "chromeos/services/secure_channel/ble_constants.h"
#include "chromeos/services/secure_channel/connection_role.h"
#include "chromeos/services/secure_channel/fake_ble_scanner.h"
#include "chromeos/services/secure_channel/fake_ble_service_data_helper.h"
#include "chromeos/services/secure_channel/fake_ble_synchronizer.h"
#include "chromeos/services/secure_channel/fake_bluetooth_helper.h"
#include "device/bluetooth/test/mock_bluetooth_adapter.h"
#include "device/bluetooth/test/mock_bluetooth_device.h"
#include "testing/gmock/include/gmock/gmock.h"
@ -89,16 +89,15 @@ class SecureChannelBleScannerImplTest : public testing::Test {
// testing::Test:
void SetUp() override {
fake_delegate_ = std::make_unique<FakeBleScannerObserver>();
fake_ble_service_data_helper_ =
std::make_unique<FakeBleServiceDataHelper>();
fake_bluetooth_helper_ = std::make_unique<FakeBluetoothHelper>();
fake_ble_synchronizer_ = std::make_unique<FakeBleSynchronizer>();
mock_adapter_ =
base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
ble_scanner_ = BleScannerImpl::Factory::Create(
fake_ble_service_data_helper_.get(), fake_ble_synchronizer_.get(),
mock_adapter_);
ble_scanner_ = BleScannerImpl::Factory::Create(fake_bluetooth_helper_.get(),
fake_ble_synchronizer_.get(),
mock_adapter_);
ble_scanner_->AddObserver(fake_delegate_.get());
auto fake_service_data_provider =
@ -186,7 +185,7 @@ class SecureChannelBleScannerImplTest : public testing::Test {
const std::vector<FakeBleScannerObserver::Result>& results =
fake_delegate_->handled_scan_results();
fake_ble_service_data_helper_->SetIdentifiedDevice(
fake_bluetooth_helper_->SetIdentifiedDevice(
service_data, expected_remote_device, is_background_advertisement);
size_t num_results_before_call = results.size();
@ -234,8 +233,8 @@ class SecureChannelBleScannerImplTest : public testing::Test {
return discovery_session_weak_ptr_.get();
}
FakeBleServiceDataHelper* fake_ble_service_data_helper() {
return fake_ble_service_data_helper_.get();
FakeBluetoothHelper* fake_bluetooth_helper() {
return fake_bluetooth_helper_.get();
}
const multidevice::RemoteDeviceRefList& test_devices() {
@ -269,7 +268,7 @@ class SecureChannelBleScannerImplTest : public testing::Test {
const multidevice::RemoteDeviceRefList test_devices_;
std::unique_ptr<FakeBleScannerObserver> fake_delegate_;
std::unique_ptr<FakeBleServiceDataHelper> fake_ble_service_data_helper_;
std::unique_ptr<FakeBluetoothHelper> fake_bluetooth_helper_;
std::unique_ptr<FakeBleSynchronizer> fake_ble_synchronizer_;
scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
@ -312,7 +311,7 @@ TEST_F(SecureChannelBleScannerImplTest, IncorrectRole) {
// Set the device to be a foreground advertisement, even though the registered
// role is listener.
fake_ble_service_data_helper()->SetIdentifiedDevice(
fake_bluetooth_helper()->SetIdentifiedDevice(
"wrongRoleServiceData", test_devices()[0],
false /* is_background_advertisement */);

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/services/secure_channel/ble_service_data_helper.h"
#include "chromeos/services/secure_channel/bluetooth_helper.h"
#include "base/logging.h"
#include "base/notreached.h"
@ -12,12 +12,12 @@ namespace chromeos {
namespace secure_channel {
BleServiceDataHelper::BleServiceDataHelper() = default;
BluetoothHelper::BluetoothHelper() = default;
BleServiceDataHelper::~BleServiceDataHelper() = default;
BluetoothHelper::~BluetoothHelper() = default;
base::Optional<BleServiceDataHelper::DeviceWithBackgroundBool>
BleServiceDataHelper::IdentifyRemoteDevice(
base::Optional<BluetoothHelper::DeviceWithBackgroundBool>
BluetoothHelper::IdentifyRemoteDevice(
const std::string& service_data,
const DeviceIdPairSet& device_id_pair_set) {
base::Optional<DeviceWithBackgroundBool>
@ -34,7 +34,7 @@ BleServiceDataHelper::IdentifyRemoteDevice(
return potential_device_with_background_bool;
}
PA_LOG(ERROR) << "BleServiceDataHelper::IdentifyRemoteDevice(): Identified "
PA_LOG(ERROR) << "BluetoothHelper::IdentifyRemoteDevice(): Identified "
"device was not present in the provided DeviceIdPairSet.";
NOTREACHED();
return base::nullopt;

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_BLE_SERVICE_DATA_HELPER_H_
#define CHROMEOS_SERVICES_SECURE_CHANNEL_BLE_SERVICE_DATA_HELPER_H_
#ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_BLUETOOTH_HELPER_H_
#define CHROMEOS_SERVICES_SECURE_CHANNEL_BLUETOOTH_HELPER_H_
#include <memory>
#include <string>
@ -22,9 +22,9 @@ namespace secure_channel {
// Provides the ability to generate BLE advertisement service data and, given
// service data that has been received in a BLE discovery session, identify the
// device which sent the advertisement.
class BleServiceDataHelper {
class BluetoothHelper {
public:
virtual ~BleServiceDataHelper();
virtual ~BluetoothHelper();
// Generates service data to be used in a foreground BLE advertisement from
// the device with ID |local_device_id| to the device with ID
@ -44,17 +44,17 @@ class BleServiceDataHelper {
const DeviceIdPairSet& device_id_pair_set);
protected:
BleServiceDataHelper();
BluetoothHelper();
virtual base::Optional<DeviceWithBackgroundBool> PerformIdentifyRemoteDevice(
const std::string& service_data,
const DeviceIdPairSet& device_id_pair_set) = 0;
DISALLOW_COPY_AND_ASSIGN(BleServiceDataHelper);
DISALLOW_COPY_AND_ASSIGN(BluetoothHelper);
};
} // namespace secure_channel
} // namespace chromeos
#endif // CHROMEOS_SERVICES_SECURE_CHANNEL_BLE_SERVICE_DATA_HELPER_H_
#endif // CHROMEOS_SERVICES_SECURE_CHANNEL_BLUETOOTH_HELPER_H_

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/services/secure_channel/ble_service_data_helper_impl.h"
#include "chromeos/services/secure_channel/bluetooth_helper_impl.h"
#include "base/containers/flat_map.h"
#include "base/memory/ptr_util.h"
@ -35,36 +35,35 @@ const size_t kMinNumBytesInForegroundServiceData = 4;
} // namespace
// static
BleServiceDataHelperImpl::Factory*
BleServiceDataHelperImpl::Factory::test_factory_ = nullptr;
BluetoothHelperImpl::Factory* BluetoothHelperImpl::Factory::test_factory_ =
nullptr;
// static
std::unique_ptr<BleServiceDataHelper> BleServiceDataHelperImpl::Factory::Create(
std::unique_ptr<BluetoothHelper> BluetoothHelperImpl::Factory::Create(
multidevice::RemoteDeviceCache* remote_device_cache) {
if (test_factory_)
return test_factory_->CreateInstance(remote_device_cache);
return base::WrapUnique(new BleServiceDataHelperImpl(remote_device_cache));
return base::WrapUnique(new BluetoothHelperImpl(remote_device_cache));
}
// static
void BleServiceDataHelperImpl::Factory::SetFactoryForTesting(
Factory* test_factory) {
void BluetoothHelperImpl::Factory::SetFactoryForTesting(Factory* test_factory) {
test_factory_ = test_factory;
}
BleServiceDataHelperImpl::Factory::~Factory() = default;
BluetoothHelperImpl::Factory::~Factory() = default;
BleServiceDataHelperImpl::BleServiceDataHelperImpl(
BluetoothHelperImpl::BluetoothHelperImpl(
multidevice::RemoteDeviceCache* remote_device_cache)
: remote_device_cache_(remote_device_cache),
background_eid_generator_(std::make_unique<BackgroundEidGenerator>()),
foreground_eid_generator_(std::make_unique<ForegroundEidGenerator>()) {}
BleServiceDataHelperImpl::~BleServiceDataHelperImpl() = default;
BluetoothHelperImpl::~BluetoothHelperImpl() = default;
std::unique_ptr<DataWithTimestamp>
BleServiceDataHelperImpl::GenerateForegroundAdvertisement(
BluetoothHelperImpl::GenerateForegroundAdvertisement(
const DeviceIdPair& device_id_pair) {
base::Optional<multidevice::RemoteDeviceRef> local_device =
remote_device_cache_->GetRemoteDevice(
@ -92,8 +91,8 @@ BleServiceDataHelperImpl::GenerateForegroundAdvertisement(
*remote_device, local_device->public_key());
}
base::Optional<BleServiceDataHelper::DeviceWithBackgroundBool>
BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
base::Optional<BluetoothHelper::DeviceWithBackgroundBool>
BluetoothHelperImpl::PerformIdentifyRemoteDevice(
const std::string& service_data,
const DeviceIdPairSet& device_id_pair_set) {
base::flat_map<std::string, std::vector<std::string>>
@ -131,8 +130,8 @@ BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
return base::nullopt;
}
base::Optional<BleServiceDataHelper::DeviceWithBackgroundBool>
BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
base::Optional<BluetoothHelper::DeviceWithBackgroundBool>
BluetoothHelperImpl::PerformIdentifyRemoteDevice(
const std::string& service_data,
const std::string& local_device_id,
const std::vector<std::string>& remote_device_ids) {
@ -178,14 +177,14 @@ BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
if (identified_device_id.empty())
return base::nullopt;
return BleServiceDataHelper::DeviceWithBackgroundBool(
return BluetoothHelper::DeviceWithBackgroundBool(
*remote_device_cache_->GetRemoteDevice(
base::nullopt /* instance_id */,
identified_device_id /* legacy_device_id */),
is_background_advertisement);
}
void BleServiceDataHelperImpl::SetTestDoubles(
void BluetoothHelperImpl::SetTestDoubles(
std::unique_ptr<BackgroundEidGenerator> background_eid_generator,
std::unique_ptr<ForegroundEidGenerator> foreground_eid_generator) {
background_eid_generator_ = std::move(background_eid_generator);

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_BLE_SERVICE_DATA_HELPER_IMPL_H_
#define CHROMEOS_SERVICES_SECURE_CHANNEL_BLE_SERVICE_DATA_HELPER_IMPL_H_
#ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_BLUETOOTH_HELPER_IMPL_H_
#define CHROMEOS_SERVICES_SECURE_CHANNEL_BLUETOOTH_HELPER_IMPL_H_
#include <memory>
#include <string>
@ -11,7 +11,7 @@
#include "base/macros.h"
#include "base/optional.h"
#include "chromeos/components/multidevice/remote_device_ref.h"
#include "chromeos/services/secure_channel/ble_service_data_helper.h"
#include "chromeos/services/secure_channel/bluetooth_helper.h"
#include "chromeos/services/secure_channel/data_with_timestamp.h"
namespace chromeos {
@ -25,40 +25,40 @@ namespace secure_channel {
class BackgroundEidGenerator;
class ForegroundEidGenerator;
// Concrete BleServiceDataHelper implementation.
class BleServiceDataHelperImpl : public BleServiceDataHelper {
// Concrete BluetoothHelper implementation.
class BluetoothHelperImpl : public BluetoothHelper {
public:
class Factory {
public:
static std::unique_ptr<BleServiceDataHelper> Create(
static std::unique_ptr<BluetoothHelper> Create(
multidevice::RemoteDeviceCache* remote_device_cache);
static void SetFactoryForTesting(Factory* test_factory);
protected:
virtual ~Factory();
virtual std::unique_ptr<BleServiceDataHelper> CreateInstance(
virtual std::unique_ptr<BluetoothHelper> CreateInstance(
multidevice::RemoteDeviceCache* remote_device_cache) = 0;
private:
static Factory* test_factory_;
};
~BleServiceDataHelperImpl() override;
~BluetoothHelperImpl() override;
private:
friend class SecureChannelBleServiceDataHelperImplTest;
friend class SecureChannelBluetoothHelperImplTest;
explicit BleServiceDataHelperImpl(
explicit BluetoothHelperImpl(
multidevice::RemoteDeviceCache* remote_device_cache);
// BleServiceDataHelper:
// BluetoothHelper:
std::unique_ptr<DataWithTimestamp> GenerateForegroundAdvertisement(
const DeviceIdPair& device_id_pair) override;
base::Optional<DeviceWithBackgroundBool> PerformIdentifyRemoteDevice(
const std::string& service_data,
const DeviceIdPairSet& device_id_pair_set) override;
base::Optional<BleServiceDataHelper::DeviceWithBackgroundBool>
base::Optional<BluetoothHelper::DeviceWithBackgroundBool>
PerformIdentifyRemoteDevice(
const std::string& service_data,
const std::string& local_device_id,
@ -72,11 +72,11 @@ class BleServiceDataHelperImpl : public BleServiceDataHelper {
std::unique_ptr<BackgroundEidGenerator> background_eid_generator_;
std::unique_ptr<ForegroundEidGenerator> foreground_eid_generator_;
DISALLOW_COPY_AND_ASSIGN(BleServiceDataHelperImpl);
DISALLOW_COPY_AND_ASSIGN(BluetoothHelperImpl);
};
} // namespace secure_channel
} // namespace chromeos
#endif // CHROMEOS_SERVICES_SECURE_CHANNEL_BLE_SERVICE_DATA_HELPER_IMPL_H_
#endif // CHROMEOS_SERVICES_SECURE_CHANNEL_BLUETOOTH_HELPER_IMPL_H_

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/services/secure_channel/ble_service_data_helper_impl.h"
#include "chromeos/services/secure_channel/bluetooth_helper_impl.h"
#include <memory>
@ -88,9 +88,9 @@ multidevice::RemoteDeviceRef CreateLocalDevice(int id) {
} // namespace
class SecureChannelBleServiceDataHelperImplTest : public testing::Test {
class SecureChannelBluetoothHelperImplTest : public testing::Test {
protected:
SecureChannelBleServiceDataHelperImplTest()
SecureChannelBluetoothHelperImplTest()
: test_local_device_1_(CreateLocalDevice(1)),
test_local_device_2_(CreateLocalDevice(2)),
test_remote_devices_(
@ -104,7 +104,7 @@ class SecureChannelBleServiceDataHelperImplTest : public testing::Test {
test_local_device_2_.GetDeviceId());
}
~SecureChannelBleServiceDataHelperImplTest() override = default;
~SecureChannelBluetoothHelperImplTest() override = default;
// testing::Test:
void SetUp() override {
@ -139,10 +139,9 @@ class SecureChannelBleServiceDataHelperImplTest : public testing::Test {
});
remote_device_cache_->SetRemoteDevices(devices);
helper_ =
BleServiceDataHelperImpl::Factory::Create(remote_device_cache_.get());
helper_ = BluetoothHelperImpl::Factory::Create(remote_device_cache_.get());
static_cast<BleServiceDataHelperImpl*>(helper_.get())
static_cast<BluetoothHelperImpl*>(helper_.get())
->SetTestDoubles(std::move(fake_background_eid_generator),
std::move(mock_foreground_eid_generator));
}
@ -158,7 +157,7 @@ class SecureChannelBleServiceDataHelperImplTest : public testing::Test {
std::unique_ptr<multidevice::RemoteDeviceCache> remote_device_cache_;
std::unique_ptr<BleServiceDataHelper> helper_;
std::unique_ptr<BluetoothHelper> helper_;
multidevice::RemoteDeviceRef test_local_device_1_;
multidevice::RemoteDeviceRef test_local_device_2_;
@ -168,10 +167,10 @@ class SecureChannelBleServiceDataHelperImplTest : public testing::Test {
DataWithTimestamp fake_advertisement_;
private:
DISALLOW_COPY_AND_ASSIGN(SecureChannelBleServiceDataHelperImplTest);
DISALLOW_COPY_AND_ASSIGN(SecureChannelBluetoothHelperImplTest);
};
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestGenerateForegroundAdvertisement_CannotGenerateAdvertisement) {
fake_ble_advertisement_generator_->set_advertisement(nullptr);
EXPECT_FALSE(helper_->GenerateForegroundAdvertisement(
@ -179,7 +178,7 @@ TEST_F(SecureChannelBleServiceDataHelperImplTest,
test_local_device_1_.GetDeviceId() /* local_device_id */)));
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestGenerateForegroundAdvertisement) {
auto data_with_timestamp = helper_->GenerateForegroundAdvertisement(
DeviceIdPair(test_remote_devices_[0].GetDeviceId() /* remote_device_id */,
@ -187,21 +186,21 @@ TEST_F(SecureChannelBleServiceDataHelperImplTest,
EXPECT_EQ(fake_advertisement_, *data_with_timestamp);
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestGenerateForegroundAdvertisement_InvalidLocalDevice) {
EXPECT_FALSE(helper_->GenerateForegroundAdvertisement(
DeviceIdPair(test_remote_devices_[0].GetDeviceId() /* remote_device_id */,
"invalid local device id" /* local_device_id */)));
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestGenerateForegroundAdvertisement_InvalidRemoteDevice) {
EXPECT_FALSE(helper_->GenerateForegroundAdvertisement(
DeviceIdPair("invalid remote device id" /* remote_device_id */,
test_local_device_1_.GetDeviceId() /* local_device_id */)));
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestIdentifyRemoteDevice_InvalidAdvertisementLength) {
std::string invalid_service_data = "a";
mock_foreground_eid_generator_->set_identified_device_id(
@ -215,7 +214,7 @@ TEST_F(SecureChannelBleServiceDataHelperImplTest,
EXPECT_FALSE(device_with_background_bool);
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestIdentifyRemoteDevice_ForegroundAdvertisement) {
std::string valid_service_data_for_registered_device = "abcde";
ASSERT_TRUE(valid_service_data_for_registered_device.size() >=
@ -246,7 +245,7 @@ TEST_F(SecureChannelBleServiceDataHelperImplTest,
EXPECT_FALSE(device_with_background_bool->second);
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestIdentifyRemoteDevice_ForegroundAdvertisement_NoRegisteredDevice) {
std::string valid_service_data = "abcde";
ASSERT_TRUE(valid_service_data.size() >=
@ -260,7 +259,7 @@ TEST_F(SecureChannelBleServiceDataHelperImplTest,
EXPECT_FALSE(device_with_background_bool);
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestIdentifyRemoteDevice_BackgroundAdvertisement) {
std::string valid_service_data_for_registered_device = "ab";
ASSERT_TRUE(valid_service_data_for_registered_device.size() >=
@ -291,7 +290,7 @@ TEST_F(SecureChannelBleServiceDataHelperImplTest,
EXPECT_TRUE(device_with_background_bool->second);
}
TEST_F(SecureChannelBleServiceDataHelperImplTest,
TEST_F(SecureChannelBluetoothHelperImplTest,
TestIdentifyRemoteDevice_BackgroundAdvertisement_NoRegisteredDevice) {
std::string valid_service_data_for_registered_device = "ab";
ASSERT_TRUE(valid_service_data_for_registered_device.size() >=

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/services/secure_channel/fake_ble_service_data_helper.h"
#include "chromeos/services/secure_channel/fake_bluetooth_helper.h"
#include "base/stl_util.h"
@ -10,22 +10,22 @@ namespace chromeos {
namespace secure_channel {
FakeBleServiceDataHelper::FakeBleServiceDataHelper() = default;
FakeBluetoothHelper::FakeBluetoothHelper() = default;
FakeBleServiceDataHelper::~FakeBleServiceDataHelper() = default;
FakeBluetoothHelper::~FakeBluetoothHelper() = default;
void FakeBleServiceDataHelper::SetAdvertisement(
void FakeBluetoothHelper::SetAdvertisement(
const DeviceIdPair& device_id_pair,
const DataWithTimestamp& service_data) {
device_id_pair_to_service_data_map_.insert({device_id_pair, service_data});
}
void FakeBleServiceDataHelper::RemoveAdvertisement(
void FakeBluetoothHelper::RemoveAdvertisement(
const DeviceIdPair& device_id_pair) {
device_id_pair_to_service_data_map_.erase(device_id_pair);
}
void FakeBleServiceDataHelper::SetIdentifiedDevice(
void FakeBluetoothHelper::SetIdentifiedDevice(
const std::string& service_data,
multidevice::RemoteDeviceRef identified_device,
bool is_background_advertisement) {
@ -35,7 +35,7 @@ void FakeBleServiceDataHelper::SetIdentifiedDevice(
}
std::unique_ptr<DataWithTimestamp>
FakeBleServiceDataHelper::GenerateForegroundAdvertisement(
FakeBluetoothHelper::GenerateForegroundAdvertisement(
const DeviceIdPair& device_id_pair) {
if (!base::Contains(device_id_pair_to_service_data_map_, device_id_pair))
return nullptr;
@ -44,8 +44,8 @@ FakeBleServiceDataHelper::GenerateForegroundAdvertisement(
device_id_pair_to_service_data_map_.at(device_id_pair));
}
base::Optional<BleServiceDataHelper::DeviceWithBackgroundBool>
FakeBleServiceDataHelper::PerformIdentifyRemoteDevice(
base::Optional<BluetoothHelper::DeviceWithBackgroundBool>
FakeBluetoothHelper::PerformIdentifyRemoteDevice(
const std::string& service_data,
const DeviceIdPairSet& device_id_pair_set) {
if (!base::Contains(service_data_to_device_with_background_bool_map_,

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_BLE_SERVICE_DATA_HELPER_H_
#define CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_BLE_SERVICE_DATA_HELPER_H_
#ifndef CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_BLUETOOTH_HELPER_H_
#define CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_BLUETOOTH_HELPER_H_
#include <memory>
#include <string>
@ -13,18 +13,18 @@
#include "base/macros.h"
#include "base/optional.h"
#include "chromeos/components/multidevice/remote_device_ref.h"
#include "chromeos/services/secure_channel/ble_service_data_helper.h"
#include "chromeos/services/secure_channel/bluetooth_helper.h"
#include "chromeos/services/secure_channel/data_with_timestamp.h"
namespace chromeos {
namespace secure_channel {
// Test BleServiceDataHelper implementation.
class FakeBleServiceDataHelper : public BleServiceDataHelper {
// Test BluetoothHelper implementation.
class FakeBluetoothHelper : public BluetoothHelper {
public:
FakeBleServiceDataHelper();
~FakeBleServiceDataHelper() override;
FakeBluetoothHelper();
~FakeBluetoothHelper() override;
// Sets the data to be returned by a GenerateForegroundAdvertisement() call.
void SetAdvertisement(const DeviceIdPair& device_id_pair,
@ -38,7 +38,7 @@ class FakeBleServiceDataHelper : public BleServiceDataHelper {
bool is_background_advertisement);
private:
// BleServiceDataHelper:
// BluetoothHelper:
std::unique_ptr<DataWithTimestamp> GenerateForegroundAdvertisement(
const DeviceIdPair& device_id_pair) override;
base::Optional<DeviceWithBackgroundBool> PerformIdentifyRemoteDevice(
@ -51,11 +51,11 @@ class FakeBleServiceDataHelper : public BleServiceDataHelper {
std::unordered_map<std::string, DeviceWithBackgroundBool>
service_data_to_device_with_background_bool_map_;
DISALLOW_COPY_AND_ASSIGN(FakeBleServiceDataHelper);
DISALLOW_COPY_AND_ASSIGN(FakeBluetoothHelper);
};
} // namespace secure_channel
} // namespace chromeos
#endif // CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_BLE_SERVICE_DATA_HELPER_H_
#endif // CHROMEOS_SERVICES_SECURE_CHANNEL_FAKE_BLUETOOTH_HELPER_H_

@ -14,8 +14,8 @@
#include "chromeos/services/secure_channel/authenticated_channel.h"
#include "chromeos/services/secure_channel/ble_connection_manager_impl.h"
#include "chromeos/services/secure_channel/ble_scanner_impl.h"
#include "chromeos/services/secure_channel/ble_service_data_helper_impl.h"
#include "chromeos/services/secure_channel/ble_synchronizer.h"
#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/pending_connection_manager_impl.h"
@ -68,19 +68,18 @@ SecureChannelImpl::SecureChannelImpl(
: bluetooth_adapter_(std::move(bluetooth_adapter)),
timer_factory_(TimerFactoryImpl::Factory::Create()),
remote_device_cache_(multidevice::RemoteDeviceCache::Factory::Create()),
ble_service_data_helper_(BleServiceDataHelperImpl::Factory::Create(
remote_device_cache_.get())),
bluetooth_helper_(
BluetoothHelperImpl::Factory::Create(remote_device_cache_.get())),
ble_synchronizer_(BleSynchronizer::Factory::Create(bluetooth_adapter_)),
ble_scanner_(
BleScannerImpl::Factory::Create(ble_service_data_helper_.get(),
ble_synchronizer_.get(),
bluetooth_adapter_)),
ble_connection_manager_(BleConnectionManagerImpl::Factory::Create(
bluetooth_adapter_,
ble_service_data_helper_.get(),
ble_synchronizer_.get(),
ble_scanner_.get(),
timer_factory_.get())),
ble_scanner_(BleScannerImpl::Factory::Create(bluetooth_helper_.get(),
ble_synchronizer_.get(),
bluetooth_adapter_)),
ble_connection_manager_(
BleConnectionManagerImpl::Factory::Create(bluetooth_adapter_,
bluetooth_helper_.get(),
ble_synchronizer_.get(),
ble_scanner_.get(),
timer_factory_.get())),
pending_connection_manager_(PendingConnectionManagerImpl::Factory::Create(
this /* delegate */,
ble_connection_manager_.get(),

@ -30,7 +30,7 @@ namespace secure_channel {
class BleConnectionManager;
class BleScanner;
class BleServiceDataHelper;
class BluetoothHelper;
class BleSynchronizerBase;
class TimerFactory;
@ -174,7 +174,7 @@ class SecureChannelImpl : public mojom::SecureChannel,
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
std::unique_ptr<TimerFactory> timer_factory_;
std::unique_ptr<multidevice::RemoteDeviceCache> remote_device_cache_;
std::unique_ptr<BleServiceDataHelper> ble_service_data_helper_;
std::unique_ptr<BluetoothHelper> bluetooth_helper_;
std::unique_ptr<BleSynchronizerBase> ble_synchronizer_;
std::unique_ptr<BleScanner> ble_scanner_;
std::unique_ptr<BleConnectionManager> ble_connection_manager_;

@ -17,15 +17,15 @@
#include "chromeos/services/secure_channel/active_connection_manager_impl.h"
#include "chromeos/services/secure_channel/ble_connection_manager_impl.h"
#include "chromeos/services/secure_channel/ble_scanner_impl.h"
#include "chromeos/services/secure_channel/ble_service_data_helper_impl.h"
#include "chromeos/services/secure_channel/ble_synchronizer.h"
#include "chromeos/services/secure_channel/bluetooth_helper_impl.h"
#include "chromeos/services/secure_channel/client_connection_parameters_impl.h"
#include "chromeos/services/secure_channel/fake_active_connection_manager.h"
#include "chromeos/services/secure_channel/fake_authenticated_channel.h"
#include "chromeos/services/secure_channel/fake_ble_connection_manager.h"
#include "chromeos/services/secure_channel/fake_ble_scanner.h"
#include "chromeos/services/secure_channel/fake_ble_service_data_helper.h"
#include "chromeos/services/secure_channel/fake_ble_synchronizer.h"
#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_pending_connection_manager.h"
@ -96,35 +96,34 @@ class TestRemoteDeviceCacheFactory
DISALLOW_COPY_AND_ASSIGN(TestRemoteDeviceCacheFactory);
};
class FakeBleServiceDataHelperFactory
: public BleServiceDataHelperImpl::Factory {
class FakeBluetoothHelperFactory : public BluetoothHelperImpl::Factory {
public:
FakeBleServiceDataHelperFactory(
FakeBluetoothHelperFactory(
TestRemoteDeviceCacheFactory* test_remote_device_cache_factory)
: test_remote_device_cache_factory_(test_remote_device_cache_factory) {}
~FakeBleServiceDataHelperFactory() override = default;
~FakeBluetoothHelperFactory() override = default;
FakeBleServiceDataHelper* instance() { return instance_; }
FakeBluetoothHelper* instance() { return instance_; }
private:
// BleServiceDataHelperImpl::Factory:
std::unique_ptr<BleServiceDataHelper> CreateInstance(
// BluetoothHelperImpl::Factory:
std::unique_ptr<BluetoothHelper> CreateInstance(
multidevice::RemoteDeviceCache* remote_device_cache) override {
EXPECT_FALSE(instance_);
EXPECT_EQ(test_remote_device_cache_factory_->instance(),
remote_device_cache);
auto instance = std::make_unique<FakeBleServiceDataHelper>();
auto instance = std::make_unique<FakeBluetoothHelper>();
instance_ = instance.get();
return instance;
}
TestRemoteDeviceCacheFactory* test_remote_device_cache_factory_;
FakeBleServiceDataHelper* instance_ = nullptr;
FakeBluetoothHelper* instance_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(FakeBleServiceDataHelperFactory);
DISALLOW_COPY_AND_ASSIGN(FakeBluetoothHelperFactory);
};
class FakeBleSynchronizerFactory : public BleSynchronizer::Factory {
@ -153,10 +152,9 @@ class FakeBleSynchronizerFactory : public BleSynchronizer::Factory {
class FakeBleScannerFactory : public BleScannerImpl::Factory {
public:
FakeBleScannerFactory(
FakeBleServiceDataHelperFactory* fake_ble_service_data_helper_factory,
FakeBluetoothHelperFactory* fake_bluetooth_helper_factory,
FakeBleSynchronizerFactory* fake_ble_synchronizer_factory)
: fake_ble_service_data_helper_factory_(
fake_ble_service_data_helper_factory),
: fake_bluetooth_helper_factory_(fake_bluetooth_helper_factory),
fake_ble_synchronizer_factory_(fake_ble_synchronizer_factory) {}
~FakeBleScannerFactory() override = default;
@ -166,11 +164,10 @@ class FakeBleScannerFactory : public BleScannerImpl::Factory {
private:
// BleScannerImpl::Factory:
std::unique_ptr<BleScanner> CreateInstance(
BleServiceDataHelper* service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer_base,
scoped_refptr<device::BluetoothAdapter> adapter) override {
EXPECT_EQ(fake_ble_service_data_helper_factory_->instance(),
service_data_helper);
EXPECT_EQ(fake_bluetooth_helper_factory_->instance(), bluetooth_helper);
EXPECT_EQ(fake_ble_synchronizer_factory_->instance(),
ble_synchronizer_base);
EXPECT_FALSE(instance_);
@ -182,7 +179,7 @@ class FakeBleScannerFactory : public BleScannerImpl::Factory {
FakeBleScanner* instance_ = nullptr;
FakeBleServiceDataHelperFactory* fake_ble_service_data_helper_factory_;
FakeBluetoothHelperFactory* fake_bluetooth_helper_factory_;
FakeBleSynchronizerFactory* fake_ble_synchronizer_factory_;
DISALLOW_COPY_AND_ASSIGN(FakeBleScannerFactory);
@ -193,13 +190,12 @@ class FakeBleConnectionManagerFactory
public:
FakeBleConnectionManagerFactory(
device::BluetoothAdapter* expected_bluetooth_adapter,
FakeBleServiceDataHelperFactory* fake_ble_service_data_helper_factory,
FakeBluetoothHelperFactory* fake_bluetooth_helper_factory,
FakeBleSynchronizerFactory* fake_ble_synchronizer_factory,
FakeBleScannerFactory* fake_ble_scanner_factory,
FakeTimerFactoryFactory* fake_timer_factory_factory)
: expected_bluetooth_adapter_(expected_bluetooth_adapter),
fake_ble_service_data_helper_factory_(
fake_ble_service_data_helper_factory),
fake_bluetooth_helper_factory_(fake_bluetooth_helper_factory),
fake_ble_synchronizer_factory_(fake_ble_synchronizer_factory),
fake_ble_scanner_factory_(fake_ble_scanner_factory),
fake_timer_factory_factory_(fake_timer_factory_factory) {}
@ -212,15 +208,14 @@ class FakeBleConnectionManagerFactory
// BleConnectionManagerImpl::Factory:
std::unique_ptr<BleConnectionManager> CreateInstance(
scoped_refptr<device::BluetoothAdapter> bluetooth_adapter,
BleServiceDataHelper* ble_service_data_helper,
BluetoothHelper* bluetooth_helper,
BleSynchronizerBase* ble_synchronizer,
BleScanner* ble_scanner,
TimerFactory* timer_factory,
base::Clock* clock) override {
EXPECT_FALSE(instance_);
EXPECT_EQ(expected_bluetooth_adapter_, bluetooth_adapter.get());
EXPECT_EQ(fake_ble_service_data_helper_factory_->instance(),
ble_service_data_helper);
EXPECT_EQ(fake_bluetooth_helper_factory_->instance(), bluetooth_helper);
EXPECT_EQ(fake_ble_synchronizer_factory_->instance(), ble_synchronizer);
EXPECT_EQ(fake_ble_scanner_factory_->instance(), ble_scanner);
EXPECT_EQ(fake_timer_factory_factory_->instance(), timer_factory);
@ -231,7 +226,7 @@ class FakeBleConnectionManagerFactory
}
device::BluetoothAdapter* expected_bluetooth_adapter_;
FakeBleServiceDataHelperFactory* fake_ble_service_data_helper_factory_;
FakeBluetoothHelperFactory* fake_bluetooth_helper_factory_;
FakeBleSynchronizerFactory* fake_ble_synchronizer_factory_;
FakeBleScannerFactory* fake_ble_scanner_factory_;
FakeTimerFactoryFactory* fake_timer_factory_factory_;
@ -427,11 +422,11 @@ class SecureChannelServiceTest : public testing::Test {
multidevice::RemoteDeviceCache::Factory::SetFactoryForTesting(
test_remote_device_cache_factory_.get());
fake_ble_service_data_helper_factory_ =
std::make_unique<FakeBleServiceDataHelperFactory>(
fake_bluetooth_helper_factory_ =
std::make_unique<FakeBluetoothHelperFactory>(
test_remote_device_cache_factory_.get());
BleServiceDataHelperImpl::Factory::SetFactoryForTesting(
fake_ble_service_data_helper_factory_.get());
BluetoothHelperImpl::Factory::SetFactoryForTesting(
fake_bluetooth_helper_factory_.get());
fake_ble_synchronizer_factory_ =
std::make_unique<FakeBleSynchronizerFactory>();
@ -439,14 +434,14 @@ class SecureChannelServiceTest : public testing::Test {
fake_ble_synchronizer_factory_.get());
fake_ble_scanner_factory_ = std::make_unique<FakeBleScannerFactory>(
fake_ble_service_data_helper_factory_.get(),
fake_bluetooth_helper_factory_.get(),
fake_ble_synchronizer_factory_.get());
BleScannerImpl::Factory::SetFactoryForTesting(
fake_ble_scanner_factory_.get());
fake_ble_connection_manager_factory_ =
std::make_unique<FakeBleConnectionManagerFactory>(
mock_adapter_.get(), fake_ble_service_data_helper_factory_.get(),
mock_adapter_.get(), fake_bluetooth_helper_factory_.get(),
fake_ble_synchronizer_factory_.get(),
fake_ble_scanner_factory_.get(), fake_timer_factory_factory_.get());
BleConnectionManagerImpl::Factory::SetFactoryForTesting(
@ -482,7 +477,7 @@ class SecureChannelServiceTest : public testing::Test {
void TearDown() override {
TimerFactoryImpl::Factory::SetFactoryForTesting(nullptr);
multidevice::RemoteDeviceCache::Factory::SetFactoryForTesting(nullptr);
BleServiceDataHelperImpl::Factory::SetFactoryForTesting(nullptr);
BluetoothHelperImpl::Factory::SetFactoryForTesting(nullptr);
BleSynchronizer::Factory::SetFactoryForTesting(nullptr);
BleScannerImpl::Factory::SetFactoryForTesting(nullptr);
BleConnectionManagerImpl::Factory::SetFactoryForTesting(nullptr);
@ -957,8 +952,7 @@ class SecureChannelServiceTest : public testing::Test {
std::unique_ptr<FakeTimerFactoryFactory> fake_timer_factory_factory_;
std::unique_ptr<TestRemoteDeviceCacheFactory>
test_remote_device_cache_factory_;
std::unique_ptr<FakeBleServiceDataHelperFactory>
fake_ble_service_data_helper_factory_;
std::unique_ptr<FakeBluetoothHelperFactory> fake_bluetooth_helper_factory_;
std::unique_ptr<FakeBleSynchronizerFactory> fake_ble_synchronizer_factory_;
std::unique_ptr<FakeBleScannerFactory> fake_ble_scanner_factory_;
std::unique_ptr<FakeBleConnectionManagerFactory>