bluetooth: Use WebBluetoothDeviceId instead of string

content/browser/bluetooth/bluetooth_allowed_devices_map_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/bluetooth/bluetooth_allowed_devices_map.h"
 
 #include "base/strings/string_util.h"
+#include "content/common/bluetooth/bluetooth_device_id.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using device::BluetoothUUID;
 
 namespace content {
 namespace {
 const url::Origin kTestOrigin1(GURL("https://www.example1.com"));
 const url::Origin kTestOrigin2(GURL("https://www.example2.com"));
 
@@ skipping 28 matching lines @@
   BluetoothAllowedDevicesMap allowed_devices_map;
 
   EXPECT_DEATH_IF_SUPPORTED(allowed_devices_map.AddDevice(
                                 url::Origin(), kDeviceAddress1, empty_options_),
                             "");
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AddDeviceToMap) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
-  const std::string& device_id = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
 
   // Test that we can retrieve the device address/id.
-  EXPECT_EQ(device_id,
-            allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1));
+  EXPECT_EQ(
+      device_id,
+      allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1).value());
   EXPECT_EQ(kDeviceAddress1,
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AddDeviceToMapTwice) {
   BluetoothAllowedDevicesMap allowed_devices_map;
-  const std::string& device_id1 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id1 = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
-  const std::string& device_id2 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id2 = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
 
   EXPECT_EQ(device_id1, device_id2);
 
   // Test that we can retrieve the device address/id.
-  EXPECT_EQ(device_id1,
-            allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1));
+  EXPECT_EQ(
+      device_id1,
+      allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1).value());
   EXPECT_EQ(kDeviceAddress1,
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id1));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AddTwoDevicesFromSameOriginToMap) {
   BluetoothAllowedDevicesMap allowed_devices_map;
-  const std::string& device_id1 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id1 = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
-  const std::string& device_id2 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id2 = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress2, empty_options_);
 
   EXPECT_NE(device_id1, device_id2);
 
   // Test that we can retrieve the device address/id.
-  EXPECT_EQ(device_id1,
-            allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1));
-  EXPECT_EQ(device_id2,
-            allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress2));
+  EXPECT_EQ(
+      device_id1,
+      allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1).value());
+  EXPECT_EQ(
+      device_id2,
+      allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress2).value());
 
   EXPECT_EQ(kDeviceAddress1,
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id1));
   EXPECT_EQ(kDeviceAddress2,
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id2));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AddTwoDevicesFromTwoOriginsToMap) {
   BluetoothAllowedDevicesMap allowed_devices_map;
-  const std::string& device_id1 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id1 = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
-  const std::string& device_id2 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id2 = allowed_devices_map.AddDevice(
       kTestOrigin2, kDeviceAddress2, empty_options_);
 
   EXPECT_NE(device_id1, device_id2);
 
   // Test that the wrong origin doesn't have access to the device.
 
-  EXPECT_EQ(base::EmptyString(),
-            allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress2));
-  EXPECT_EQ(base::EmptyString(),
-            allowed_devices_map.GetDeviceId(kTestOrigin2, kDeviceAddress1));
+  EXPECT_FALSE(allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress2));
+  EXPECT_FALSE(allowed_devices_map.GetDeviceId(kTestOrigin2, kDeviceAddress1));
 
   EXPECT_EQ(base::EmptyString(),
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id2));
   EXPECT_EQ(base::EmptyString(),
             allowed_devices_map.GetDeviceAddress(kTestOrigin2, device_id1));
 
   // Test that we can retrieve the device address/id.
-  EXPECT_EQ(device_id1,
-            allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1));
-  EXPECT_EQ(device_id2,
-            allowed_devices_map.GetDeviceId(kTestOrigin2, kDeviceAddress2));
+  EXPECT_EQ(
+      device_id1,
+      allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1).value());
+  EXPECT_EQ(
+      device_id2,
+      allowed_devices_map.GetDeviceId(kTestOrigin2, kDeviceAddress2).value());
 
   EXPECT_EQ(kDeviceAddress1,
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id1));
   EXPECT_EQ(kDeviceAddress2,
             allowed_devices_map.GetDeviceAddress(kTestOrigin2, device_id2));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AddDeviceFromTwoOriginsToMap) {
   BluetoothAllowedDevicesMap allowed_devices_map;
-  const std::string& device_id1 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id1 = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
-  const std::string& device_id2 = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id2 = allowed_devices_map.AddDevice(
       kTestOrigin2, kDeviceAddress1, empty_options_);
 
   EXPECT_NE(device_id1, device_id2);
 
   // Test that the wrong origin doesn't have access to the device.
   EXPECT_EQ(base::EmptyString(),
             allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id2));
   EXPECT_EQ(base::EmptyString(),
             allowed_devices_map.GetDeviceAddress(kTestOrigin2, device_id1));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AddRemoveAddDeviceToMap) {
   BluetoothAllowedDevicesMap allowed_devices_map;
-  const std::string device_id_first_time = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId device_id_first_time = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
 
   allowed_devices_map.RemoveDevice(kTestOrigin1, kDeviceAddress1);
 
-  const std::string device_id_second_time = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId device_id_second_time = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
 
   EXPECT_NE(device_id_first_time, device_id_second_time);
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, RemoveDeviceFromMap) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
-  const std::string& device_id = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId device_id = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
 
   allowed_devices_map.RemoveDevice(kTestOrigin1, kDeviceAddress1);
 
+  EXPECT_FALSE(allowed_devices_map.GetDeviceId(kTestOrigin1, kDeviceAddress1));
   EXPECT_EQ(base::EmptyString(),
-            allowed_devices_map.GetDeviceId(kTestOrigin1, device_id));
-  EXPECT_EQ(base::EmptyString(), allowed_devices_map.GetDeviceAddress(
-                                     kTestOrigin1, kDeviceAddress1));
+            allowed_devices_map.GetDeviceAddress(kTestOrigin1, device_id));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AllowedServices_OneOriginOneDevice) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
   // Setup device.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter1 =
       blink::mojom::WebBluetoothScanFilter::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
 
   scanFilter1->services.push_back(kGlucoseUUID);
   options->filters.push_back(scanFilter1.Clone());
 
   scanFilter2->services.push_back(kHeartRateUUID);
   options->filters.push_back(scanFilter2.Clone());
 
   options->optional_services.push_back(kBatteryServiceUUID);
   options->optional_services.push_back(kHeartRateUUID);
 
   // Add to map.
-  const std::string device_id1 =
+  const BluetoothDeviceId device_id1 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options);
 
   // Access allowed services.
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kGlucoseUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kHeartRateUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kBatteryServiceUUID));
 
@@ skipping 11 matching lines @@
   EXPECT_FALSE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kBatteryServiceUUID));
 
   // Add device back.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
 
   options2->filters.push_back(scanFilter1.Clone());
   options2->filters.push_back(scanFilter2.Clone());
 
-  const std::string device_id2 =
+  const BluetoothDeviceId device_id2 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options2);
 
   // Access allowed services.
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id2, kGlucoseUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id2, kHeartRateUUID));
 
   // Try to access a non-allowed service.
   EXPECT_FALSE(allowed_devices_map.IsOriginAllowedToAccessService(
@@ skipping 27 matching lines @@
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
 
   scanFilter2->services.push_back(kBatteryServiceUUID);
   options2->filters.push_back(std::move(scanFilter2));
 
   options2->optional_services.push_back(kBloodPressureUUID);
 
   // Add devices to map.
-  const std::string& device_id1 =
+  const BluetoothDeviceId& device_id1 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options1);
-  const std::string& device_id2 =
+  const BluetoothDeviceId& device_id2 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress2, options2);
 
   // Access allowed services.
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kGlucoseUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kHeartRateUUID));
 
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id2, kBatteryServiceUUID));
@@ skipping 34 matching lines @@
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
 
   scanFilter2->services.push_back(kBatteryServiceUUID);
   options2->filters.push_back(std::move(scanFilter2));
 
   options2->optional_services.push_back(kBloodPressureUUID);
 
   // Add devices to map.
-  const std::string& device_id1 =
+  const BluetoothDeviceId& device_id1 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options1);
-  const std::string& device_id2 =
+  const BluetoothDeviceId& device_id2 =
       allowed_devices_map.AddDevice(kTestOrigin2, kDeviceAddress1, options2);
 
   // Access allowed services.
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kGlucoseUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kHeartRateUUID));
 
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin2, device_id2, kBatteryServiceUUID));
@@ skipping 38 matching lines @@
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter1 =
       blink::mojom::WebBluetoothScanFilter::New();
 
   scanFilter1->services.push_back(kGlucoseUUID);
   options1->filters.push_back(std::move(scanFilter1));
 
   options1->optional_services.push_back(kBatteryServiceUUID);
 
   // Add to map.
-  const std::string device_id1 =
+  const BluetoothDeviceId device_id1 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options1);
 
   // Setup second request.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
 
   scanFilter2->services.push_back(kHeartRateUUID);
   options2->filters.push_back(std::move(scanFilter2));
 
   options2->optional_services.push_back(kBloodPressureUUID);
 
   // Add to map again.
-  const std::string device_id2 =
+  const BluetoothDeviceId device_id2 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options2);
 
   EXPECT_EQ(device_id1, device_id2);
 
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kGlucoseUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kBatteryServiceUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kHeartRateUUID));
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kBloodPressureUUID));
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, CorrectIdFormat) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
-  const std::string& device_id = allowed_devices_map.AddDevice(
+  const BluetoothDeviceId& device_id = allowed_devices_map.AddDevice(
       kTestOrigin1, kDeviceAddress1, empty_options_);
 
-  EXPECT_TRUE(device_id.size() == 24)
-      << "Expected Lenghth of a 128bit string encoded to Base64.";
-  EXPECT_TRUE((device_id[22] == '=') && (device_id[23] == '='))
-      << "Expected padding characters for a 128bit string encoded to Base64.";
+  EXPECT_TRUE(BluetoothDeviceId::IsValid(device_id.str()));
 }
 
 }  // namespace content