bluetooth: Refactor how we update based on Advertising Data

components/proximity_auth/ble/bluetooth_low_energy_connection_finder_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 "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 19 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 using testing::SaveArg;
 
+using device::BluetoothDevice;
+
 namespace proximity_auth {
 namespace {
 
 const char kServiceUUID[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEEF";
 const char kOtherUUID[] = "AAAAAAAA-AAAA-AAAA-AAAA-D15EA5EBEEEF";
 
 const int kMaxNumberOfAttempts = 2;
 
 class MockBluetoothLowEnergyDeviceWhitelist
     : public BluetoothLowEnergyDeviceWhitelist {
@@ skipping 107 matching lines @@
   }
 
   void ExpectRemoveObserver() {
     EXPECT_CALL(*adapter_, RemoveObserver(_)).Times(AtLeast(1));
   }
 
   // Prepare |device_| with |uuid|.
   void PrepareDevice(const std::string& uuid,
                      const std::string& address,
                      bool paired) {
-    std::vector<device::BluetoothUUID> uuids;
-    uuids.push_back(device::BluetoothUUID(uuid));
+    BluetoothDevice::UUIDSet uuids;

[Jeffrey Yasskin, 2016/08/18 16:04:32]

I believe you can use

  BluetoothDevice::UUIDSet uuids = {device::BluetoothUUID(uuid)};

now:
https://www.chromium.org/developers/coding-style/cpp-dos-and-donts?pli=1#TOC-...

[ortuno, 2016/08/19 20:50:32]

Done.

+    uuids.insert(device::BluetoothUUID(uuid));
     ON_CALL(*device_, GetUUIDs()).WillByDefault(Return(uuids));
     ON_CALL(*device_, GetAddress()).WillByDefault(Return(address));
     ON_CALL(*device_, IsPaired()).WillByDefault(Return(paired));
   }
 
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
   ConnectionFinder::ConnectionCallback connection_callback_;
   std::unique_ptr<device::MockBluetoothDevice> device_;
   std::unique_ptr<Connection> last_found_connection_;
   std::unique_ptr<MockBluetoothLowEnergyDeviceWhitelist> device_whitelist_;
@@ skipping 52 matching lines @@
 
 // TODO(sacomoto): Remove it when ProximityAuthBleSystem is not needed anymore.
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionFinderTest,
        Find_CreatesConnectionWhenWhitelistedDeviceIsAdded) {
   StrictMock<MockBluetoothLowEnergyConnectionFinder> connection_finder(
       device_whitelist_.get(),
       BluetoothLowEnergyConnectionFinder::FIND_ANY_DEVICE);
   FindAndExpectStartDiscovery(connection_finder);
   ExpectRemoveObserver();
 
-  std::vector<device::BluetoothUUID> uuids;
+  BluetoothDevice::UUIDSet uuids;
   ON_CALL(*device_, GetUUIDs()).WillByDefault(Return(uuids));
   ON_CALL(*device_, IsPaired()).WillByDefault(Return(true));
   ON_CALL(*device_whitelist_, HasDeviceWithAddress(_))
       .WillByDefault(Return(true));
 
   connection_finder.ExpectCreateConnection();
   connection_finder.DeviceAdded(adapter_.get(), device_.get());
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionFinderTest,
@@ skipping 85 matching lines @@
   FindAndExpectStartDiscovery(connection_finder);
   ExpectRemoveObserver();
 
   // Prepare to add |device_|.
   PrepareDevice(kServiceUUID, kTestRemoteDeviceBluetoothAddress, true);
 
   // Prepare to add |other_device|.
   NiceMock<device::MockBluetoothDevice> other_device(
       adapter_.get(), 0, kTestRemoteDeviceName,
       kTestRemoteDeviceBluetoothAddress, false, false);
-  std::vector<device::BluetoothUUID> uuids;
-  uuids.push_back(device::BluetoothUUID(kServiceUUID));
+  BluetoothDevice::UUIDSet uuids;
+  uuids.insert(device::BluetoothUUID(kServiceUUID));
   ON_CALL(other_device, GetAddress())
       .WillByDefault(Return(kTestRemoteDeviceBluetoothAddress));
   ON_CALL(other_device, IsPaired()).WillByDefault(Return(true));
   ON_CALL(other_device, GetUUIDs()).WillByDefault((Return(uuids)));
 
   // Only one connection should be created.
   connection_finder.ExpectCreateConnection();
 
   // Add the devices.
   connection_finder.DeviceAdded(adapter_.get(), device_.get());
@@ skipping 126 matching lines @@
   // Completing the connection.
   base::RunLoop run_loop;
   ASSERT_FALSE(last_found_connection_);
   connection->SetStatus(Connection::IN_PROGRESS);
   connection->SetStatus(Connection::CONNECTED);
   run_loop.RunUntilIdle();
   EXPECT_TRUE(last_found_connection_);
 }
 
 }  // namespace proximity_auth