Allow device/bluetooth to build on the macOS 10.13 SDK

device/bluetooth/bluetooth_adapter_mac_unittest.mm

 // Copyright 2013 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 "device/bluetooth/bluetooth_adapter_mac.h"
 
+#import <Foundation/Foundation.h>
+
 #include <memory>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/test_simple_task_runner.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
-#include "device/bluetooth/bluetooth_low_energy_device_mac.h"
-#include "device/bluetooth/test/mock_bluetooth_cbperipheral_mac.h"
-#include "device/bluetooth/test/mock_bluetooth_central_manager_mac.h"
+#import "device/bluetooth/bluetooth_low_energy_device_mac.h"
+#import "device/bluetooth/test/mock_bluetooth_cbperipheral_mac.h"
+#import "device/bluetooth/test/mock_bluetooth_central_manager_mac.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/ocmock/OCMock/OCMock.h"
+#import "third_party/ocmock/OCMock/OCMock.h"
 
 #if defined(OS_IOS)
 #import <CoreBluetooth/CoreBluetooth.h>
 #else  // !defined(OS_IOS)
 #import <IOBluetooth/IOBluetooth.h>
 #endif  // defined(OS_IOS)
 
-#import <Foundation/Foundation.h>
-
 namespace {
 // |kTestHashAddress| is the hash corresponding to identifier |kTestNSUUID|.
 const char* const kTestNSUUID = "00000000-1111-2222-3333-444444444444";
 const std::string kTestHashAddress = "D1:6F:E3:22:FD:5B";
 const int kTestRssi = 0;
 }  // namespace
 
 namespace device {
 
 class BluetoothAdapterMacTest : public testing::Test {
@@ skipping 43 matching lines @@
   }
 
   int NumDevices() { return adapter_mac_->devices_.size(); }
 
   bool DevicePresent(CBPeripheral* peripheral) {
     BluetoothDevice* device = adapter_mac_->GetDevice(
         BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral));
     return (device != NULL);
   }
 
-  bool SetMockCentralManager(CBCentralManagerState desired_state) {
+  bool SetMockCentralManager(CBManagerState desired_state) {
     if (!BluetoothAdapterMac::IsLowEnergyAvailable()) {
       LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
       return false;
     }
     mock_central_manager_.reset([[MockCentralManager alloc] init]);
     [mock_central_manager_ setState:desired_state];
     CBCentralManager* centralManager =
         static_cast<CBCentralManager*>(mock_central_manager_.get());
     adapter_mac_->SetCentralManagerForTesting(centralManager);
     return true;
@@ skipping 35 matching lines @@
   int callback_count_;
   int error_callback_count_;
 };
 
 TEST_F(BluetoothAdapterMacTest, Poll) {
   PollAdapter();
   EXPECT_TRUE(ui_task_runner_->HasPendingTask());
 }
 
 TEST_F(BluetoothAdapterMacTest, AddDiscoverySessionWithLowEnergyFilter) {
-  if (!SetMockCentralManager(CBCentralManagerStatePoweredOn))
+  if (!SetMockCentralManager(CBManagerStatePoweredOn))
     return;
   EXPECT_EQ(0, [mock_central_manager_ scanForPeripheralsCallCount]);
   EXPECT_EQ(0, NumDiscoverySessions());
 
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(
       new BluetoothDiscoveryFilter(BLUETOOTH_TRANSPORT_LE));
   AddDiscoverySession(discovery_filter.get());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, NumDiscoverySessions());
 
   // Check that adding a discovery session resulted in
   // scanForPeripheralsWithServices being called on the Central Manager.
   EXPECT_EQ(1, [mock_central_manager_ scanForPeripheralsCallCount]);
 }
 
 // TODO(krstnmnlsn): Test changing the filter when adding the second discovery
 // session (once we have that ability).
 TEST_F(BluetoothAdapterMacTest, AddSecondDiscoverySessionWithLowEnergyFilter) {
-  if (!SetMockCentralManager(CBCentralManagerStatePoweredOn))
+  if (!SetMockCentralManager(CBManagerStatePoweredOn))
     return;
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(
       new BluetoothDiscoveryFilter(BLUETOOTH_TRANSPORT_LE));
   AddDiscoverySession(discovery_filter.get());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, NumDiscoverySessions());
 
   // We replaced the success callback handed to AddDiscoverySession, so
   // |adapter_mac_| should remain in a discovering state indefinitely.
   EXPECT_TRUE(adapter_mac_->IsDiscovering());
 
   AddDiscoverySession(discovery_filter.get());
   EXPECT_EQ(2, [mock_central_manager_ scanForPeripheralsCallCount]);
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(2, NumDiscoverySessions());
 }
 
 TEST_F(BluetoothAdapterMacTest, RemoveDiscoverySessionWithLowEnergyFilter) {
-  if (!SetMockCentralManager(CBCentralManagerStatePoweredOn))
+  if (!SetMockCentralManager(CBManagerStatePoweredOn))
     return;
   EXPECT_EQ(0, [mock_central_manager_ scanForPeripheralsCallCount]);
 
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(
       new BluetoothDiscoveryFilter(BLUETOOTH_TRANSPORT_LE));
   AddDiscoverySession(discovery_filter.get());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, NumDiscoverySessions());
 
   EXPECT_EQ(0, [mock_central_manager_ stopScanCallCount]);
   RemoveDiscoverySession(discovery_filter.get());
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(0, NumDiscoverySessions());
 
   // Check that removing the discovery session resulted in stopScan being called
   // on the Central Manager.
   EXPECT_EQ(1, [mock_central_manager_ stopScanCallCount]);
 }
 
 TEST_F(BluetoothAdapterMacTest, RemoveDiscoverySessionWithLowEnergyFilterFail) {
-  if (!SetMockCentralManager(CBCentralManagerStatePoweredOn))
+  if (!SetMockCentralManager(CBManagerStatePoweredOn))
     return;
   EXPECT_EQ(0, [mock_central_manager_ scanForPeripheralsCallCount]);
   EXPECT_EQ(0, [mock_central_manager_ stopScanCallCount]);
   EXPECT_EQ(0, NumDiscoverySessions());
 
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(
       new BluetoothDiscoveryFilter(BLUETOOTH_TRANSPORT_LE));
   RemoveDiscoverySession(discovery_filter.get());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(0, NumDiscoverySessions());
 
   // Check that stopScan was not called.
   EXPECT_EQ(0, [mock_central_manager_ stopScanCallCount]);
 }
 
 TEST_F(BluetoothAdapterMacTest, CheckGetPeripheralHashAddress) {
-  if (!SetMockCentralManager(CBCentralManagerStatePoweredOn))
+  if (!SetMockCentralManager(CBManagerStatePoweredOn))
     return;
   base::scoped_nsobject<CBPeripheral> mock_peripheral(
       CreateMockPeripheral(kTestNSUUID));
   if (!mock_peripheral)
     return;
   EXPECT_EQ(kTestHashAddress, GetHashAddress(mock_peripheral));
 }
 
 TEST_F(BluetoothAdapterMacTest, LowEnergyDeviceUpdatedNewDevice) {
-  if (!SetMockCentralManager(CBCentralManagerStatePoweredOn))
+  if (!SetMockCentralManager(CBManagerStatePoweredOn))
     return;
   base::scoped_nsobject<CBPeripheral> mock_peripheral(
       CreateMockPeripheral(kTestNSUUID));
   if (!mock_peripheral)
     return;
   base::scoped_nsobject<NSDictionary> advertisement_data(AdvertisementData());
 
   EXPECT_EQ(0, NumDevices());
   EXPECT_FALSE(DevicePresent(mock_peripheral));
   LowEnergyDeviceUpdated(mock_peripheral, advertisement_data, kTestRssi);
   EXPECT_EQ(1, NumDevices());
   EXPECT_TRUE(DevicePresent(mock_peripheral));
 }
 
 }  // namespace device