Use new wrapper types for web_bluetooth.mojom

content/browser/bluetooth/bluetooth_blocklist_unittest.cc

 // Copyright 2016 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_blocklist.h"
 
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using device::BluetoothUUID;
 
 namespace content {
 
-namespace {
-
-base::Optional<BluetoothUUID> Canonicalize(const std::string& str) {
-  return base::make_optional(device::BluetoothUUID(str));
-}
-
-}  // namespace
-
 class BluetoothBlocklistTest : public ::testing::Test {
  public:
   BluetoothBlocklistTest() : list_(BluetoothBlocklist::Get()) {
     // Because BluetoothBlocklist is used via a singleton instance, the data
     // must be reset for each test.
     list_.ResetToDefaultValuesForTest();
   }
   BluetoothBlocklist& list_;
 };
 
@@ skipping 186 matching lines @@
   list_.Add("\r\n0009:e\n\r");
   EXPECT_EQ(++previous_list_size, list_.size());
   EXPECT_TRUE(list_.IsExcluded(BluetoothUUID("0009")));
 }
 
 TEST_F(BluetoothBlocklistTest, IsExcluded_BluetoothScanFilter_ReturnsFalse) {
   list_.Add(BluetoothUUID("eeee"), BluetoothBlocklist::Value::EXCLUDE);
   list_.Add(BluetoothUUID("ee01"), BluetoothBlocklist::Value::EXCLUDE_READS);
   list_.Add(BluetoothUUID("ee02"), BluetoothBlocklist::Value::EXCLUDE_WRITES);
   {
-    mojo::Array<blink::mojom::WebBluetoothScanFilterPtr> empty_filters;
+    std::vector<blink::mojom::WebBluetoothScanFilterPtr> empty_filters;
     EXPECT_FALSE(list_.IsExcluded(empty_filters));
   }
   {
-    mojo::Array<blink::mojom::WebBluetoothScanFilterPtr> single_empty_filter(1);
+    std::vector<blink::mojom::WebBluetoothScanFilterPtr>
+        single_filter_with_no_services(1);
+
+    single_filter_with_no_services[0] =
+        blink::mojom::WebBluetoothScanFilter::New();
+
+    EXPECT_FALSE(single_filter_with_no_services[0]->services);
+    EXPECT_FALSE(list_.IsExcluded(single_filter_with_no_services));
+  }
+  {
+    std::vector<blink::mojom::WebBluetoothScanFilterPtr> single_empty_filter(1);
 
     single_empty_filter[0] = blink::mojom::WebBluetoothScanFilter::New();
-    single_empty_filter[0]->services =
-        mojo::Array<base::Optional<BluetoothUUID>>();
+    single_empty_filter[0]->services = std::vector<BluetoothUUID>();
 
-    EXPECT_EQ(0u, single_empty_filter[0]->services.size());
+    EXPECT_EQ(0u, single_empty_filter[0]->services->size());
     EXPECT_FALSE(list_.IsExcluded(single_empty_filter));
   }
   {
-    mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>
+    std::vector<blink::mojom::WebBluetoothScanFilterPtr>
         single_non_matching_filter(1);
 
     single_non_matching_filter[0] = blink::mojom::WebBluetoothScanFilter::New();
-    single_non_matching_filter[0]->services.push_back(Canonicalize("0000"));
+    single_non_matching_filter[0]->services = std::vector<BluetoothUUID>();
+    single_non_matching_filter[0]->services->push_back(BluetoothUUID("0000"));
 
     EXPECT_FALSE(list_.IsExcluded(single_non_matching_filter));
   }
   {
-    mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>
+    std::vector<blink::mojom::WebBluetoothScanFilterPtr>
         multiple_non_matching_filters(2);
 
     multiple_non_matching_filters[0] =
         blink::mojom::WebBluetoothScanFilter::New();
-    multiple_non_matching_filters[0]->services.push_back(Canonicalize("0000"));
-    multiple_non_matching_filters[0]->services.push_back(Canonicalize("ee01"));
+    multiple_non_matching_filters[0]->services = std::vector<BluetoothUUID>();
+    multiple_non_matching_filters[0]->services->push_back(
+        BluetoothUUID("0000"));
+    multiple_non_matching_filters[0]->services->push_back(
+        BluetoothUUID("ee01"));
 
     multiple_non_matching_filters[1] =
         blink::mojom::WebBluetoothScanFilter::New();
-    multiple_non_matching_filters[1]->services.push_back(Canonicalize("ee02"));
-    multiple_non_matching_filters[1]->services.push_back(Canonicalize("0003"));
+    multiple_non_matching_filters[1]->services = std::vector<BluetoothUUID>();
+    multiple_non_matching_filters[1]->services->push_back(
+        BluetoothUUID("ee02"));
+    multiple_non_matching_filters[1]->services->push_back(
+        BluetoothUUID("0003"));
 
     EXPECT_FALSE(list_.IsExcluded(multiple_non_matching_filters));
   }
 }
 
 TEST_F(BluetoothBlocklistTest, IsExcluded_BluetoothScanFilter_ReturnsTrue) {
   list_.Add(BluetoothUUID("eeee"), BluetoothBlocklist::Value::EXCLUDE);
   {
     mojo::Array<blink::mojom::WebBluetoothScanFilterPtr> single_matching_filter(
         1);
 
     single_matching_filter[0] = blink::mojom::WebBluetoothScanFilter::New();
-    single_matching_filter[0]->services.push_back(Canonicalize("eeee"));
+    single_matching_filter[0]->services = std::vector<BluetoothUUID>();
+    single_matching_filter[0]->services->push_back(BluetoothUUID("eeee"));
 
     EXPECT_TRUE(list_.IsExcluded(single_matching_filter));
   }
   {
     mojo::Array<blink::mojom::WebBluetoothScanFilterPtr> first_matching_filter(
         2);
 
     first_matching_filter[0] = blink::mojom::WebBluetoothScanFilter::New();
-    first_matching_filter[0]->services.push_back(Canonicalize("eeee"));
-    first_matching_filter[0]->services.push_back(Canonicalize("0001"));
+    first_matching_filter[0]->services = std::vector<BluetoothUUID>();
+    first_matching_filter[0]->services->push_back(BluetoothUUID("eeee"));
+    first_matching_filter[0]->services->push_back(BluetoothUUID("0001"));
 
     first_matching_filter[1] = blink::mojom::WebBluetoothScanFilter::New();
-    first_matching_filter[1]->services.push_back(Canonicalize("0002"));
-    first_matching_filter[1]->services.push_back(Canonicalize("0003"));
+    first_matching_filter[1]->services = std::vector<BluetoothUUID>();
+    first_matching_filter[1]->services->push_back(BluetoothUUID("0002"));
+    first_matching_filter[1]->services->push_back(BluetoothUUID("0003"));
 
     EXPECT_TRUE(list_.IsExcluded(first_matching_filter));
   }
   {
     mojo::Array<blink::mojom::WebBluetoothScanFilterPtr> last_matching_filter(
         2);
 
     last_matching_filter[0] = blink::mojom::WebBluetoothScanFilter::New();
-    last_matching_filter[0]->services.push_back(Canonicalize("0001"));
-    last_matching_filter[0]->services.push_back(Canonicalize("0001"));
+    last_matching_filter[0]->services = std::vector<BluetoothUUID>();
+    last_matching_filter[0]->services->push_back(BluetoothUUID("0001"));
+    last_matching_filter[0]->services->push_back(BluetoothUUID("0001"));
 
     last_matching_filter[1] = blink::mojom::WebBluetoothScanFilter::New();
-    last_matching_filter[1]->services.push_back(Canonicalize("0002"));
-    last_matching_filter[1]->services.push_back(Canonicalize("eeee"));
+    last_matching_filter[1]->services = std::vector<BluetoothUUID>();
+    last_matching_filter[1]->services->push_back(BluetoothUUID("0002"));
+    last_matching_filter[1]->services->push_back(BluetoothUUID("eeee"));
 
     EXPECT_TRUE(list_.IsExcluded(last_matching_filter));
   }
   {
     mojo::Array<blink::mojom::WebBluetoothScanFilterPtr>
         multiple_matching_filters(2);
 
     multiple_matching_filters[0] = blink::mojom::WebBluetoothScanFilter::New();
-    multiple_matching_filters[0]->services.push_back(Canonicalize("eeee"));
-    multiple_matching_filters[0]->services.push_back(Canonicalize("eeee"));
+    multiple_matching_filters[0]->services = std::vector<BluetoothUUID>();
+    multiple_matching_filters[0]->services->push_back(BluetoothUUID("eeee"));
+    multiple_matching_filters[0]->services->push_back(BluetoothUUID("eeee"));
 
     multiple_matching_filters[1] = blink::mojom::WebBluetoothScanFilter::New();
-    multiple_matching_filters[1]->services.push_back(Canonicalize("eeee"));
-    multiple_matching_filters[1]->services.push_back(Canonicalize("eeee"));
+    multiple_matching_filters[1]->services = std::vector<BluetoothUUID>();
+    multiple_matching_filters[1]->services->push_back(BluetoothUUID("eeee"));
+    multiple_matching_filters[1]->services->push_back(BluetoothUUID("eeee"));
 
     EXPECT_TRUE(list_.IsExcluded(multiple_matching_filters));
   }
 }
 
 TEST_F(BluetoothBlocklistTest, RemoveExcludedUUIDs_NonMatching) {
   list_.Add(BluetoothUUID("eeee"), BluetoothBlocklist::Value::EXCLUDE);
   list_.Add(BluetoothUUID("ee01"), BluetoothBlocklist::Value::EXCLUDE_READS);
   list_.Add(BluetoothUUID("ee02"), BluetoothBlocklist::Value::EXCLUDE_WRITES);
 
   // options.optional_services should be the same before and after
   // RemoveExcludedUUIDs().
   {
     // Empty optional_services.
     blink::mojom::WebBluetoothRequestDeviceOptions options;
-    options.optional_services = mojo::Array<base::Optional<BluetoothUUID>>();
 
-    mojo::Array<base::Optional<BluetoothUUID>> expected =
-        options.optional_services.Clone();
+    std::vector<BluetoothUUID> expected = options.optional_services;
 
     list_.RemoveExcludedUUIDs(&options);
-    EXPECT_TRUE(options.optional_services.Equals(expected));
+    EXPECT_EQ(expected, options.optional_services);
   }
   {
     // One non-matching service in optional_services.
     blink::mojom::WebBluetoothRequestDeviceOptions options;
-    options.optional_services.push_back(Canonicalize("0000"));
+    options.optional_services.push_back(BluetoothUUID("0000"));
 
-    mojo::Array<base::Optional<BluetoothUUID>> expected =
-        options.optional_services.Clone();
+    std::vector<BluetoothUUID> expected = options.optional_services;
 
     list_.RemoveExcludedUUIDs(&options);
-    EXPECT_TRUE(options.optional_services.Equals(expected));
+    EXPECT_EQ(expected, options.optional_services);
   }
   {
     // Multiple non-matching services in optional_services.
     blink::mojom::WebBluetoothRequestDeviceOptions options;
-    options.optional_services.push_back(Canonicalize("0000"));
-    options.optional_services.push_back(Canonicalize("ee01"));
-    options.optional_services.push_back(Canonicalize("ee02"));
-    options.optional_services.push_back(Canonicalize("0003"));
+    options.optional_services.push_back(BluetoothUUID("0000"));
+    options.optional_services.push_back(BluetoothUUID("ee01"));
+    options.optional_services.push_back(BluetoothUUID("ee02"));
+    options.optional_services.push_back(BluetoothUUID("0003"));
 
-    mojo::Array<base::Optional<BluetoothUUID>> expected =
-        options.optional_services.Clone();
+    std::vector<BluetoothUUID> expected = options.optional_services;
 
     list_.RemoveExcludedUUIDs(&options);
-    EXPECT_TRUE(options.optional_services.Equals(expected));
+    EXPECT_EQ(expected, options.optional_services);
   }
 }
 
 TEST_F(BluetoothBlocklistTest, RemoveExcludedUuids_Matching) {
   list_.Add(BluetoothUUID("eeee"), BluetoothBlocklist::Value::EXCLUDE);
   list_.Add(BluetoothUUID("eee2"), BluetoothBlocklist::Value::EXCLUDE);
   list_.Add(BluetoothUUID("eee3"), BluetoothBlocklist::Value::EXCLUDE);
   list_.Add(BluetoothUUID("eee4"), BluetoothBlocklist::Value::EXCLUDE);
   {
     // Single matching service in optional_services.
     blink::mojom::WebBluetoothRequestDeviceOptions options;
-    options.optional_services.push_back(Canonicalize("eeee"));
+    options.optional_services.push_back(BluetoothUUID("eeee"));
 
-    mojo::Array<base::Optional<BluetoothUUID>> expected;
+    std::vector<BluetoothUUID> expected;
 
     list_.RemoveExcludedUUIDs(&options);
 
-    EXPECT_TRUE(options.optional_services.Equals(expected));
+    EXPECT_EQ(expected, options.optional_services);
   }
   {
     // Single matching of many services in optional_services.
     blink::mojom::WebBluetoothRequestDeviceOptions options;
-    options.optional_services.push_back(Canonicalize("0000"));
-    options.optional_services.push_back(Canonicalize("eeee"));
-    options.optional_services.push_back(Canonicalize("0001"));
+    options.optional_services.push_back(BluetoothUUID("0000"));
+    options.optional_services.push_back(BluetoothUUID("eeee"));
+    options.optional_services.push_back(BluetoothUUID("0001"));
 
-    mojo::Array<base::Optional<BluetoothUUID>> expected;
-    expected.push_back(Canonicalize("0000"));
-    expected.push_back(Canonicalize("0001"));
+    std::vector<BluetoothUUID> expected;
+    expected.push_back(BluetoothUUID("0000"));
+    expected.push_back(BluetoothUUID("0001"));
 
     list_.RemoveExcludedUUIDs(&options);
-    EXPECT_TRUE(options.optional_services.Equals(expected));
+    EXPECT_EQ(expected, options.optional_services);
   }
   {
     // All matching of many services in optional_services.
     blink::mojom::WebBluetoothRequestDeviceOptions options;
-    options.optional_services.push_back(Canonicalize("eee2"));
-    options.optional_services.push_back(Canonicalize("eee4"));
-    options.optional_services.push_back(Canonicalize("eee3"));
-    options.optional_services.push_back(Canonicalize("eeee"));
+    options.optional_services.push_back(BluetoothUUID("eee2"));
+    options.optional_services.push_back(BluetoothUUID("eee4"));
+    options.optional_services.push_back(BluetoothUUID("eee3"));
+    options.optional_services.push_back(BluetoothUUID("eeee"));
 
-    mojo::Array<base::Optional<BluetoothUUID>> expected;
+    std::vector<BluetoothUUID> expected;
 
     list_.RemoveExcludedUUIDs(&options);
-    EXPECT_TRUE(options.optional_services.Equals(expected));
+    EXPECT_EQ(expected, options.optional_services);
   }
 }
 
 TEST_F(BluetoothBlocklistTest, VerifyDefaultBlocklistSize) {
   // REMINDER: ADD new blocklist items to tests below for each exclusion type.
   EXPECT_EQ(13u, list_.size());
 }
 
 TEST_F(BluetoothBlocklistTest, VerifyDefaultExcludeList) {
   EXPECT_FALSE(list_.IsExcluded(BluetoothUUID("1800")));
@@ skipping 58 matching lines @@
       BluetoothUUID("bad1c9a2-9a5b-4015-8b60-1579bbbf2135")));
   EXPECT_TRUE(list_.IsExcludedFromWrites(BluetoothUUID("2902")));
   EXPECT_TRUE(list_.IsExcludedFromWrites(BluetoothUUID("2903")));
   EXPECT_TRUE(list_.IsExcludedFromWrites(
       BluetoothUUID("bad2ddcf-60db-45cd-bef9-fd72b153cf7c")));
   EXPECT_FALSE(list_.IsExcludedFromWrites(
       BluetoothUUID("bad3ec61-3cc3-4954-9702-7977df514114")));
 }
 
 }  // namespace content