arc: bluetooth: Clean up arc_bluetooth_bridge

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 294 matching lines @@
   // 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::DeviceAdded(BluetoothAdapter* adapter,
-                                     BluetoothDevice* device) {
+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 =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
   bluetooth_instance->OnDeviceFound(std::move(properties));
 
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnLEDeviceFound", kMinBtleVersion);
-  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);
-  btle_instance->OnLEDeviceFound(std::move(addr),
-                                 rssi.value_or(mojom::kUnknownPower),
-                                 std::move(adv_data));
+  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 =
+        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());
   OnGattConnectStateChanged(std::move(addr), true);
 }
 
+void ArcBluetoothBridge::DeviceAdded(BluetoothAdapter* adapter,
+                                     BluetoothDevice* device) {
+  SendDevice(device);
+}
+
 void ArcBluetoothBridge::DeviceChanged(BluetoothAdapter* adapter,
                                        BluetoothDevice* device) {
+  SendDevice(device);
+
   if (!(device->GetType() & device::BLUETOOTH_TRANSPORT_LE))
     return;
 
   auto it = gatt_connection_cache_.find(device->GetAddress());
   bool was_connected = it != gatt_connection_cache_.end();
   bool is_connected = device->IsConnected();
 
   if (is_connected == was_connected)
     return;
 
@@ skipping 1335 matching lines @@
   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>
 ArcBluetoothBridge::GetDeviceProperties(mojom::BluetoothPropertyType type,
-                                        BluetoothDevice* device) const {
+                                        const BluetoothDevice* device) const {
   mojo::Array<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() : nullptr);
     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(device->GetAddress()));
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::UUIDS) {
-    mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     BluetoothDevice::UUIDSet uuids = device->GetUUIDs();
-    btp->set_uuids(std::vector<BluetoothUUID>(uuids.begin(), uuids.end()));
-    properties.push_back(std::move(btp));
+    if (uuids.size() > 0) {
+      mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
+      btp->set_uuids(std::vector<BluetoothUUID>(uuids.begin(), uuids.end()));
+      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(device->GetBluetoothClass());
     properties.push_back(std::move(btp));
   }
   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())));
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::REMOTE_RSSI) {
-    mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     base::Optional<int8_t> rssi = device->GetInquiryRSSI();
-    btp->set_remote_rssi(rssi.value_or(mojom::kUnknownPower));
-    properties.push_back(std::move(btp));
+    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>
 ArcBluetoothBridge::GetAdapterProperties(
     mojom::BluetoothPropertyType type) const {
   mojo::Array<mojom::BluetoothPropertyPtr> properties;
@@ skipping 93 matching lines @@
   return properties;
 }
 
 // Android support 5 types of Advertising Data.
 // However Chrome didn't expose AdvertiseFlag and ManufacturerData.
 // So we will only expose local_name, service_uuids and service_data.
 // Note that we need to use UUID 16 bits in service_data section
 // because Android does not support UUID 128 bits there.
 // TODO(crbug.com/618442) Make Chrome expose missing data.
 mojo::Array<mojom::BluetoothAdvertisingDataPtr>
-ArcBluetoothBridge::GetAdvertisingData(BluetoothDevice* device) const {
+ArcBluetoothBridge::GetAdvertisingData(const BluetoothDevice* device) const {
   mojo::Array<mojom::BluetoothAdvertisingDataPtr> advertising_data;
 
   // LocalName
   mojom::BluetoothAdvertisingDataPtr local_name =
       mojom::BluetoothAdvertisingData::New();
   local_name->set_local_name(device->GetName() ? device->GetName().value()
                                                : nullptr);
   advertising_data.push_back(std::move(local_name));
 
   // ServiceUuid
@@ skipping 23 matching lines @@
     service_data->data.Swap(&data_copy);
 
     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 {
+  DCHECK(bluetooth_adapter_);
+
   // Send devices that have already been discovered, but aren't connected.
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnDeviceFound");
-  if (!bluetooth_instance)
-    return;
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnLEDeviceFound", kMinBtleVersion);
-
   BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
   for (auto* device : devices) {
     if (device->IsPaired())
       continue;
 
-    mojo::Array<mojom::BluetoothPropertyPtr> properties =
-        GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
-
-    bluetooth_instance->OnDeviceFound(std::move(properties));
-
-    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);
-      btle_instance->OnLEDeviceFound(std::move(addr),
-                                     rssi.value_or(mojom::kUnknownPower),
-                                     std::move(adv_data));
-    }
+    SendDevice(device);
   }
 }
 
 void ArcBluetoothBridge::SendCachedPairedDevices() const {
   DCHECK(bluetooth_adapter_);
-  auto* bluetooth_instance =
-      arc_bridge_service()->bluetooth()->GetInstanceForMethod("OnDeviceFound");
-  if (!bluetooth_instance)
-    return;
-  auto* btle_instance = arc_bridge_service()->bluetooth()->GetInstanceForMethod(
-      "OnLEDeviceFound", kMinBtleVersion);
 
   BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
   for (auto* device : devices) {
     if (!device->IsPaired())
       continue;
 
-    mojo::Array<mojom::BluetoothPropertyPtr> properties =
-        GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
-
-    bluetooth_instance->OnDeviceFound(std::move(properties));
-
-    mojom::BluetoothAddressPtr addr =
-        mojom::BluetoothAddress::From(device->GetAddress());
-
-    if (btle_instance) {
-      base::Optional<int8_t> rssi = device->GetInquiryRSSI();
-      mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
-          GetAdvertisingData(device);
-      btle_instance->OnLEDeviceFound(addr->Clone(),
-                                     rssi.value_or(mojom::kUnknownPower),
-                                     std::move(adv_data));
-    }
+    SendDevice(device);
 
     // 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.
+    mojom::BluetoothAddressPtr addr =
+        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 =
@@ skipping 35 matching lines @@
   sdp_bluetooth_instance->OnGetSdpRecords(
       status, std::move(remote_addr), target_uuid,
       mojo::Array<mojom::BluetoothSdpRecordPtr>::New(0));
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc