arc: Use GET_INTERFACE_FOR_METHOD macro

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 36 matching lines @@
 using device::BluetoothLocalGattCharacteristic;
 using device::BluetoothLocalGattDescriptor;
 using device::BluetoothLocalGattService;
 using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothRemoteGattDescriptor;
 using device::BluetoothRemoteGattService;
 using device::BluetoothTransport;
 using device::BluetoothUUID;
 
 namespace {
-constexpr uint32_t kMinBtleVersion = 1;
-constexpr uint32_t kMinBtleNotifyVersion = 2;
-constexpr uint32_t kMinGattServerVersion = 3;
-constexpr uint32_t kMinAddrChangeVersion = 4;
-constexpr uint32_t kMinSdpSupportVersion = 5;
 constexpr uint32_t kGattReadPermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
 constexpr uint32_t kGattWritePermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE |
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
@@ skipping 216 matching lines @@
   // register ourselves as an observer with it then. Since our adapter is
   // ready, we should register it now.
   if (!bluetooth_adapter_->HasObserver(this) &&
       arc_bridge_service()->bluetooth()->has_instance()) {
     bluetooth_adapter_->AddObserver(this);
   }
 }
 
 void ArcBluetoothBridge::OnInstanceReady() {
   mojom::BluetoothInstance* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod("Init");
+      ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service()->bluetooth(), Init);
   DCHECK(bluetooth_instance);
 
   bluetooth_instance->Init(binding_.CreateInterfacePtrAndBind());
 
   // The Bluetooth adapter was ready before the ARC instance, hence we didn't
   // register ourselves as an observer with it then. Since our instance is
   // ready, we should register it now.
   if (bluetooth_adapter_ && !bluetooth_adapter_->HasObserver(this))
     bluetooth_adapter_->AddObserver(this);
 }
 
 void ArcBluetoothBridge::OnInstanceClosed() {
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 void ArcBluetoothBridge::SendDevice(const BluetoothDevice* device) const {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnDeviceFound");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnDeviceFound);
   if (!bluetooth_instance)
     return;
 
   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);
+    auto* btle_instance = ARC_GET_INSTANCE_FOR_METHOD(
+        arc_bridge_service()->bluetooth(), OnLEDeviceFound);
     if (!btle_instance)
       return;
     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())
@@ skipping 41 matching lines @@
   if (!(device->GetType() & device::BLUETOOTH_TRANSPORT_LE))
     return;
 
   auto it = gatt_connection_cache_.find(old_address);
   if (it == gatt_connection_cache_.end())
     return;
 
   gatt_connection_cache_.erase(it);
   gatt_connection_cache_.insert(device->GetAddress());
 
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnLEDeviceAddressChange", kMinAddrChangeVersion);
+  auto* btle_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnLEDeviceAddressChange);
   if (!btle_instance)
     return;
 
   mojom::BluetoothAddressPtr old_addr =
       mojom::BluetoothAddress::From(old_address);
   mojom::BluetoothAddressPtr new_addr =
       mojom::BluetoothAddress::From(device->GetAddress());
   btle_instance->OnLEDeviceAddressChange(std::move(old_addr),
                                          std::move(new_addr));
 }
@@ skipping 45 matching lines @@
 
 void ArcBluetoothBridge::GattServiceRemoved(
     BluetoothAdapter* adapter,
     BluetoothDevice* device,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServicesDiscovered(BluetoothAdapter* adapter,
                                                 BluetoothDevice* device) {
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnSearchComplete", kMinBtleVersion);
+  auto* btle_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnSearchComplete);
   if (!btle_instance)
     return;
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
 
   btle_instance->OnSearchComplete(std::move(addr),
                                   mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
@@ skipping 30 matching lines @@
 void ArcBluetoothBridge::GattDescriptorRemoved(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattCharacteristicValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnGattNotify", kMinBtleNotifyVersion);
+  auto* btle_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnGattNotify);
   if (!btle_instance)
     return;
 
   BluetoothRemoteGattService* service = characteristic->GetService();
   BluetoothDevice* device = service->GetDevice();
   mojom::BluetoothAddressPtr address =
       mojom::BluetoothAddress::From(device->GetAddress());
   mojom::BluetoothGattServiceIDPtr service_id =
       mojom::BluetoothGattServiceID::New();
   service_id->is_primary = service->IsPrimary();
@@ skipping 17 matching lines @@
 }
 
 template <class LocalGattAttribute>
 void ArcBluetoothBridge::OnGattAttributeReadRequest(
     const BluetoothDevice* device,
     const LocalGattAttribute* attribute,
     int offset,
     const ValueCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK(CalledOnValidThread());
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "RequestGattRead", kMinGattServerVersion);
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), RequestGattRead);
   if (!bluetooth_instance || !IsGattOffsetValid(offset)) {
     error_callback.Run();
     return;
   }
 
   DCHECK(gatt_handle_.find(attribute->GetIdentifier()) != gatt_handle_.end());
 
   bluetooth_instance->RequestGattRead(
       mojom::BluetoothAddress::From(device->GetAddress()),
       gatt_handle_[attribute->GetIdentifier()], offset, false /* is_long */,
       base::Bind(&OnGattServerRead, success_callback, error_callback));
 }
 
 template <class LocalGattAttribute>
 void ArcBluetoothBridge::OnGattAttributeWriteRequest(
     const BluetoothDevice* device,
     const LocalGattAttribute* attribute,
     const std::vector<uint8_t>& value,
     int offset,
     const base::Closure& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK(CalledOnValidThread());
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "RequestGattWrite", kMinGattServerVersion);
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), RequestGattWrite);
   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, value,
@@ skipping 69 matching lines @@
   DCHECK(bluetooth_adapter_);
   bluetooth_adapter_->SetPowered(
       false, base::Bind(&ArcBluetoothBridge::OnPoweredOff,
                         weak_factory_.GetWeakPtr(), callback),
       base::Bind(&ArcBluetoothBridge::OnPoweredError,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::GetAdapterProperty(mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnAdapterProperties");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnAdapterProperties);
   if (!bluetooth_instance)
     return;
 
   std::vector<mojom::BluetoothPropertyPtr> properties =
       GetAdapterProperties(type);
 
   bluetooth_instance->OnAdapterProperties(mojom::BluetoothStatus::SUCCESS,
                                           std::move(properties));
 }
 
@@ skipping 43 matching lines @@
       discoverable,
       base::Bind(&ArcBluetoothBridge::OnSetDiscoverable,
                  weak_factory_.GetWeakPtr(), discoverable, true, timeout),
       base::Bind(&ArcBluetoothBridge::OnSetDiscoverable,
                  weak_factory_.GetWeakPtr(), discoverable, false, timeout));
 }
 
 void ArcBluetoothBridge::OnSetAdapterProperty(
     mojom::BluetoothStatus status,
     mojom::BluetoothPropertyPtr property) {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnAdapterProperties");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnAdapterProperties);
   DCHECK(bluetooth_instance);
 
   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) {
@@ skipping 31 matching lines @@
     // Android does not set any other property type.
     OnSetAdapterProperty(mojom::BluetoothStatus::UNSUPPORTED,
                          std::move(property));
   }
 }
 
 void ArcBluetoothBridge::GetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnRemoteDeviceProperties");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnRemoteDeviceProperties);
   if (!bluetooth_instance)
     return;
 
   std::string addr_str = remote_addr->To<std::string>();
   BluetoothDevice* device = bluetooth_adapter_->GetDevice(addr_str);
 
   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");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), 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),
       std::vector<mojom::BluetoothPropertyPtr>());
 }
 
@@ skipping 56 matching lines @@
 
   callback.Run(bluetooth_adapter_->IsPowered()
                    ? mojom::BluetoothAdapterState::ON
                    : mojom::BluetoothAdapterState::OFF);
 }
 
 void ArcBluetoothBridge::OnDiscoveryStarted(
     std::unique_ptr<BluetoothDiscoverySession> session) {
   DCHECK(CalledOnValidThread());
 
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnDiscoveryStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnDiscoveryStateChanged);
   if (!bluetooth_instance)
     return;
 
   discovery_session_ = std::move(session);
 
   // We need to set timer to turn device discovery off because of the difference
   // between Android API (do device discovery once) and Chrome API (do device
   // discovery until user turns it off).
   discovery_off_timer_.Start(FROM_HERE, kDiscoveryTimeout,
                              base::Bind(&ArcBluetoothBridge::CancelDiscovery,
                                         weak_factory_.GetWeakPtr()));
 
   bluetooth_instance->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STARTED);
 
   SendCachedDevicesFound();
 }
 
 void ArcBluetoothBridge::OnDiscoveryStopped() {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnDiscoveryStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnDiscoveryStateChanged);
   if (!bluetooth_instance)
     return;
 
   discovery_session_.reset();
   discovery_off_timer_.Stop();
 
   bluetooth_instance->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STOPPED);
 }
 
@@ skipping 92 matching lines @@
                  weak_factory_.GetWeakPtr()));
 }
 
 void ArcBluetoothBridge::StopLEScan() {
   CancelDiscovery();
 }
 
 void ArcBluetoothBridge::OnGattConnectStateChanged(
     mojom::BluetoothAddressPtr addr,
     bool connected) const {
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnLEConnectionStateChange", kMinBtleVersion);
+  auto* btle_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnLEConnectionStateChange);
   if (!btle_instance)
     return;
 
   DCHECK(addr);
 
   btle_instance->OnLEConnectionStateChange(std::move(addr), connected);
 }
 
 void ArcBluetoothBridge::OnGattConnected(
     mojom::BluetoothAddressPtr addr,
@@ skipping 18 matching lines @@
                  << "but no gatt connection was found";
   } else {
     gatt_connections_.erase(it);
   }
 
   OnGattConnectStateChanged(std::move(addr), false);
 }
 
 void ArcBluetoothBridge::ConnectLEDevice(
     mojom::BluetoothAddressPtr remote_addr) {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnLEConnectionStateChange", kMinBtleVersion);
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnLEConnectionStateChange);
   if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   if (device->IsConnected()) {
     bluetooth_instance->OnLEConnectionStateChange(std::move(remote_addr), true);
     return;
   }
 
   // Also pass disconnect callback in error case since it would be disconnected
   // anyway.
   mojom::BluetoothAddressPtr remote_addr_clone = remote_addr.Clone();
   device->CreateGattConnection(
       base::Bind(&ArcBluetoothBridge::OnGattConnected,
                  weak_factory_.GetWeakPtr(), base::Passed(&remote_addr)),
       base::Bind(&ArcBluetoothBridge::OnGattConnectError,
                  weak_factory_.GetWeakPtr(), base::Passed(&remote_addr_clone)));
 }
 
 void ArcBluetoothBridge::DisconnectLEDevice(
     mojom::BluetoothAddressPtr remote_addr) {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnLEConnectionStateChange", kMinBtleVersion);
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnLEConnectionStateChange);
   if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   if (!device->IsConnected()) {
     bluetooth_instance->OnLEConnectionStateChange(std::move(remote_addr),
                                                   false);
     return;
   }
 
   mojom::BluetoothAddressPtr remote_addr_clone = remote_addr.Clone();
   device->Disconnect(
       base::Bind(&ArcBluetoothBridge::OnGattDisconnected,
                  weak_factory_.GetWeakPtr(), base::Passed(&remote_addr)),
       base::Bind(&ArcBluetoothBridge::OnGattDisconnected,
                  weak_factory_.GetWeakPtr(), base::Passed(&remote_addr_clone)));
 }
 
 void ArcBluetoothBridge::SearchService(mojom::BluetoothAddressPtr remote_addr) {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnSearchComplete", kMinBtleVersion);
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnSearchComplete);
   if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   // Call the callback if discovery is completed
   if (device->IsGattServicesDiscoveryComplete()) {
     bluetooth_instance->OnSearchComplete(
@@ skipping 55 matching lines @@
         BluetoothAdvertisement::ErrorCode::ERROR_ADVERTISEMENT_DOES_NOT_EXIST);
     return;
   }
   advertisment_->Unregister(base::Bind(&ArcBluetoothBridge::OnStopLEListenDone,
                                        weak_factory_.GetWeakPtr(), callback),
                             base::Bind(&ArcBluetoothBridge::OnStopLEListenError,
                                        weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::GetGattDB(mojom::BluetoothAddressPtr remote_addr) {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnGetGattDB",
-                                                              kMinBtleVersion);
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnGetGattDB);
   if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   std::vector<mojom::BluetoothGattDBElementPtr> db;
   for (auto* service : device->GetGattServices()) {
     mojom::BluetoothGattDBElementPtr service_element = CreateGattDBElement(
         service->IsPrimary()
             ? mojom::BluetoothGattDBAttributeType::BTGATT_DB_PRIMARY_SERVICE
@@ skipping 545 matching lines @@
                << ", error code = " << error_code;
   advertisements_.erase(adv_handle);
   callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
 }
 
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
 }
 
 void ArcBluetoothBridge::OnPairing(mojom::BluetoothAddressPtr addr) const {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnBondStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnBondStateChanged);
   if (!bluetooth_instance)
     return;
 
   bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::SUCCESS,
                                          std::move(addr),
                                          mojom::BluetoothBondState::BONDING);
 }
 
 void ArcBluetoothBridge::OnPairedDone(mojom::BluetoothAddressPtr addr) const {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnBondStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnBondStateChanged);
   if (!bluetooth_instance)
     return;
 
   bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::SUCCESS,
                                          std::move(addr),
                                          mojom::BluetoothBondState::BONDED);
 }
 
 void ArcBluetoothBridge::OnPairedError(
     mojom::BluetoothAddressPtr addr,
     BluetoothDevice::ConnectErrorCode error_code) const {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnBondStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnBondStateChanged);
   if (!bluetooth_instance)
     return;
 
   bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::FAIL,
                                          std::move(addr),
                                          mojom::BluetoothBondState::NONE);
 }
 
 void ArcBluetoothBridge::OnForgetDone(mojom::BluetoothAddressPtr addr) const {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnBondStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnBondStateChanged);
   if (!bluetooth_instance)
     return;
 
   bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::SUCCESS,
                                          std::move(addr),
                                          mojom::BluetoothBondState::NONE);
 }
 
 void ArcBluetoothBridge::OnForgetError(mojom::BluetoothAddressPtr addr) const {
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-          "OnBondStateChanged");
+  auto* bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnBondStateChanged);
   if (!bluetooth_instance)
     return;
 
   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,
@@ skipping 273 matching lines @@
         mojom::BluetoothAddress::From(device->GetAddress());
     OnPairing(addr->Clone());
     OnPairedDone(std::move(addr));
   }
 }
 
 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);
+  auto* sdp_bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnGetSdpRecords);
   if (!sdp_bluetooth_instance)
     return;
 
   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);
+  auto* sdp_bluetooth_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service()->bluetooth(), OnGetSdpRecords);
   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,
       std::vector<mojom::BluetoothSdpRecordPtr>());
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc