arc: bluetooth: enable use_new_wrapper_types for bluetooth.mojom

components/arc/bluetooth/arc_bluetooth_bridge.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 "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <bluetooth/bluetooth.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 134 matching lines @@
                           BluetoothGattService::GattErrorCode error_code) {
   callback.Run(mojo::ConvertTo<arc::mojom::BluetoothGattStatus>(error_code));
 }
 
 // Common success callback for ReadGattCharacteristic and ReadGattDescriptor
 void OnGattReadDone(const GattReadCallback& callback,
                     const std::vector<uint8_t>& result) {
   arc::mojom::BluetoothGattValuePtr gattValue =
       arc::mojom::BluetoothGattValue::New();
   gattValue->status = arc::mojom::BluetoothGattStatus::GATT_SUCCESS;
-  gattValue->value = mojo::Array<uint8_t>::From(result);
+  gattValue->value = result;
   callback.Run(std::move(gattValue));
 }
 
 // Common error callback for ReadGattCharacteristic and ReadGattDescriptor
 void OnGattReadError(const GattReadCallback& callback,
                      BluetoothGattService::GattErrorCode error_code) {
   arc::mojom::BluetoothGattValuePtr gattValue =
       arc::mojom::BluetoothGattValue::New();
   gattValue->status =
       mojo::ConvertTo<arc::mojom::BluetoothGattStatus>(error_code);
-  gattValue->value = nullptr;
+  gattValue->value = std::vector<uint8_t>();
   callback.Run(std::move(gattValue));
 }
 
 // Callback function for mojom::BluetoothInstance::RequestGattRead
 void OnGattServerRead(
     const BluetoothLocalGattService::Delegate::ValueCallback& success_callback,
     const BluetoothLocalGattService::Delegate::ErrorCallback& error_callback,
     arc::mojom::BluetoothGattStatus status,
-    mojo::Array<uint8_t> value) {
+    const std::vector<uint8_t>& value) {
   if (status == arc::mojom::BluetoothGattStatus::GATT_SUCCESS)
-    success_callback.Run(value.To<std::vector<uint8_t>>());
+    success_callback.Run(value);
   else
     error_callback.Run();
 }
 
 // Callback function for mojom::BluetoothInstance::RequestGattWrite
 void OnGattServerWrite(
     const base::Closure& success_callback,
     const BluetoothLocalGattService::Delegate::ErrorCallback& error_callback,
     arc::mojom::BluetoothGattStatus status) {
   if (status == arc::mojom::BluetoothGattStatus::GATT_SUCCESS)
@@ skipping 123 matching lines @@
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 void ArcBluetoothBridge::SendDevice(const BluetoothDevice* device) const {
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnDeviceFound");
   if (!bluetooth_instance)
     return;
 
-  mojo::Array<mojom::BluetoothPropertyPtr> properties =
+  std::vector<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
   bluetooth_instance->OnDeviceFound(std::move(properties));
 
 
   if (!(device->GetType() & device::BLUETOOTH_TRANSPORT_LE))
     return;
 
   base::Optional<int8_t> rssi = device->GetInquiryRSSI();
   mojom::BluetoothAddressPtr addr;
 
   // We only want to send updated advertise data to Android only when we are
   // scanning which is checked by the validity of rssi. Here are the 2 cases
   // that we don't want to send updated advertise data to Android.
   // 1) Cached found device and 2) rssi became invalid when we stop scanning.
   if (rssi.has_value()) {
     auto* btle_instance =
         arc_bridge_service()->bluetooth()->GetInstanceForMethod(
             "OnLEDeviceFound", kMinBtleVersion);
     if (!btle_instance)
       return;
-    mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
+    std::vector<mojom::BluetoothAdvertisingDataPtr> adv_data =
         GetAdvertisingData(device);
     addr = mojom::BluetoothAddress::From(device->GetAddress());
     btle_instance->OnLEDeviceFound(std::move(addr), rssi.value(),
                                    std::move(adv_data));
   }
 
   if (!device->IsConnected())
     return;
 
   addr = mojom::BluetoothAddress::From(device->GetAddress());
@@ skipping 178 matching lines @@
   service_id->is_primary = service->IsPrimary();
   service_id->id = mojom::BluetoothGattID::New();
   service_id->id->inst_id = ConvertGattIdentifierToId(service->GetIdentifier());
   service_id->id->uuid = service->GetUUID();
 
   mojom::BluetoothGattIDPtr char_id = mojom::BluetoothGattID::New();
   char_id->inst_id = ConvertGattIdentifierToId(characteristic->GetIdentifier());
   char_id->uuid = characteristic->GetUUID();
 
   btle_instance->OnGattNotify(std::move(address), std::move(service_id),
-                              std::move(char_id), true /* is_notify */,
-                              mojo::Array<uint8_t>::From(value));
+                              std::move(char_id), true /* is_notify */, value);
 }
 
 void ArcBluetoothBridge::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   // Placeholder for GATT client functionality
 }
 
 template <class LocalGattAttribute>
@@ skipping 34 matching lines @@
           "RequestGattWrite", kMinGattServerVersion);
   if (!bluetooth_instance || !IsGattOffsetValid(offset)) {
     error_callback.Run();
     return;
   }
 
   DCHECK(gatt_handle_.find(attribute->GetIdentifier()) != gatt_handle_.end());
 
   bluetooth_instance->RequestGattWrite(
       mojom::BluetoothAddress::From(device->GetAddress()),
-      gatt_handle_[attribute->GetIdentifier()], offset,
-      mojo::Array<uint8_t>::From(value),
+      gatt_handle_[attribute->GetIdentifier()], offset, value,
       base::Bind(&OnGattServerWrite, success_callback, error_callback));
 }
 
 void ArcBluetoothBridge::OnCharacteristicReadRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic,
     int offset,
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
   OnGattAttributeReadRequest(device, characteristic, offset, callback,
@@ skipping 65 matching lines @@
 }
 
 void ArcBluetoothBridge::GetAdapterProperty(mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnAdapterProperties");
   if (!bluetooth_instance)
     return;
 
-  mojo::Array<mojom::BluetoothPropertyPtr> properties =
+  std::vector<mojom::BluetoothPropertyPtr> properties =
       GetAdapterProperties(type);
 
   bluetooth_instance->OnAdapterProperties(mojom::BluetoothStatus::SUCCESS,
                                           std::move(properties));
 }
 
 void ArcBluetoothBridge::OnSetDiscoverable(bool discoverable,
                                            bool success,
                                            uint32_t timeout) {
   DCHECK(CalledOnValidThread());
@@ skipping 44 matching lines @@
 }
 
 void ArcBluetoothBridge::OnSetAdapterProperty(
     mojom::BluetoothStatus status,
     mojom::BluetoothPropertyPtr property) {
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnAdapterProperties");
   DCHECK(bluetooth_instance);
 
-  auto properties = mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0);
+  std::vector<arc::mojom::BluetoothPropertyPtr> properties;
   properties.push_back(std::move(property));
 
   bluetooth_instance->OnAdapterProperties(status, std::move(properties));
 }
 
 void ArcBluetoothBridge::SetAdapterProperty(
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
 
   if (property->is_discovery_timeout()) {
@@ skipping 37 matching lines @@
   DCHECK(bluetooth_adapter_);
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnRemoteDeviceProperties");
   if (!bluetooth_instance)
     return;
 
   std::string addr_str = remote_addr->To<std::string>();
   BluetoothDevice* device = bluetooth_adapter_->GetDevice(addr_str);
 
-  mojo::Array<mojom::BluetoothPropertyPtr> properties =
+  std::vector<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(type, device);
   mojom::BluetoothStatus status = mojom::BluetoothStatus::SUCCESS;
 
   if (!device) {
     VLOG(1) << __func__ << ": device " << addr_str << " not available";
     status = mojom::BluetoothStatus::FAIL;
   }
 
   bluetooth_instance->OnRemoteDeviceProperties(status, std::move(remote_addr),
                                                std::move(properties));
 }
 
 void ArcBluetoothBridge::SetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnRemoteDeviceProperties");
   if (!bluetooth_instance)
     return;
 
   // Unsupported. Only used by Android hidden API, BluetoothDevice.SetAlias().
   // And only Android Settings App / Android TV / NFC used that.
   bluetooth_instance->OnRemoteDeviceProperties(
       mojom::BluetoothStatus::UNSUPPORTED, std::move(remote_addr),
-      mojo::Array<mojom::BluetoothPropertyPtr>::New(0));
+      std::vector<mojom::BluetoothPropertyPtr>());
 }
 
 void ArcBluetoothBridge::GetRemoteServiceRecord(
     mojom::BluetoothAddressPtr remote_addr,
     const BluetoothUUID& uuid) {
   // TODO(smbarber): Implement GetRemoteServiceRecord
 }
 
 void ArcBluetoothBridge::GetRemoteServices(
     mojom::BluetoothAddressPtr remote_addr) {
@@ skipping 363 matching lines @@
 
 void ArcBluetoothBridge::GetGattDB(mojom::BluetoothAddressPtr remote_addr) {
   auto* bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnGetGattDB",
                                                               kMinBtleVersion);
   if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
-  mojo::Array<mojom::BluetoothGattDBElementPtr> db;
+  std::vector<mojom::BluetoothGattDBElementPtr> db;
   for (auto* service : device->GetGattServices()) {
     mojom::BluetoothGattDBElementPtr service_element = CreateGattDBElement(
         service->IsPrimary()
             ? mojom::BluetoothGattDBAttributeType::BTGATT_DB_PRIMARY_SERVICE
             : mojom::BluetoothGattDBAttributeType::BTGATT_DB_SECONDARY_SERVICE,
         service);
 
     const auto& characteristics = service->GetCharacteristics();
     if (characteristics.size() > 0) {
       const auto& descriptors = characteristics.back()->GetDescriptors();
@@ skipping 79 matching lines @@
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattValuePtr value,
     const WriteGattCharacteristicCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   DCHECK(characteristic);
   DCHECK(characteristic->GetPermissions() & kGattWritePermission);
 
   characteristic->WriteRemoteCharacteristic(
-      value->value.To<std::vector<uint8_t>>(),
-      base::Bind(&OnGattOperationDone, callback),
+      value->value, base::Bind(&OnGattOperationDone, callback),
       base::Bind(&OnGattOperationError, callback));
 }
 
 void ArcBluetoothBridge::ReadGattDescriptor(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattIDPtr desc_id,
     const ReadGattDescriptorCallback& callback) {
   BluetoothRemoteGattDescriptor* descriptor =
@@ skipping 26 matching lines @@
   // directly to the CCC Descriptor. Therefore, until we fix
   // https://crbug.com/622832, we return successfully when we encounter this.
   // TODO(http://crbug.com/622832)
   if (descriptor->GetUUID() ==
       BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid()) {
     OnGattOperationDone(callback);
     return;
   }
 
   descriptor->WriteRemoteDescriptor(
-      value->value.To<std::vector<uint8_t>>(),
-      base::Bind(&OnGattOperationDone, callback),
+      value->value, base::Bind(&OnGattOperationDone, callback),
       base::Bind(&OnGattOperationError, callback));
 }
 
 void ArcBluetoothBridge::OnGattNotifyStartDone(
     const RegisterForGattNotificationCallback& callback,
     const std::string char_string_id,
     std::unique_ptr<BluetoothGattNotifySession> notify_session) {
   DCHECK(CalledOnValidThread());
   notification_session_[char_string_id] = std::move(notify_session);
   callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
@@ skipping 209 matching lines @@
   gatt_identifier_.erase(service_handle);
   gatt_handle_.erase(service->GetIdentifier());
   service->Delete();
   OnGattOperationDone(callback);
 }
 
 void ArcBluetoothBridge::SendIndication(
     int32_t attribute_handle,
     mojom::BluetoothAddressPtr address,
     bool confirm,
-    mojo::Array<uint8_t> value,
+    const std::vector<uint8_t>& value,
     const SendIndicationCallback& callback) {}
 
 void ArcBluetoothBridge::GetSdpRecords(mojom::BluetoothAddressPtr remote_addr,
                                        const BluetoothUUID& target_uuid) {
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
 
   bluez::BluetoothDeviceBlueZ* device_bluez =
       static_cast<bluez::BluetoothDeviceBlueZ*>(device);
 
@@ skipping 228 matching lines @@
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(addr->To<std::string>());
   mojom::BluetoothBondState bond_state = mojom::BluetoothBondState::NONE;
   if (device && device->IsPaired()) {
     bond_state = mojom::BluetoothBondState::BONDED;
   }
   bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::FAIL,
                                          std::move(addr), bond_state);
 }
 
-mojo::Array<mojom::BluetoothPropertyPtr>
+std::vector<mojom::BluetoothPropertyPtr>
 ArcBluetoothBridge::GetDeviceProperties(mojom::BluetoothPropertyType type,
                                         const BluetoothDevice* device) const {
-  mojo::Array<mojom::BluetoothPropertyPtr> properties;
+  std::vector<mojom::BluetoothPropertyPtr> properties;
 
   if (!device) {
     return properties;
   }
 
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::BDNAME) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_bdname(device->GetName() ? device->GetName().value() : "");
     properties.push_back(std::move(btp));
@@ skipping 22 matching lines @@
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::TYPE_OF_DEVICE) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_device_type(device->GetType());
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::REMOTE_FRIENDLY_NAME) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_remote_friendly_name(
-        mojo::String::From(base::UTF16ToUTF8(device->GetNameForDisplay())));
+        base::UTF16ToUTF8(device->GetNameForDisplay()));
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::REMOTE_RSSI) {
     base::Optional<int8_t> rssi = device->GetInquiryRSSI();
     if (rssi.has_value()) {
       mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
       btp->set_remote_rssi(rssi.value());
       properties.push_back(std::move(btp));
     }
   }
   // TODO(smbarber): Add remote version info
 
   return properties;
 }
 
-mojo::Array<mojom::BluetoothPropertyPtr>
+std::vector<mojom::BluetoothPropertyPtr>
 ArcBluetoothBridge::GetAdapterProperties(
     mojom::BluetoothPropertyType type) const {
-  mojo::Array<mojom::BluetoothPropertyPtr> properties;
+  std::vector<mojom::BluetoothPropertyPtr> properties;
 
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::BDNAME) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     std::string name = bluetooth_adapter_->GetName();
-    btp->set_bdname(mojo::String(name));
+    btp->set_bdname(name);
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::BDADDR) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_bdaddr(
         mojom::BluetoothAddress::From(bluetooth_adapter_->GetAddress()));
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::UUIDS) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
-    btp->set_uuids(
-        mojo::Array<BluetoothUUID>::From(bluetooth_adapter_->GetUUIDs()));
+    btp->set_uuids(bluetooth_adapter_->GetUUIDs());
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::CLASS_OF_DEVICE) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     btp->set_device_class(kBluetoothComputerClass);
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::TYPE_OF_DEVICE) {
@@ skipping 11 matching lines @@
       scan_mode = mojom::BluetoothScanMode::CONNECTABLE_DISCOVERABLE;
 
     btp->set_adapter_scan_mode(scan_mode);
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::ADAPTER_BONDED_DEVICES) {
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
 
-    mojo::Array<mojom::BluetoothAddressPtr> bonded_devices =
-        mojo::Array<mojom::BluetoothAddressPtr>::New(0);
+    std::vector<mojom::BluetoothAddressPtr> bonded_devices;
 
     for (auto* device : devices) {
       if (device->IsPaired())
         continue;
 
       mojom::BluetoothAddressPtr addr =
           mojom::BluetoothAddress::From(device->GetAddress());
       bonded_devices.push_back(std::move(addr));
     }
 
@@ skipping 27 matching lines @@
     properties.push_back(std::move(btp));
   }
 
   return properties;
 }
 
 // Android support 6 types of Advertising Data which are Advertising Data Flags,
 // Local Name, Service UUIDs, Tx Power Level, Service Data, and Manufacturer
 // Data. Note that we need to use 16-bit UUID in Service Data section because
 // Android does not support 128-bit UUID there.
-mojo::Array<mojom::BluetoothAdvertisingDataPtr>
+std::vector<mojom::BluetoothAdvertisingDataPtr>
 ArcBluetoothBridge::GetAdvertisingData(const BluetoothDevice* device) const {
-  mojo::Array<mojom::BluetoothAdvertisingDataPtr> advertising_data;
+  std::vector<mojom::BluetoothAdvertisingDataPtr> advertising_data;
 
   // Advertising Data Flags
   if (device->GetAdvertisingDataFlags().has_value()) {
     mojom::BluetoothAdvertisingDataPtr flags =
         mojom::BluetoothAdvertisingData::New();
     flags->set_flags(device->GetAdvertisingDataFlags().value());
     advertising_data.push_back(std::move(flags));
   }
 
   // Local Name
   mojom::BluetoothAdvertisingDataPtr local_name =
       mojom::BluetoothAdvertisingData::New();
   local_name->set_local_name(device->GetName() ? device->GetName().value()
                                                : "");
   advertising_data.push_back(std::move(local_name));
 
   // Service UUIDs
   const BluetoothDevice::UUIDSet& uuid_set = device->GetUUIDs();
   if (uuid_set.size() > 0) {
     mojom::BluetoothAdvertisingDataPtr service_uuids =
         mojom::BluetoothAdvertisingData::New();
-    service_uuids->set_service_uuids(mojo::Array<BluetoothUUID>::From(
-        std::vector<BluetoothUUID>(uuid_set.begin(), uuid_set.end())));
+    service_uuids->set_service_uuids(
+        std::vector<BluetoothUUID>(uuid_set.begin(), uuid_set.end()));
     advertising_data.push_back(std::move(service_uuids));
   }
 
   // Tx Power Level
   if (device->GetInquiryTxPower().has_value()) {
     mojom::BluetoothAdvertisingDataPtr tx_power_level_element =
         mojom::BluetoothAdvertisingData::New();
     tx_power_level_element->set_tx_power_level(
         device->GetInquiryTxPower().value());
     advertising_data.push_back(std::move(tx_power_level_element));
   }
 
   // Service Data
   for (const BluetoothUUID& uuid : device->GetServiceDataUUIDs()) {
     mojom::BluetoothAdvertisingDataPtr service_data_element =
         mojom::BluetoothAdvertisingData::New();
     mojom::BluetoothServiceDataPtr service_data =
         mojom::BluetoothServiceData::New();
 
     // Android only supports UUID 16 bit here.
     service_data->uuid_16bit = GetUUID16(uuid);
 
     const std::vector<uint8_t>* data = device->GetServiceDataForUUID(uuid);
     DCHECK(data != nullptr);
 
-    std::vector<uint8_t> data_copy = *data;
-    service_data->data.Swap(&data_copy);
+    service_data->data = *data;
 
     service_data_element->set_service_data(std::move(service_data));
     advertising_data.push_back(std::move(service_data_element));
   }
 
   // Manufacturer Data
   if (!device->GetManufacturerData().empty()) {
     std::vector<uint8_t> manufacturer_data;
     for (const auto& pair : device->GetManufacturerData()) {
       uint16_t id = pair.first;
@@ skipping 49 matching lines @@
 void ArcBluetoothBridge::OnGetServiceRecordsDone(
     mojom::BluetoothAddressPtr remote_addr,
     const BluetoothUUID& target_uuid,
     const std::vector<bluez::BluetoothServiceRecordBlueZ>& records_bluez) {
   auto* sdp_bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnGetSdpRecords", kMinSdpSupportVersion);
   if (!sdp_bluetooth_instance)
     return;
 
-  sdp_bluetooth_instance->OnGetSdpRecords(
-      mojom::BluetoothStatus::SUCCESS, std::move(remote_addr), target_uuid,
-      mojo::Array<mojom::BluetoothSdpRecordPtr>::From(records_bluez));
+  std::vector<mojom::BluetoothSdpRecordPtr> records;
+  for (const auto& r : records_bluez)
+    records.push_back(mojom::BluetoothSdpRecord::From(r));
+
+  sdp_bluetooth_instance->OnGetSdpRecords(mojom::BluetoothStatus::SUCCESS,
+                                          std::move(remote_addr), target_uuid,
+                                          std::move(records));
 }
 
 void ArcBluetoothBridge::OnGetServiceRecordsError(
     mojom::BluetoothAddressPtr remote_addr,
     const BluetoothUUID& target_uuid,
     bluez::BluetoothServiceRecordBlueZ::ErrorCode error_code) {
   auto* sdp_bluetooth_instance =
       arc_bridge_service()->bluetooth()->GetInstanceForMethod(
           "OnGetSdpRecords", kMinSdpSupportVersion);
   if (!sdp_bluetooth_instance)
     return;
 
   mojom::BluetoothStatus status;
 
   switch (error_code) {
     case bluez::BluetoothServiceRecordBlueZ::ErrorCode::ERROR_ADAPTER_NOT_READY:
       status = mojom::BluetoothStatus::NOT_READY;
       break;
     case bluez::BluetoothServiceRecordBlueZ::ErrorCode::
         ERROR_DEVICE_DISCONNECTED:
       status = mojom::BluetoothStatus::RMT_DEV_DOWN;
       break;
     default:
       status = mojom::BluetoothStatus::FAIL;
       break;
   }
 
   sdp_bluetooth_instance->OnGetSdpRecords(
       status, std::move(remote_addr), target_uuid,
-      mojo::Array<mojom::BluetoothSdpRecordPtr>::New(0));
+      std::vector<mojom::BluetoothSdpRecordPtr>());
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc