arc: Add InstanceHelper::GetInstanceForMethod()

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 35 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 int32_t kMinBtleVersion = 1;
-constexpr int32_t kMinBtleNotifyVersion = 2;
-constexpr int32_t kMinGattServerVersion = 3;
-constexpr int32_t kMinAddrChangeVersion = 4;
-constexpr int32_t kMinSdpSupportVersion = 5;
+constexpr uint32_t kMinInstanceVersion = 0;
+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 234 matching lines @@
     bluetooth_adapter_->AddObserver(this);
 }
 
 void ArcBluetoothBridge::OnInstanceClosed() {
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 void ArcBluetoothBridge::AdapterPoweredChanged(BluetoothAdapter* adapter,
                                                bool powered) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   // TODO(smbarber): Invoke EnableAdapter or DisableAdapter via ARC bridge
   // service.
 }
 
 void ArcBluetoothBridge::DeviceAdded(BluetoothAdapter* adapter,
                                      BluetoothDevice* device) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
-  arc_bridge_service()->bluetooth()->instance()->OnDeviceFound(
-      std::move(properties));
+  bluetooth_instance->OnDeviceFound(std::move(properties));
 
-  if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinBtleVersion, "OnLEDeviceFound");
+  if (!btle_instance)
     return;
 
   if (!(device->GetType() & device::BLUETOOTH_TRANSPORT_LE))
     return;
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
   base::Optional<int8_t> rssi = device->GetInquiryRSSI();
   mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
       GetAdvertisingData(device);
-  arc_bridge_service()->bluetooth()->instance()->OnLEDeviceFound(
-      std::move(addr), rssi.value_or(mojom::kUnknownPower),
-      std::move(adv_data));
+  btle_instance->OnLEDeviceFound(std::move(addr),
+                                 rssi.value_or(mojom::kUnknownPower),
+                                 std::move(adv_data));
 
   if (!device->IsConnected())
     return;
 
   addr = mojom::BluetoothAddress::From(device->GetAddress());
   OnGattConnectStateChanged(std::move(addr), true);
 }
 
 void ArcBluetoothBridge::DeviceChanged(BluetoothAdapter* adapter,
                                        BluetoothDevice* device) {
@@ skipping 26 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());
 
-  if (!HasBluetoothInstance())
-    return;
-
-  if (!CheckBluetoothInstanceVersion(kMinAddrChangeVersion))
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinAddrChangeVersion, "OnLEDeviceAddressChange");
+  if (!btle_instance)
     return;
 
   mojom::BluetoothAddressPtr old_addr =
       mojom::BluetoothAddress::From(old_address);
   mojom::BluetoothAddressPtr new_addr =
       mojom::BluetoothAddress::From(device->GetAddress());
-  arc_bridge_service()->bluetooth()->instance()->OnLEDeviceAddressChange(
-      std::move(old_addr), std::move(new_addr));
+  btle_instance->OnLEDeviceAddressChange(std::move(old_addr),
+                                         std::move(new_addr));
 }
 
 void ArcBluetoothBridge::DevicePairedChanged(BluetoothAdapter* adapter,
                                              BluetoothDevice* device,
                                              bool new_paired_status) {
   DCHECK(adapter);
   DCHECK(device);
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
@@ skipping 36 matching lines @@
 
 void ArcBluetoothBridge::GattServiceRemoved(
     BluetoothAdapter* adapter,
     BluetoothDevice* device,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServicesDiscovered(BluetoothAdapter* adapter,
                                                 BluetoothDevice* device) {
-  if (!HasBluetoothInstance())
-    return;
-
-  if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinBtleVersion, "OnSearchComplete");
+  if (!btle_instance)
     return;
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
 
-  arc_bridge_service()->bluetooth()->instance()->OnSearchComplete(
-      std::move(addr), mojom::BluetoothGattStatus::GATT_SUCCESS);
+  btle_instance->OnSearchComplete(std::move(addr),
+                                  mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
 void ArcBluetoothBridge::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServiceChanged(
     BluetoothAdapter* adapter,
@@ skipping 22 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) {
-  if (!HasBluetoothInstance())
-    return;
-
-  if (!CheckBluetoothInstanceVersion(kMinBtleNotifyVersion))
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinBtleNotifyVersion, "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();
   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();
 
-  arc_bridge_service()->bluetooth()->instance()->OnGattNotify(
-      std::move(address), std::move(service_id), std::move(char_id),
-      true /* is_notify */, mojo::Array<uint8_t>::From(value));
+  btle_instance->OnGattNotify(std::move(address), std::move(service_id),
+                              std::move(char_id), true /* is_notify */,
+                              mojo::Array<uint8_t>::From(value));
 }
 
 void ArcBluetoothBridge::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   // Placeholder for GATT client functionality
 }
 
 template <class LocalGattAttribute>
 void ArcBluetoothBridge::OnGattAttributeReadRequest(
     const BluetoothDevice* device,
     const LocalGattAttribute* attribute,
     int offset,
     const ValueCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK(CalledOnValidThread());
-  if (!HasBluetoothInstance() ||
-      !CheckBluetoothInstanceVersion(kMinGattServerVersion) ||
-      !IsGattOffsetValid(offset)) {
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinGattServerVersion, "RequestGattRead");
+  if (!bluetooth_instance || !IsGattOffsetValid(offset)) {
     error_callback.Run();
     return;
   }
 
   DCHECK(gatt_handle_.find(attribute->GetIdentifier()) != gatt_handle_.end());
 
-  arc_bridge_service()->bluetooth()->instance()->RequestGattRead(
+  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());
-  if (!HasBluetoothInstance() ||
-      !CheckBluetoothInstanceVersion(kMinGattServerVersion) ||
-      !IsGattOffsetValid(offset)) {
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinGattServerVersion, "RequestGattWrite");
+  if (!bluetooth_instance || !IsGattOffsetValid(offset)) {
     error_callback.Run();
     return;
   }
 
   DCHECK(gatt_handle_.find(attribute->GetIdentifier()) != gatt_handle_.end());
 
-  arc_bridge_service()->bluetooth()->instance()->RequestGattWrite(
+  bluetooth_instance->RequestGattWrite(
       mojom::BluetoothAddress::From(device->GetAddress()),
       gatt_handle_[attribute->GetIdentifier()], offset,
       mojo::Array<uint8_t>::From(value),
       base::Bind(&OnGattServerWrite, success_callback, error_callback));
 }
 
 void ArcBluetoothBridge::OnCharacteristicReadRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic,
     int offset,
@@ skipping 62 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_);
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetAdapterProperties(type);
 
-  arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
-      mojom::BluetoothStatus::SUCCESS, std::move(properties));
+  bluetooth_instance->OnAdapterProperties(mojom::BluetoothStatus::SUCCESS,
+                                          std::move(properties));
 }
 
 void ArcBluetoothBridge::OnSetDiscoverable(bool discoverable,
                                            bool success,
                                            uint32_t timeout) {
   DCHECK(CalledOnValidThread());
 
   if (success && discoverable && timeout > 0) {
     discoverable_off_timer_.Start(
         FROM_HERE, base::TimeDelta::FromSeconds(timeout),
         base::Bind(&ArcBluetoothBridge::SetDiscoverable,
                    weak_factory_.GetWeakPtr(), false, 0));
   }
 
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   if (success) {
-    arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+    bluetooth_instance->OnAdapterProperties(
         mojom::BluetoothStatus::SUCCESS, GetDiscoveryTimeoutProperty(timeout));
   } else {
-    arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+    bluetooth_instance->OnAdapterProperties(
         mojom::BluetoothStatus::FAIL,
         mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0));
   }
 }
 
 // Set discoverable state to on / off.
 // In case of turning on, start timer to turn it back off in |timeout| seconds.
 void ArcBluetoothBridge::SetDiscoverable(bool discoverable, uint32_t timeout) {
   DCHECK(bluetooth_adapter_);
   DCHECK(CalledOnValidThread());
   DCHECK(!discoverable || timeout == 0);
 
   bool currently_discoverable = bluetooth_adapter_->IsDiscoverable();
 
   if (!discoverable && !currently_discoverable)
     return;
 
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+
   if (discoverable && currently_discoverable) {
     if (base::TimeDelta::FromSeconds(timeout) >
         discoverable_off_timer_.GetCurrentDelay()) {
       // Restart discoverable_off_timer_ if new timeout is greater
       OnSetDiscoverable(true, true, timeout);
-    } else if (HasBluetoothInstance()) {
+    } else if (bluetooth_instance) {
       // Just send message to Android if new timeout is lower.
-      arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+      bluetooth_instance->OnAdapterProperties(
           mojom::BluetoothStatus::SUCCESS,
           GetDiscoveryTimeoutProperty(timeout));
     }
     return;
   }
 
   bluetooth_adapter_->SetDiscoverable(
       discoverable,
       base::Bind(&ArcBluetoothBridge::OnSetDiscoverable,
                  weak_factory_.GetWeakPtr(), discoverable, true, timeout),
       base::Bind(&ArcBluetoothBridge::OnSetDiscoverable,
                  weak_factory_.GetWeakPtr(), discoverable, false, timeout));
 }
 
 void ArcBluetoothBridge::SetAdapterProperty(
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   if (property->is_discovery_timeout()) {
     uint32_t discovery_timeout = property->get_discovery_timeout();
     if (discovery_timeout > 0) {
       SetDiscoverable(true, discovery_timeout);
     } else {
-      arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+      bluetooth_instance->OnAdapterProperties(
           mojom::BluetoothStatus::PARM_INVALID,
           mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0));
     }
   } else {
     // TODO(puthik) Implement other case.
-    arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+    bluetooth_instance->OnAdapterProperties(
         mojom::BluetoothStatus::UNSUPPORTED,
         mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0));
   }
 }
 
 void ArcBluetoothBridge::GetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  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 =
       GetDeviceProperties(type, device);
   mojom::BluetoothStatus status = mojom::BluetoothStatus::SUCCESS;
 
   if (!device) {
     VLOG(1) << __func__ << ": device " << addr_str << " not available";
     status = mojom::BluetoothStatus::FAIL;
   }
 
-  arc_bridge_service()->bluetooth()->instance()->OnRemoteDeviceProperties(
-      status, std::move(remote_addr), std::move(properties));
+  bluetooth_instance->OnRemoteDeviceProperties(status, std::move(remote_addr),
+                                               std::move(properties));
 }
 
 void ArcBluetoothBridge::SetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   // TODO(smbarber): Implement SetRemoteDeviceProperty
-  arc_bridge_service()->bluetooth()->instance()->OnRemoteDeviceProperties(
+  bluetooth_instance->OnRemoteDeviceProperties(
       mojom::BluetoothStatus::FAIL, std::move(remote_addr),
       mojo::Array<mojom::BluetoothPropertyPtr>::New(0));
 }
 
 void ArcBluetoothBridge::GetRemoteServiceRecord(
     mojom::BluetoothAddressPtr remote_addr,
     const BluetoothUUID& uuid) {
   // TODO(smbarber): Implement GetRemoteServiceRecord
 }
 
@@ skipping 44 matching lines @@
     const base::Callback<void(mojom::BluetoothAdapterState)>& callback) const {
   LOG(WARNING) << "failed to change power state";
 
   callback.Run(bluetooth_adapter_->IsPowered()
                    ? mojom::BluetoothAdapterState::ON
                    : mojom::BluetoothAdapterState::OFF);
 }
 
 void ArcBluetoothBridge::OnDiscoveryStarted(
     std::unique_ptr<BluetoothDiscoverySession> session) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   discovery_session_ = std::move(session);
 
-  arc_bridge_service()->bluetooth()->instance()->OnDiscoveryStateChanged(
+  bluetooth_instance->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STARTED);
 
   SendCachedDevicesFound();
 }
 
 void ArcBluetoothBridge::OnDiscoveryStopped() {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   discovery_session_.reset();
 
-  arc_bridge_service()->bluetooth()->instance()->OnDiscoveryStateChanged(
+  bluetooth_instance->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STOPPED);
 }
 
 void ArcBluetoothBridge::CreateBond(mojom::BluetoothAddressPtr addr,
                                     int32_t transport) {
   std::string addr_str = addr->To<std::string>();
   BluetoothDevice* device = bluetooth_adapter_->GetDevice(addr_str);
   if (!device || !device->IsPairable()) {
     VLOG(1) << __func__ << ": device " << addr_str
             << " is no longer valid or pairable";
@@ skipping 85 matching lines @@
                  weak_factory_.GetWeakPtr()));
 }
 
 void ArcBluetoothBridge::StopLEScan() {
   CancelDiscovery();
 }
 
 void ArcBluetoothBridge::OnGattConnectStateChanged(
     mojom::BluetoothAddressPtr addr,
     bool connected) const {
-  if (!HasBluetoothInstance())
-    return;
-
-  if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinBtleVersion, "OnLEConnectionStateChange");
+  if (!btle_instance)
     return;
 
   DCHECK(addr);
 
-  arc_bridge_service()->bluetooth()->instance()->OnLEConnectionStateChange(
-      std::move(addr), connected);
+  btle_instance->OnLEConnectionStateChange(std::move(addr), connected);
 }
 
 void ArcBluetoothBridge::OnGattConnected(
     mojom::BluetoothAddressPtr addr,
     std::unique_ptr<BluetoothGattConnection> connection) {
   DCHECK(CalledOnValidThread());
   gatt_connections_[addr->To<std::string>()] = std::move(connection);
   OnGattConnectStateChanged(std::move(addr), true);
 }
 
@@ skipping 12 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) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   if (device->IsConnected()) {
-    arc_bridge_service()->bluetooth()->instance()->OnLEConnectionStateChange(
-        std::move(remote_addr), true);
+    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) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   if (!device->IsConnected()) {
-    arc_bridge_service()->bluetooth()->instance()->OnLEConnectionStateChange(
-        std::move(remote_addr), false);
+    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) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  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()) {
-    arc_bridge_service()->bluetooth()->instance()->OnSearchComplete(
+    bluetooth_instance->OnSearchComplete(
         std::move(remote_addr), mojom::BluetoothGattStatus::GATT_SUCCESS);
     return;
   }
 
   // Discard result. Will call the callback when discovery is completed.
   device->GetGattServices();
 }
 
 void ArcBluetoothBridge::OnStartLEListenDone(
     const StartLEListenCallback& callback,
@@ skipping 45 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) {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   mojo::Array<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,
@@ skipping 19 matching lines @@
       db.push_back(std::move(characteristic_element));
 
       for (auto* descriptor : characteristic->GetDescriptors()) {
         db.push_back(CreateGattDBElement(
             mojom::BluetoothGattDBAttributeType::BTGATT_DB_DESCRIPTOR,
             descriptor));
       }
     }
   }
 
-  arc_bridge_service()->bluetooth()->instance()->OnGetGattDB(
-      std::move(remote_addr), std::move(db));
+  bluetooth_instance->OnGetGattDB(std::move(remote_addr), std::move(db));
 }
 
 BluetoothRemoteGattCharacteristic* ArcBluetoothBridge::FindGattCharacteristic(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id) const {
   DCHECK(remote_addr);
   DCHECK(service_id);
   DCHECK(char_id);
 
@@ skipping 378 matching lines @@
   bluetooth_adapter_->RemoveServiceRecord(
       service_handle, base::Bind(&OnRemoveServiceRecordDone, callback),
       base::Bind(&OnRemoveServiceRecordError, callback));
 }
 
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
 }
 
 void ArcBluetoothBridge::OnPairing(mojom::BluetoothAddressPtr addr) const {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
-  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
-      mojom::BluetoothStatus::SUCCESS, std::move(addr),
-      mojom::BluetoothBondState::BONDING);
+  bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::SUCCESS,
+                                         std::move(addr),
+                                         mojom::BluetoothBondState::BONDING);
 }
 
 void ArcBluetoothBridge::OnPairedDone(mojom::BluetoothAddressPtr addr) const {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
-  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
-      mojom::BluetoothStatus::SUCCESS, std::move(addr),
-      mojom::BluetoothBondState::BONDED);
+  bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::SUCCESS,
+                                         std::move(addr),
+                                         mojom::BluetoothBondState::BONDED);
 }
 
 void ArcBluetoothBridge::OnPairedError(
     mojom::BluetoothAddressPtr addr,
     BluetoothDevice::ConnectErrorCode error_code) const {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
-  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
-      mojom::BluetoothStatus::FAIL, std::move(addr),
-      mojom::BluetoothBondState::NONE);
+  bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::FAIL,
+                                         std::move(addr),
+                                         mojom::BluetoothBondState::NONE);
 }
 
 void ArcBluetoothBridge::OnForgetDone(mojom::BluetoothAddressPtr addr) const {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
 
-  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
-      mojom::BluetoothStatus::SUCCESS, std::move(addr),
-      mojom::BluetoothBondState::NONE);
+  bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::SUCCESS,
+                                         std::move(addr),
+                                         mojom::BluetoothBondState::NONE);
 }
 
 void ArcBluetoothBridge::OnForgetError(mojom::BluetoothAddressPtr addr) const {
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  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;
   }
-  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
-      mojom::BluetoothStatus::FAIL, std::move(addr), bond_state);
+  bluetooth_instance->OnBondStateChanged(mojom::BluetoothStatus::FAIL,
+                                         std::move(addr), bond_state);
 }
 
 mojo::Array<mojom::BluetoothPropertyPtr>
 ArcBluetoothBridge::GetDeviceProperties(mojom::BluetoothPropertyType type,
                                         BluetoothDevice* device) const {
   mojo::Array<mojom::BluetoothPropertyPtr> properties;
 
   if (!device) {
     return properties;
   }
@@ skipping 195 matching lines @@
 
     service_data_element->set_service_data(std::move(service_data));
     advertising_data.push_back(std::move(service_data_element));
   }
 
   return advertising_data;
 }
 
 void ArcBluetoothBridge::SendCachedDevicesFound() const {
   // Send devices that have already been discovered, but aren't connected.
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinBtleVersion, "OnLEDeviceFound");
 
   BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
   for (auto* device : devices) {
     if (device->IsPaired())
       continue;
 
     mojo::Array<mojom::BluetoothPropertyPtr> properties =
         GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
-    arc_bridge_service()->bluetooth()->instance()->OnDeviceFound(
-        std::move(properties));
+    bluetooth_instance->OnDeviceFound(std::move(properties));
 
-    if (arc_bridge_service()->bluetooth()->version() >= kMinBtleVersion) {
+    if (btle_instance) {
       mojom::BluetoothAddressPtr addr =
           mojom::BluetoothAddress::From(device->GetAddress());
       base::Optional<int8_t> rssi = device->GetInquiryRSSI();
       mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
           GetAdvertisingData(device);
-      arc_bridge_service()->bluetooth()->instance()->OnLEDeviceFound(
-          std::move(addr), rssi.value_or(mojom::kUnknownPower),
-          std::move(adv_data));
+      btle_instance->OnLEDeviceFound(std::move(addr),
+                                     rssi.value_or(mojom::kUnknownPower),
+                                     std::move(adv_data));
     }
   }
 }
 
-bool ArcBluetoothBridge::HasBluetoothInstance() const {
-  if (!arc_bridge_service()->bluetooth()->instance()) {
-    LOG(WARNING) << "no Bluetooth instance available";
-    return false;
-  }
-
-  return true;
-}
-
 void ArcBluetoothBridge::SendCachedPairedDevices() const {
   DCHECK(bluetooth_adapter_);
-  if (!HasBluetoothInstance())
+  auto* bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(kMinVersion);
+  if (!bluetooth_instance)
     return;
+  auto* btle_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinBtleVersion, "OnLEDeviceFound");
 
   BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
   for (auto* device : devices) {
     if (!device->IsPaired())
       continue;
 
     mojo::Array<mojom::BluetoothPropertyPtr> properties =
         GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
-    arc_bridge_service()->bluetooth()->instance()->OnDeviceFound(
-        std::move(properties));
+    bluetooth_instance->OnDeviceFound(std::move(properties));
 
     mojom::BluetoothAddressPtr addr =
         mojom::BluetoothAddress::From(device->GetAddress());
 
-    if (arc_bridge_service()->bluetooth()->version() >= kMinBtleVersion) {
+    if (btle_instance) {
       base::Optional<int8_t> rssi = device->GetInquiryRSSI();
       mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
           GetAdvertisingData(device);
-      arc_bridge_service()->bluetooth()->instance()->OnLEDeviceFound(
-          addr->Clone(), rssi.value_or(mojom::kUnknownPower),
-          std::move(adv_data));
+      btle_instance->OnLEDeviceFound(addr->Clone(),
+                                     rssi.value_or(mojom::kUnknownPower),
+                                     std::move(adv_data));
     }
 
     // OnBondStateChanged must be called with mojom::BluetoothBondState::BONDING
     // to make sure the bond state machine on Android is ready to take the
     // pair-done event. Otherwise the pair-done event will be dropped as an
     // invalid change of paired status.
     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) {
-  if (!CheckBluetoothInstanceVersion(kMinSdpSupportVersion))
+  auto* sdp_bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinSdpSupportVersion, "OnGetSdpRecords");
+  if (!sdp_bluetooth_instance)
     return;
 
-  if (!HasBluetoothInstance())
-    return;
-
-  arc_bridge_service()->bluetooth()->instance()->OnGetSdpRecords(
+  sdp_bluetooth_instance->OnGetSdpRecords(
       mojom::BluetoothStatus::SUCCESS, std::move(remote_addr), target_uuid,
       mojo::Array<mojom::BluetoothSdpRecordPtr>::From(records_bluez));
 }
 
 void ArcBluetoothBridge::OnGetServiceRecordsError(
     mojom::BluetoothAddressPtr remote_addr,
     const BluetoothUUID& target_uuid,
     bluez::BluetoothServiceRecordBlueZ::ErrorCode error_code) {
-  if (!HasBluetoothInstance())
-    return;
-
-  if (!CheckBluetoothInstanceVersion(kMinSdpSupportVersion))
+  auto* sdp_bluetooth_instance =
+      arc_bridge_service()->bluetooth()->GetInstanceForVersion(
+          kMinSdpSupportVersion, "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;
   }
 
-  arc_bridge_service()->bluetooth()->instance()->OnGetSdpRecords(
+  sdp_bluetooth_instance->OnGetSdpRecords(
       status, std::move(remote_addr), target_uuid,
       mojo::Array<mojom::BluetoothSdpRecordPtr>::New(0));
 }
 
-bool ArcBluetoothBridge::CheckBluetoothInstanceVersion(
-    uint32_t version_need) const {
-  uint32_t version = arc_bridge_service()->bluetooth()->version();
-  if (version >= version_need)
-    return true;
-  LOG(WARNING) << "Bluetooth instance is too old (version " << version
-               << ") need version " << version_need;
-  return false;
-}
-
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc