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 312 matching lines @@
                                      BluetoothDevice* device) {
   if (!HasBluetoothInstance())
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
   arc_bridge_service()->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(

[Yusuke Sato, 2016/09/16 23:58:48]

btle_instance->OnLEDevice...(

[Luis Héctor Chávez, 2016/09/17 00:30:53]

Done.

       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);
 }
 
@@ skipping 28 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(

[Yusuke Sato, 2016/09/16 23:58:48]

same

[Luis Héctor Chávez, 2016/09/17 00:30:53]

Done.

       std::move(addr), mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
 void ArcBluetoothBridge::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServiceChanged(
@@ skipping 23 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(

[Yusuke Sato, 2016/09/16 23:58:48]

same

[Luis Héctor Chávez, 2016/09/17 00:30:53]

Done.

       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 373 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 840 matching lines @@
     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())
     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));
 
-    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 {

[Yusuke Sato, 2016/09/17 01:38:56]

nice!

   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())
     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));
 
     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