bluetooth: Use BluetoothUUID instead of string when sending uuids

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 "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"));
 
 const std::string kDeviceAddress1 = "00:00:00";
 const std::string kDeviceAddress2 = "11:11:11";
 
-const char kGlucoseUUID[] = "00001808-0000-1000-8000-00805f9b34fb";
-const char kHeartRateUUID[] = "0000180d-0000-1000-8000-00805f9b34fb";
-const char kBatteryServiceUUID[] = "0000180f-0000-1000-8000-00805f9b34fb";
-const char kBloodPressureUUID[] = "00001813-0000-1000-8000-00805f9b34fb";
-const char kCyclingPowerUUID[] = "00001818-0000-1000-8000-00805f9b34fb";
+const char kGlucoseUUIDString[] = "00001808-0000-1000-8000-00805f9b34fb";
+const char kHeartRateUUIDString[] = "0000180d-0000-1000-8000-00805f9b34fb";
+const char kBatteryServiceUUIDString[] = "0000180f-0000-1000-8000-00805f9b34fb";
+const char kBloodPressureUUIDString[] = "00001813-0000-1000-8000-00805f9b34fb";
+const char kCyclingPowerUUIDString[] = "00001818-0000-1000-8000-00805f9b34fb";
+const BluetoothUUID kGlucoseUUID(kGlucoseUUIDString);

[Jeffrey Yasskin, 2016/05/28 04:38:06]

Didn't we just get rid of these? ;-)

[ortuno, 2016/05/31 17:30:47]

We did! But turns out we needed them hehe

+const BluetoothUUID kHeartRateUUID(kHeartRateUUIDString);
+const BluetoothUUID kBatteryServiceUUID(kBatteryServiceUUIDString);
+const BluetoothUUID kBloodPressureUUID(kBloodPressureUUIDString);
+const BluetoothUUID kCyclingPowerUUID(kCyclingPowerUUIDString);
 
 class BluetoothAllowedDevicesMapTest : public testing::Test {
  protected:
   BluetoothAllowedDevicesMapTest() {
     empty_options_ = blink::mojom::WebBluetoothRequestDeviceOptions::New();
   }
 
   ~BluetoothAllowedDevicesMapTest() override {}
 
+  std::unique_ptr<BluetoothUUID> GetGlucoseUUID() {

[Jeffrey Yasskin, 2016/05/28 04:38:06]

Maybe "GetGlucoseUUIDPtr()" to be clear how this is different from kGlucoseUUID.

[ortuno, 2016/05/31 17:30:47]

Since these now return an Optional, I changed them to ...UUIDOpt.

+    return base::WrapUnique(new BluetoothUUID(kGlucoseUUID));

[Jeffrey Yasskin, 2016/05/28 04:38:06]

We have base::MakeUnique<BluetoothUUID>(kGlucoseUUID) now. Try to switch to that
everywhere.

[ortuno, 2016/05/31 17:30:47]

No longer needed.

+  }
+  std::unique_ptr<BluetoothUUID> GetHeartRateUUID() {
+    return base::WrapUnique(new BluetoothUUID(kHeartRateUUID));
+  }
+  std::unique_ptr<BluetoothUUID> GetBatteryServiceUUID() {
+    return base::WrapUnique(new BluetoothUUID(kBatteryServiceUUID));
+  }
+  std::unique_ptr<BluetoothUUID> GetBloodPressureUUID() {
+    return base::WrapUnique(new BluetoothUUID(kBloodPressureUUID));
+  }
+  std::unique_ptr<BluetoothUUID> GetCyclingPowerUUID() {
+    return base::WrapUnique(new BluetoothUUID(kCyclingPowerUUID));
+  }
+
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr empty_options_;
 };
 
 }  // namespace
 
 TEST_F(BluetoothAllowedDevicesMapTest, UniqueOriginNotSupported) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
   EXPECT_DEATH_IF_SUPPORTED(allowed_devices_map.AddDevice(
                                 url::Origin(), kDeviceAddress1, empty_options_),
@@ skipping 125 matching lines @@
   EXPECT_EQ(base::EmptyString(), allowed_devices_map.GetDeviceAddress(
                                      kTestOrigin1, kDeviceAddress1));
 }
 
 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 scanFilter1Clone =
+      blink::mojom::WebBluetoothScanFilter::New();
+
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
+  blink::mojom::WebBluetoothScanFilterPtr scanFilter2Clone =
+      blink::mojom::WebBluetoothScanFilter::New();
 
-  scanFilter1->services.push_back(kGlucoseUUID);
-  options->filters.push_back(scanFilter1.Clone());
+  scanFilter1->services.push_back(GetGlucoseUUID());
+  scanFilter1Clone->services.push_back(GetGlucoseUUID());

[Jeffrey Yasskin, 2016/05/28 04:38:06]

The fact that we can't clone messages with unique_ptrs is also sad. Using
base::Optional would fix this, and I think WTF::Optional's definition means
it'll be fine to use that in blink too.

[ortuno, 2016/05/31 17:30:47]

Done. FWIW once we Onion-Soup Web Bluetooth, blink will not pass a Optional or a
BluetoothUUID it will just pass a WTF::String.

 
-  scanFilter2->services.push_back(kHeartRateUUID);
-  options->filters.push_back(scanFilter2.Clone());
+  scanFilter2->services.push_back(GetHeartRateUUID());
+  scanFilter2Clone->services.push_back(GetHeartRateUUID());
 
-  options->optional_services.push_back(kBatteryServiceUUID);
-  options->optional_services.push_back(kHeartRateUUID);
+  options->filters.push_back(std::move(scanFilter1));
+  options->filters.push_back(std::move(scanFilter2));
+  options->optional_services.push_back(GetBatteryServiceUUID());
+  options->optional_services.push_back(GetHeartRateUUID());
 
   // Add to map.
   const std::string 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));
@@ skipping 11 matching lines @@
       kTestOrigin1, device_id1, kGlucoseUUID));
   EXPECT_FALSE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kHeartRateUUID));
   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());
+  options2->filters.push_back(std::move(scanFilter1Clone));
+  options2->filters.push_back(std::move(scanFilter2Clone));
 
   const std::string 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));
 
@@ skipping 12 matching lines @@
 
 TEST_F(BluetoothAllowedDevicesMapTest, AllowedServices_OneOriginTwoDevices) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
   // Setup request for device #1.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options1 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter1 =
       blink::mojom::WebBluetoothScanFilter::New();
 
-  scanFilter1->services.push_back(kGlucoseUUID);
+  scanFilter1->services.push_back(GetGlucoseUUID());
   options1->filters.push_back(std::move(scanFilter1));
 
-  options1->optional_services.push_back(kHeartRateUUID);
+  options1->optional_services.push_back(GetHeartRateUUID());
 
   // Setup request for device #2.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
 
-  scanFilter2->services.push_back(kBatteryServiceUUID);
+  scanFilter2->services.push_back(GetBatteryServiceUUID());
   options2->filters.push_back(std::move(scanFilter2));
 
-  options2->optional_services.push_back(kBloodPressureUUID);
+  options2->optional_services.push_back(GetBloodPressureUUID());
 
   // Add devices to map.
   const std::string& device_id1 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options1);
   const std::string& device_id2 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress2, options2);
 
   // Access allowed services.
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kGlucoseUUID));
@@ skipping 22 matching lines @@
 }
 
 TEST_F(BluetoothAllowedDevicesMapTest, AllowedServices_TwoOriginsOneDevice) {
   BluetoothAllowedDevicesMap allowed_devices_map;
   // Setup request #1 for device.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options1 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter1 =
       blink::mojom::WebBluetoothScanFilter::New();
 
-  scanFilter1->services.push_back(kGlucoseUUID);
+  scanFilter1->services.push_back(GetGlucoseUUID());
   options1->filters.push_back(std::move(scanFilter1));
 
-  options1->optional_services.push_back(kHeartRateUUID);
+  options1->optional_services.push_back(GetHeartRateUUID());
 
   // Setup request #2 for device.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options2 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter2 =
       blink::mojom::WebBluetoothScanFilter::New();
 
-  scanFilter2->services.push_back(kBatteryServiceUUID);
+  scanFilter2->services.push_back(GetBatteryServiceUUID());
   options2->filters.push_back(std::move(scanFilter2));
 
-  options2->optional_services.push_back(kBloodPressureUUID);
+  options2->optional_services.push_back(GetBloodPressureUUID());
 
   // Add devices to map.
   const std::string& device_id1 =
       allowed_devices_map.AddDevice(kTestOrigin1, kDeviceAddress1, options1);
   const std::string& device_id2 =
       allowed_devices_map.AddDevice(kTestOrigin2, kDeviceAddress1, options2);
 
   // Access allowed services.
   EXPECT_TRUE(allowed_devices_map.IsOriginAllowedToAccessService(
       kTestOrigin1, device_id1, kGlucoseUUID));
@@ skipping 37 matching lines @@
 
 TEST_F(BluetoothAllowedDevicesMapTest, MergeServices) {
   BluetoothAllowedDevicesMap allowed_devices_map;
 
   // Setup first request.
   blink::mojom::WebBluetoothRequestDeviceOptionsPtr options1 =
       blink::mojom::WebBluetoothRequestDeviceOptions::New();
   blink::mojom::WebBluetoothScanFilterPtr scanFilter1 =
       blink::mojom::WebBluetoothScanFilter::New();
 
-  scanFilter1->services.push_back(kGlucoseUUID);
+  scanFilter1->services.push_back(GetGlucoseUUID());
   options1->filters.push_back(std::move(scanFilter1));
 
-  options1->optional_services.push_back(kBatteryServiceUUID);
+  options1->optional_services.push_back(GetBatteryServiceUUID());
 
   // Add to map.
   const std::string 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);
+  scanFilter2->services.push_back(GetHeartRateUUID());
   options2->filters.push_back(std::move(scanFilter2));
 
-  options2->optional_services.push_back(kBloodPressureUUID);
+  options2->optional_services.push_back(GetBloodPressureUUID());
 
   // Add to map again.
   const std::string 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(
@@ skipping 10 matching lines @@
   const std::string& 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.";
 }
 
 }  // namespace content