1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/browser/bluetooth/bluetooth_allowed_devices.h"
6
7 #include "base/strings/string_util.h"
8 #include "content/browser/bluetooth/bluetooth_allowed_devices_map.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10 #include "third_party/blink/public/common/bluetooth/web_bluetooth_device_id.h"
11 #include "url/gurl.h"
12
13 using device::BluetoothUUID;
14
15 namespace content {
16 namespace {
17 const std::string kDeviceAddress1 = "00:00:00";
18 const std::string kDeviceAddress2 = "11:11:11";
19
20 const std::string kDeviceName = "TestName";
21
22 const char kGlucoseUUIDString[] = "00001808-0000-1000-8000-00805f9b34fb";
23 const char kHeartRateUUIDString[] = "0000180d-0000-1000-8000-00805f9b34fb";
24 const char kBatteryServiceUUIDString[] = "0000180f-0000-1000-8000-00805f9b34fb";
25 const char kBloodPressureUUIDString[] = "00001813-0000-1000-8000-00805f9b34fb";
26 const char kCyclingPowerUUIDString[] = "00001818-0000-1000-8000-00805f9b34fb";
27 const BluetoothUUID kGlucoseUUID(kGlucoseUUIDString);
28 const BluetoothUUID kHeartRateUUID(kHeartRateUUIDString);
29 const BluetoothUUID kBatteryServiceUUID(kBatteryServiceUUIDString);
30 const BluetoothUUID kBloodPressureUUID(kBloodPressureUUIDString);
31 const BluetoothUUID kCyclingPowerUUID(kCyclingPowerUUIDString);
32
33 class BluetoothAllowedDevicesTest : public testing::Test {
34 protected:
BluetoothAllowedDevicesTest()35 BluetoothAllowedDevicesTest() {
36 empty_options_ = blink::mojom::WebBluetoothRequestDeviceOptions::New();
37 }
38
~BluetoothAllowedDevicesTest()39 ~BluetoothAllowedDevicesTest() override {}
40
41 blink::mojom::WebBluetoothRequestDeviceOptionsPtr empty_options_;
42 };
43
44 } // namespace
45
TEST_F(BluetoothAllowedDevicesTest,UniqueOriginNotSupported)46 TEST_F(BluetoothAllowedDevicesTest, UniqueOriginNotSupported) {
47 auto allowed_devices_map = std::make_unique<BluetoothAllowedDevicesMap>();
48 EXPECT_DEATH_IF_SUPPORTED(
49 allowed_devices_map->GetOrCreateAllowedDevices(url::Origin()), "");
50 }
51
TEST_F(BluetoothAllowedDevicesTest,AddDevice)52 TEST_F(BluetoothAllowedDevicesTest, AddDevice) {
53 BluetoothAllowedDevices allowed_devices;
54
55 const blink::WebBluetoothDeviceId& device_id =
56 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
57
58 // Test that we can retrieve the device address/id.
59 EXPECT_EQ(device_id, *allowed_devices.GetDeviceId(kDeviceAddress1));
60 EXPECT_EQ(kDeviceAddress1, allowed_devices.GetDeviceAddress(device_id));
61 }
62
TEST_F(BluetoothAllowedDevicesTest,AddDeviceTwice)63 TEST_F(BluetoothAllowedDevicesTest, AddDeviceTwice) {
64 BluetoothAllowedDevices allowed_devices;
65 const blink::WebBluetoothDeviceId& device_id1 =
66 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
67 const blink::WebBluetoothDeviceId& device_id2 =
68 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
69
70 EXPECT_EQ(device_id1, device_id2);
71
72 // Test that we can retrieve the device address/id.
73 EXPECT_EQ(device_id1, *allowed_devices.GetDeviceId(kDeviceAddress1));
74 EXPECT_EQ(kDeviceAddress1, allowed_devices.GetDeviceAddress(device_id1));
75 }
76
TEST_F(BluetoothAllowedDevicesTest,AddTwoDevices)77 TEST_F(BluetoothAllowedDevicesTest, AddTwoDevices) {
78 BluetoothAllowedDevices allowed_devices;
79 const blink::WebBluetoothDeviceId& device_id1 =
80 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
81 const blink::WebBluetoothDeviceId& device_id2 =
82 allowed_devices.AddDevice(kDeviceAddress2, empty_options_);
83
84 EXPECT_NE(device_id1, device_id2);
85
86 // Test that we can retrieve the device address/id.
87 EXPECT_EQ(device_id1, *allowed_devices.GetDeviceId(kDeviceAddress1));
88 EXPECT_EQ(device_id2, *allowed_devices.GetDeviceId(kDeviceAddress2));
89
90 EXPECT_EQ(kDeviceAddress1, allowed_devices.GetDeviceAddress(device_id1));
91 EXPECT_EQ(kDeviceAddress2, allowed_devices.GetDeviceAddress(device_id2));
92 }
93
TEST_F(BluetoothAllowedDevicesTest,AddTwoDevicesFromTwoOriginsToMap)94 TEST_F(BluetoothAllowedDevicesTest, AddTwoDevicesFromTwoOriginsToMap) {
95 auto allowed_devices_map = std::make_unique<BluetoothAllowedDevicesMap>();
96 content::BluetoothAllowedDevices& allowed_devices1 =
97 allowed_devices_map->GetOrCreateAllowedDevices(
98 url::Origin::Create(GURL("https://www.example1.com")));
99 content::BluetoothAllowedDevices& allowed_devices2 =
100 allowed_devices_map->GetOrCreateAllowedDevices(
101 url::Origin::Create(GURL("https://www.example2.com")));
102
103 const blink::WebBluetoothDeviceId& device_id1 =
104 allowed_devices1.AddDevice(kDeviceAddress1, empty_options_);
105 const blink::WebBluetoothDeviceId& device_id2 =
106 allowed_devices2.AddDevice(kDeviceAddress2, empty_options_);
107
108 EXPECT_NE(device_id1, device_id2);
109
110 // Test that the wrong origin doesn't have access to the device.
111 EXPECT_EQ(nullptr, allowed_devices1.GetDeviceId(kDeviceAddress2));
112 EXPECT_EQ(nullptr, allowed_devices2.GetDeviceId(kDeviceAddress1));
113
114 EXPECT_EQ(std::string(), allowed_devices1.GetDeviceAddress(device_id2));
115 EXPECT_EQ(std::string(), allowed_devices2.GetDeviceAddress(device_id1));
116
117 // Test that we can retrieve the device address/id.
118 EXPECT_EQ(device_id1, *(allowed_devices1.GetDeviceId(kDeviceAddress1)));
119 EXPECT_EQ(device_id2, *(allowed_devices2.GetDeviceId(kDeviceAddress2)));
120
121 EXPECT_EQ(kDeviceAddress1, allowed_devices1.GetDeviceAddress(device_id1));
122 EXPECT_EQ(kDeviceAddress2, allowed_devices2.GetDeviceAddress(device_id2));
123 }
124
TEST_F(BluetoothAllowedDevicesTest,AddDeviceFromTwoOriginsToMap)125 TEST_F(BluetoothAllowedDevicesTest, AddDeviceFromTwoOriginsToMap) {
126 auto allowed_devices_map = std::make_unique<BluetoothAllowedDevicesMap>();
127 content::BluetoothAllowedDevices& allowed_devices1 =
128 allowed_devices_map->GetOrCreateAllowedDevices(
129 url::Origin::Create(GURL("https://www.example1.com")));
130 content::BluetoothAllowedDevices& allowed_devices2 =
131 allowed_devices_map->GetOrCreateAllowedDevices(
132 url::Origin::Create(GURL("https://www.example2.com")));
133
134 const blink::WebBluetoothDeviceId& device_id1 =
135 allowed_devices1.AddDevice(kDeviceAddress1, empty_options_);
136 const blink::WebBluetoothDeviceId& device_id2 =
137 allowed_devices2.AddDevice(kDeviceAddress1, empty_options_);
138
139 EXPECT_NE(device_id1, device_id2);
140
141 // Test that the wrong origin doesn't have access to the device.
142 EXPECT_EQ(std::string(), allowed_devices1.GetDeviceAddress(device_id2));
143 EXPECT_EQ(std::string(), allowed_devices2.GetDeviceAddress(device_id1));
144 }
145
TEST_F(BluetoothAllowedDevicesTest,AddRemoveAddDevice)146 TEST_F(BluetoothAllowedDevicesTest, AddRemoveAddDevice) {
147 BluetoothAllowedDevices allowed_devices;
148 const blink::WebBluetoothDeviceId device_id_first_time =
149 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
150
151 allowed_devices.RemoveDevice(kDeviceAddress1);
152
153 const blink::WebBluetoothDeviceId device_id_second_time =
154 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
155
156 EXPECT_NE(device_id_first_time, device_id_second_time);
157 }
158
TEST_F(BluetoothAllowedDevicesTest,RemoveDevice)159 TEST_F(BluetoothAllowedDevicesTest, RemoveDevice) {
160 BluetoothAllowedDevices allowed_devices;
161
162 const blink::WebBluetoothDeviceId device_id =
163 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
164
165 allowed_devices.RemoveDevice(kDeviceAddress1);
166
167 EXPECT_EQ(nullptr, allowed_devices.GetDeviceId(kDeviceAddress1));
168 EXPECT_EQ(std::string(), allowed_devices.GetDeviceAddress(device_id));
169 }
170
TEST_F(BluetoothAllowedDevicesTest,NoPermissionForAnyService)171 TEST_F(BluetoothAllowedDevicesTest, NoPermissionForAnyService) {
172 BluetoothAllowedDevices allowed_devices;
173
174 // Setup device.
175 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options =
176 blink::mojom::WebBluetoothRequestDeviceOptions::New();
177 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter =
178 blink::mojom::WebBluetoothLeScanFilter::New();
179
180 scan_filter->name = kDeviceName;
181 options->filters.emplace();
182 options->filters->push_back({scan_filter.Clone()});
183
184 // Add to map.
185 const blink::WebBluetoothDeviceId device_id =
186 allowed_devices.AddDevice(kDeviceAddress1, options);
187
188 // Try to access at least one service.
189 EXPECT_FALSE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id));
190 EXPECT_FALSE(
191 allowed_devices.IsAllowedToAccessService(device_id, kGlucoseUUID));
192 }
193
TEST_F(BluetoothAllowedDevicesTest,AllowedServices_OneDevice)194 TEST_F(BluetoothAllowedDevicesTest, AllowedServices_OneDevice) {
195 BluetoothAllowedDevices allowed_devices;
196
197 // Setup device.
198 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options =
199 blink::mojom::WebBluetoothRequestDeviceOptions::New();
200 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter1 =
201 blink::mojom::WebBluetoothLeScanFilter::New();
202 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter2 =
203 blink::mojom::WebBluetoothLeScanFilter::New();
204
205 scan_filter1->services.emplace();
206 scan_filter1->services->push_back(kGlucoseUUID);
207 options->filters.emplace();
208 options->filters->push_back(scan_filter1.Clone());
209
210 scan_filter2->services.emplace();
211 scan_filter2->services->push_back(kHeartRateUUID);
212 options->filters->push_back(scan_filter2.Clone());
213
214 options->optional_services.push_back(kBatteryServiceUUID);
215 options->optional_services.push_back(kHeartRateUUID);
216
217 // Add to map.
218 const blink::WebBluetoothDeviceId device_id1 =
219 allowed_devices.AddDevice(kDeviceAddress1, options);
220
221 // Access allowed services.
222 EXPECT_TRUE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id1));
223 EXPECT_TRUE(
224 allowed_devices.IsAllowedToAccessService(device_id1, kGlucoseUUID));
225 EXPECT_TRUE(
226 allowed_devices.IsAllowedToAccessService(device_id1, kHeartRateUUID));
227 EXPECT_TRUE(allowed_devices.IsAllowedToAccessService(device_id1,
228 kBatteryServiceUUID));
229
230 // Try to access a non-allowed service.
231 EXPECT_FALSE(
232 allowed_devices.IsAllowedToAccessService(device_id1, kBloodPressureUUID));
233
234 // Try to access allowed services after removing device.
235 allowed_devices.RemoveDevice(kDeviceAddress1);
236
237 EXPECT_FALSE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id1));
238 EXPECT_FALSE(
239 allowed_devices.IsAllowedToAccessService(device_id1, kGlucoseUUID));
240 EXPECT_FALSE(
241 allowed_devices.IsAllowedToAccessService(device_id1, kHeartRateUUID));
242 EXPECT_FALSE(allowed_devices.IsAllowedToAccessService(device_id1,
243 kBatteryServiceUUID));
244
245 // Add device back.
246 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
247 blink::mojom::WebBluetoothRequestDeviceOptions::New();
248
249 options2->filters.emplace();
250 options2->filters->push_back(scan_filter1.Clone());
251 options2->filters->push_back(scan_filter2.Clone());
252
253 const blink::WebBluetoothDeviceId device_id2 =
254 allowed_devices.AddDevice(kDeviceAddress1, options2);
255
256 // Access allowed services.
257 EXPECT_TRUE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id2));
258 EXPECT_TRUE(
259 allowed_devices.IsAllowedToAccessService(device_id2, kGlucoseUUID));
260 EXPECT_TRUE(
261 allowed_devices.IsAllowedToAccessService(device_id2, kHeartRateUUID));
262
263 // Try to access a non-allowed service.
264 EXPECT_FALSE(allowed_devices.IsAllowedToAccessService(device_id2,
265 kBatteryServiceUUID));
266
267 // Try to access services from old device.
268 EXPECT_FALSE(
269 allowed_devices.IsAllowedToAccessService(device_id1, kGlucoseUUID));
270 EXPECT_FALSE(
271 allowed_devices.IsAllowedToAccessService(device_id1, kHeartRateUUID));
272 EXPECT_FALSE(allowed_devices.IsAllowedToAccessService(device_id1,
273 kBatteryServiceUUID));
274 }
275
TEST_F(BluetoothAllowedDevicesTest,AllowedServices_TwoDevices)276 TEST_F(BluetoothAllowedDevicesTest, AllowedServices_TwoDevices) {
277 BluetoothAllowedDevices allowed_devices;
278
279 // Setup request for device #1.
280 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options1 =
281 blink::mojom::WebBluetoothRequestDeviceOptions::New();
282 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter1 =
283 blink::mojom::WebBluetoothLeScanFilter::New();
284
285 scan_filter1->services.emplace();
286 scan_filter1->services->push_back(kGlucoseUUID);
287 options1->filters.emplace();
288 options1->filters->push_back(std::move(scan_filter1));
289
290 options1->optional_services.push_back(kHeartRateUUID);
291
292 // Setup request for device #2.
293 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
294 blink::mojom::WebBluetoothRequestDeviceOptions::New();
295 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter2 =
296 blink::mojom::WebBluetoothLeScanFilter::New();
297
298 scan_filter2->services.emplace();
299 scan_filter2->services->push_back(kBatteryServiceUUID);
300 options2->filters.emplace();
301 options2->filters->push_back(std::move(scan_filter2));
302
303 options2->optional_services.push_back(kBloodPressureUUID);
304
305 // Add devices to map.
306 const blink::WebBluetoothDeviceId& device_id1 =
307 allowed_devices.AddDevice(kDeviceAddress1, options1);
308 const blink::WebBluetoothDeviceId& device_id2 =
309 allowed_devices.AddDevice(kDeviceAddress2, options2);
310
311 // Access allowed services.
312 EXPECT_TRUE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id1));
313 EXPECT_TRUE(
314 allowed_devices.IsAllowedToAccessService(device_id1, kGlucoseUUID));
315 EXPECT_TRUE(
316 allowed_devices.IsAllowedToAccessService(device_id1, kHeartRateUUID));
317
318 EXPECT_TRUE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id2));
319 EXPECT_TRUE(allowed_devices.IsAllowedToAccessService(device_id2,
320 kBatteryServiceUUID));
321 EXPECT_TRUE(
322 allowed_devices.IsAllowedToAccessService(device_id2, kBloodPressureUUID));
323
324 // Try to access non-allowed services.
325 EXPECT_FALSE(allowed_devices.IsAllowedToAccessService(device_id1,
326 kBatteryServiceUUID));
327 EXPECT_FALSE(
328 allowed_devices.IsAllowedToAccessService(device_id1, kBloodPressureUUID));
329 EXPECT_FALSE(
330 allowed_devices.IsAllowedToAccessService(device_id1, kCyclingPowerUUID));
331
332 EXPECT_FALSE(
333 allowed_devices.IsAllowedToAccessService(device_id2, kGlucoseUUID));
334 EXPECT_FALSE(
335 allowed_devices.IsAllowedToAccessService(device_id2, kHeartRateUUID));
336 EXPECT_FALSE(
337 allowed_devices.IsAllowedToAccessService(device_id2, kCyclingPowerUUID));
338 }
339
TEST_F(BluetoothAllowedDevicesTest,AllowedServices_TwoOriginsOneDevice)340 TEST_F(BluetoothAllowedDevicesTest, AllowedServices_TwoOriginsOneDevice) {
341 auto allowed_devices_map = std::make_unique<BluetoothAllowedDevicesMap>();
342 content::BluetoothAllowedDevices& allowed_devices1 =
343 allowed_devices_map->GetOrCreateAllowedDevices(
344 url::Origin::Create(GURL("https://www.example1.com")));
345 content::BluetoothAllowedDevices& allowed_devices2 =
346 allowed_devices_map->GetOrCreateAllowedDevices(
347 url::Origin::Create(GURL("https://www.example2.com")));
348 // Setup request #1 for device.
349 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options1 =
350 blink::mojom::WebBluetoothRequestDeviceOptions::New();
351 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter1 =
352 blink::mojom::WebBluetoothLeScanFilter::New();
353
354 scan_filter1->services.emplace();
355 scan_filter1->services->push_back(kGlucoseUUID);
356 options1->filters.emplace();
357 options1->filters->push_back(std::move(scan_filter1));
358
359 options1->optional_services.push_back(kHeartRateUUID);
360
361 // Setup request #2 for device.
362 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
363 blink::mojom::WebBluetoothRequestDeviceOptions::New();
364 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter2 =
365 blink::mojom::WebBluetoothLeScanFilter::New();
366
367 scan_filter2->services.emplace();
368 scan_filter2->services->push_back(kBatteryServiceUUID);
369 options2->filters.emplace();
370 options2->filters->push_back(std::move(scan_filter2));
371
372 options2->optional_services.push_back(kBloodPressureUUID);
373
374 // Add devices to map.
375 const blink::WebBluetoothDeviceId& device_id1 =
376 allowed_devices1.AddDevice(kDeviceAddress1, options1);
377 const blink::WebBluetoothDeviceId& device_id2 =
378 allowed_devices2.AddDevice(kDeviceAddress1, options2);
379
380 // Access allowed services.
381 EXPECT_TRUE(allowed_devices1.IsAllowedToAccessAtLeastOneService(device_id1));
382 EXPECT_TRUE(
383 allowed_devices1.IsAllowedToAccessService(device_id1, kGlucoseUUID));
384 EXPECT_TRUE(
385 allowed_devices1.IsAllowedToAccessService(device_id1, kHeartRateUUID));
386
387 EXPECT_TRUE(allowed_devices2.IsAllowedToAccessAtLeastOneService(device_id2));
388 EXPECT_TRUE(allowed_devices2.IsAllowedToAccessService(device_id2,
389 kBatteryServiceUUID));
390 EXPECT_TRUE(allowed_devices2.IsAllowedToAccessService(device_id2,
391 kBloodPressureUUID));
392
393 // Try to access non-allowed services.
394 EXPECT_FALSE(allowed_devices1.IsAllowedToAccessService(device_id1,
395 kBatteryServiceUUID));
396 EXPECT_FALSE(allowed_devices1.IsAllowedToAccessService(device_id1,
397 kBloodPressureUUID));
398
399 EXPECT_FALSE(allowed_devices1.IsAllowedToAccessAtLeastOneService(device_id2));
400 EXPECT_FALSE(
401 allowed_devices1.IsAllowedToAccessService(device_id2, kGlucoseUUID));
402 EXPECT_FALSE(
403 allowed_devices1.IsAllowedToAccessService(device_id2, kHeartRateUUID));
404 EXPECT_FALSE(allowed_devices1.IsAllowedToAccessService(device_id2,
405 kBatteryServiceUUID));
406 EXPECT_FALSE(allowed_devices1.IsAllowedToAccessService(device_id2,
407 kBloodPressureUUID));
408
409 EXPECT_FALSE(
410 allowed_devices2.IsAllowedToAccessService(device_id2, kGlucoseUUID));
411 EXPECT_FALSE(
412 allowed_devices2.IsAllowedToAccessService(device_id2, kHeartRateUUID));
413
414 EXPECT_FALSE(allowed_devices2.IsAllowedToAccessAtLeastOneService(device_id1));
415 EXPECT_FALSE(
416 allowed_devices2.IsAllowedToAccessService(device_id1, kGlucoseUUID));
417 EXPECT_FALSE(
418 allowed_devices2.IsAllowedToAccessService(device_id1, kHeartRateUUID));
419 EXPECT_FALSE(allowed_devices2.IsAllowedToAccessService(device_id1,
420 kBatteryServiceUUID));
421 EXPECT_FALSE(allowed_devices2.IsAllowedToAccessService(device_id1,
422 kBloodPressureUUID));
423 }
424
TEST_F(BluetoothAllowedDevicesTest,MergeServices)425 TEST_F(BluetoothAllowedDevicesTest, MergeServices) {
426 BluetoothAllowedDevices allowed_devices;
427
428 // Setup first request.
429 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options1 =
430 blink::mojom::WebBluetoothRequestDeviceOptions::New();
431 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter1 =
432 blink::mojom::WebBluetoothLeScanFilter::New();
433
434 scan_filter1->services.emplace();
435 scan_filter1->services->push_back(kGlucoseUUID);
436 options1->filters.emplace();
437 options1->filters->push_back(std::move(scan_filter1));
438
439 options1->optional_services.push_back(kBatteryServiceUUID);
440
441 // Add to map.
442 const blink::WebBluetoothDeviceId device_id1 =
443 allowed_devices.AddDevice(kDeviceAddress1, options1);
444
445 // Setup second request.
446 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
447 blink::mojom::WebBluetoothRequestDeviceOptions::New();
448 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter2 =
449 blink::mojom::WebBluetoothLeScanFilter::New();
450
451 scan_filter2->services.emplace();
452 scan_filter2->services->push_back(kHeartRateUUID);
453 options2->filters.emplace();
454 options2->filters->push_back(std::move(scan_filter2));
455
456 options2->optional_services.push_back(kBloodPressureUUID);
457
458 // Add to map again.
459 const blink::WebBluetoothDeviceId device_id2 =
460 allowed_devices.AddDevice(kDeviceAddress1, options2);
461
462 EXPECT_EQ(device_id1, device_id2);
463
464 EXPECT_TRUE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id1));
465 EXPECT_TRUE(
466 allowed_devices.IsAllowedToAccessService(device_id1, kGlucoseUUID));
467 EXPECT_TRUE(allowed_devices.IsAllowedToAccessService(device_id1,
468 kBatteryServiceUUID));
469 EXPECT_TRUE(
470 allowed_devices.IsAllowedToAccessService(device_id1, kHeartRateUUID));
471 EXPECT_TRUE(
472 allowed_devices.IsAllowedToAccessService(device_id1, kBloodPressureUUID));
473 }
474
TEST_F(BluetoothAllowedDevicesTest,CorrectIdFormat)475 TEST_F(BluetoothAllowedDevicesTest, CorrectIdFormat) {
476 BluetoothAllowedDevices allowed_devices;
477
478 const blink::WebBluetoothDeviceId& device_id =
479 allowed_devices.AddDevice(kDeviceAddress1, empty_options_);
480
481 EXPECT_TRUE(blink::WebBluetoothDeviceId::IsValid(device_id.str()));
482 }
483
TEST_F(BluetoothAllowedDevicesTest,NoFilterServices)484 TEST_F(BluetoothAllowedDevicesTest, NoFilterServices) {
485 BluetoothAllowedDevices allowed_devices;
486
487 // Setup request.
488 blink::mojom::WebBluetoothRequestDeviceOptionsPtr options =
489 blink::mojom::WebBluetoothRequestDeviceOptions::New();
490 blink::mojom::WebBluetoothLeScanFilterPtr scan_filter =
491 blink::mojom::WebBluetoothLeScanFilter::New();
492
493 options->filters.emplace();
494 options->filters->push_back(std::move(scan_filter));
495
496 // Add to map.
497 const blink::WebBluetoothDeviceId device_id =
498 allowed_devices.AddDevice(kDeviceAddress1, options);
499
500 EXPECT_FALSE(allowed_devices.IsAllowedToAccessAtLeastOneService(device_id));
501 }
502
503 } // namespace content
504