arc: Revamp the ArcBridgeService interface

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 <fcntl.h>
 #include <stddef.h>
 
 #include <iomanip>
@@ skipping 53 matching lines @@
 ArcBluetoothBridge::ArcBluetoothBridge(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this), weak_factory_(this) {
   if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     VLOG(1) << "registering bluetooth adapter";
     BluetoothAdapterFactory::GetAdapter(base::Bind(
         &ArcBluetoothBridge::OnAdapterInitialized, weak_factory_.GetWeakPtr()));
   } else {
     VLOG(1) << "no bluetooth adapter available";
   }
 
-  arc_bridge_service()->AddObserver(this);
+  arc_bridge_service()->bluetooth()->AddObserver(this);
 }
 
 ArcBluetoothBridge::~ArcBluetoothBridge() {
-  arc_bridge_service()->RemoveObserver(this);
+  arc_bridge_service()->bluetooth()->RemoveObserver(this);
 
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 void ArcBluetoothBridge::OnAdapterInitialized(
     scoped_refptr<BluetoothAdapter> adapter) {
   // We can downcast here because we are always running on Chrome OS, and
   // so our adapter uses BlueZ.
   bluetooth_adapter_ =
       static_cast<bluez::BluetoothAdapterBlueZ*>(adapter.get());
   bluetooth_adapter_->AddObserver(this);
 }
 
-void ArcBluetoothBridge::OnBluetoothInstanceReady() {
-  mojom::BluetoothInstance* bluetooth_instance =
-      arc_bridge_service()->bluetooth_instance();
-  if (!bluetooth_instance) {
-    LOG(ERROR) << "OnBluetoothInstanceReady called, "
-               << "but no bluetooth instance found";
-    return;
-  }
-
-  arc_bridge_service()->bluetooth_instance()->Init(
-      binding_.CreateInterfacePtrAndBind());
+void ArcBluetoothBridge::OnInstanceReady(
+    mojom::BluetoothInstance* bluetooth_instance,
+    uint32_t version) {
+  bluetooth_instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcBluetoothBridge::AdapterPresentChanged(BluetoothAdapter* adapter,
                                                bool present) {
   // If the adapter goes away, remove ourselves as an observer.
   if (!present && adapter == bluetooth_adapter_) {
     adapter->RemoveObserver(this);
     bluetooth_adapter_ = nullptr;
   }
 }
@@ skipping 11 matching lines @@
                                      BluetoothDevice* device) {
   if (!HasBluetoothInstance())
     return;
 
   if (device->IsConnected())
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
-  arc_bridge_service()->bluetooth_instance()->OnDeviceFound(
+  arc_bridge_service()->bluetooth()->instance()->OnDeviceFound(
       std::move(properties));
 
   if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
     return;
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
   int rssi = device->GetInquiryRSSI();
   mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
       GetAdvertisingData(device);
-  arc_bridge_service()->bluetooth_instance()->OnLEDeviceFound(
+  arc_bridge_service()->bluetooth()->instance()->OnLEDeviceFound(
       std::move(addr), rssi, std::move(adv_data));
 }
 
 void ArcBluetoothBridge::DeviceChanged(BluetoothAdapter* adapter,
                                        BluetoothDevice* device) {
   // TODO(smbarber): device properties changed; inform the container.
 }
 
 void ArcBluetoothBridge::DeviceAddressChanged(BluetoothAdapter* adapter,
                                               BluetoothDevice* device,
@@ skipping 49 matching lines @@
                                                 BluetoothDevice* device) {
   if (!HasBluetoothInstance())
     return;
 
   if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
     return;
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
 
-  arc_bridge_service()->bluetooth_instance()->OnSearchComplete(
+  arc_bridge_service()->bluetooth()->instance()->OnSearchComplete(
       std::move(addr), mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
 void ArcBluetoothBridge::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServiceChanged(
@@ skipping 44 matching lines @@
       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 = mojom::BluetoothUUID::From(service->GetUUID());
 
   mojom::BluetoothGattIDPtr char_id = mojom::BluetoothGattID::New();
   char_id->inst_id = ConvertGattIdentifierToId(characteristic->GetIdentifier());
   char_id->uuid = mojom::BluetoothUUID::From(characteristic->GetUUID());
 
-  arc_bridge_service()->bluetooth_instance()->OnGattNotify(
+  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));
 }
 
 void ArcBluetoothBridge::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   // Placeholder for GATT client functionality
 }
@@ skipping 23 matching lines @@
 }
 
 void ArcBluetoothBridge::GetAdapterProperty(mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
   if (!HasBluetoothInstance())
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetAdapterProperties(type);
 
-  arc_bridge_service()->bluetooth_instance()->OnAdapterProperties(
+  arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
       mojom::BluetoothStatus::SUCCESS, std::move(properties));
 }
 
 void ArcBluetoothBridge::SetAdapterProperty(
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
   if (!HasBluetoothInstance())
     return;
 
   // TODO(smbarber): Implement SetAdapterProperty
-  arc_bridge_service()->bluetooth_instance()->OnAdapterProperties(
+  arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
       mojom::BluetoothStatus::FAIL,
       mojo::Array<mojom::BluetoothPropertyPtr>::New(0));
 }
 
 void ArcBluetoothBridge::GetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
   if (!HasBluetoothInstance())
     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(
+  arc_bridge_service()->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())
     return;
 
   // TODO(smbarber): Implement SetRemoteDeviceProperty
-  arc_bridge_service()->bluetooth_instance()->OnRemoteDeviceProperties(
+  arc_bridge_service()->bluetooth()->instance()->OnRemoteDeviceProperties(
       mojom::BluetoothStatus::FAIL, std::move(remote_addr),
       mojo::Array<mojom::BluetoothPropertyPtr>::New(0));
 }
 
 void ArcBluetoothBridge::GetRemoteServiceRecord(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothUUIDPtr uuid) {
   // TODO(smbarber): Implement GetRemoteServiceRecord
 }
 
@@ skipping 49 matching lines @@
                    : mojom::BluetoothAdapterState::OFF);
 }
 
 void ArcBluetoothBridge::OnDiscoveryStarted(
     std::unique_ptr<BluetoothDiscoverySession> session) {
   if (!HasBluetoothInstance())
     return;
 
   discovery_session_ = std::move(session);
 
-  arc_bridge_service()->bluetooth_instance()->OnDiscoveryStateChanged(
+  arc_bridge_service()->bluetooth()->instance()->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STARTED);
 
   SendCachedDevicesFound();
 }
 
 void ArcBluetoothBridge::OnDiscoveryStopped() {
   if (!HasBluetoothInstance())
     return;
 
   discovery_session_.reset();
 
-  arc_bridge_service()->bluetooth_instance()->OnDiscoveryStateChanged(
+  arc_bridge_service()->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 93 matching lines @@
     mojom::BluetoothAddressPtr addr,
     bool connected) const {
   if (!HasBluetoothInstance())
     return;
 
   if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
     return;
 
   DCHECK(addr);
 
-  arc_bridge_service()->bluetooth_instance()->OnLEConnectionStateChange(
+  arc_bridge_service()->bluetooth()->instance()->OnLEConnectionStateChange(
       std::move(addr), connected);
 }
 
 void ArcBluetoothBridge::OnGattConnected(
     mojom::BluetoothAddressPtr addr,
     std::unique_ptr<BluetoothGattConnection> connection) const {
   OnGattConnectStateChanged(std::move(addr), true);
 }
 
 void ArcBluetoothBridge::OnGattConnectError(
@@ skipping 10 matching lines @@
 void ArcBluetoothBridge::ConnectLEDevice(
     mojom::BluetoothAddressPtr remote_addr) {
   if (!HasBluetoothInstance())
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   if (device->IsConnected()) {
-    arc_bridge_service()->bluetooth_instance()->OnLEConnectionStateChange(
+    arc_bridge_service()->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())
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   DCHECK(device);
 
   if (!device->IsConnected()) {
-    arc_bridge_service()->bluetooth_instance()->OnLEConnectionStateChange(
+    arc_bridge_service()->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())
     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(
+    arc_bridge_service()->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 105 matching lines @@
       db.push_back(std::move(characteristic_element));
 
       for (auto descriptor : characteristic->GetDescriptors()) {
         db.push_back(CreateGattDBElement<device::BluetoothRemoteGattDescriptor>(
             mojom::BluetoothGattDBAttributeType::BTGATT_DB_DESCRIPTOR,
             descriptor));
       }
     }
   }
 
-  arc_bridge_service()->bluetooth_instance()->OnGetGattDB(
+  arc_bridge_service()->bluetooth()->instance()->OnGetGattDB(
       std::move(remote_addr), std::move(db));
 }
 
 // Find Gatt Service/Characteristic/Descriptor from std::vector from UUID.
 template <class T>
 T* ArcBluetoothBridge::FindGattObjectFromUuid(
     const std::vector<T*> gatt_objs,
     const device::BluetoothUUID uuid) const {
   auto it = std::find_if(gatt_objs.begin(), gatt_objs.end(),
                          [&](T* obj) { return obj->GetUUID() == uuid; });
@@ skipping 241 matching lines @@
 }
 
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
 }
 
 void ArcBluetoothBridge::OnPairing(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     return;
 
-  arc_bridge_service()->bluetooth_instance()->OnBondStateChanged(
+  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
       mojom::BluetoothStatus::SUCCESS, std::move(addr),
       mojom::BluetoothBondState::BONDING);
 }
 
 void ArcBluetoothBridge::OnPairedDone(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     return;
 
-  arc_bridge_service()->bluetooth_instance()->OnBondStateChanged(
+  arc_bridge_service()->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())
     return;
 
-  arc_bridge_service()->bluetooth_instance()->OnBondStateChanged(
+  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
       mojom::BluetoothStatus::FAIL, std::move(addr),
       mojom::BluetoothBondState::NONE);
 }
 
 void ArcBluetoothBridge::OnForgetDone(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     return;
 
-  arc_bridge_service()->bluetooth_instance()->OnBondStateChanged(
+  arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
       mojom::BluetoothStatus::SUCCESS, std::move(addr),
       mojom::BluetoothBondState::NONE);
 }
 
 void ArcBluetoothBridge::OnForgetError(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     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(
+  arc_bridge_service()->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 193 matching lines @@
     return;
 
   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(
+    arc_bridge_service()->bluetooth()->instance()->OnDeviceFound(
         std::move(properties));
 
-    if (arc_bridge_service()->bluetooth_version() >= kMinBtleVersion) {
+    if (arc_bridge_service()->bluetooth()->version() >= kMinBtleVersion) {
       mojom::BluetoothAddressPtr addr =
           mojom::BluetoothAddress::From(device->GetAddress());
       int rssi = device->GetInquiryRSSI();
       mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
           GetAdvertisingData(device);
-      arc_bridge_service()->bluetooth_instance()->OnLEDeviceFound(
+      arc_bridge_service()->bluetooth()->instance()->OnLEDeviceFound(
           std::move(addr), rssi, std::move(adv_data));
     }
   }
 }
 
 bool ArcBluetoothBridge::HasBluetoothInstance() const {
-  if (!arc_bridge_service()->bluetooth_instance()) {
+  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;
 
   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(
+    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 (arc_bridge_service()->bluetooth()->version() >= kMinBtleVersion) {
       int rssi = device->GetInquiryRSSI();
       mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
           GetAdvertisingData(device);
-      arc_bridge_service()->bluetooth_instance()->OnLEDeviceFound(
+      arc_bridge_service()->bluetooth()->instance()->OnLEDeviceFound(
           addr->Clone(), rssi, 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));
   }
 }
 
 bool ArcBluetoothBridge::CheckBluetoothInstanceVersion(
-    int32_t version_need) const {
-  int32_t version = arc_bridge_service()->bluetooth_version();
+    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;
 }
 
 }  // namespace arc