Add unit test for ArcBluetoothBridge and TypeConverter

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 54 matching lines @@
     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);
 }
 
+ArcBluetoothBridge::ArcBluetoothBridge(ArcBridgeService* bridge_service,

[rkc, 2016/06/19 18:45:43]

We don't need this constructor. We never use the test_flag variable anywhere
anyway.

+                                       bool test_flag)
+    : ArcService(bridge_service), binding_(this), weak_factory_(this) {
+  if (!test_flag) {
+    LOG(ERROR) << "Test Constructor got called with test = false";
+  }
+  arc_bridge_service()->AddObserver(this);
+}
+
 ArcBluetoothBridge::~ArcBluetoothBridge() {
   arc_bridge_service()->RemoveObserver(this);
 
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 void ArcBluetoothBridge::OnAdapterInitialized(
     scoped_refptr<BluetoothAdapter> adapter) {
   bluetooth_adapter_ = adapter;
   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());
+  bluetooth_instance_ = base::WrapUnique(bluetooth_instance);

[rkc, 2016/06/19 18:45:43]

None of these changes are needed. This file, in fact, should really not be
touched at all for the test.

+  bluetooth_version_ = arc_bridge_service()->bluetooth_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(
-      std::move(properties));
+  bluetooth_instance_->OnDeviceFound(std::move(properties));
 
-  if (arc_bridge_service()->bluetooth_version() < kMinBtleVersion) {
+  if (bluetooth_version_ < kMinBtleVersion) {
     LOG(WARNING) << "Bluetooth instance is too old and does not support BTLE";
     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(
-      std::move(addr), rssi, std::move(adv_data));
+  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,
                                               const std::string& old_address) {
@@ skipping 42 matching lines @@
     BluetoothDevice* device,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServicesDiscovered(BluetoothAdapter* adapter,
                                                 BluetoothDevice* device) {
   if (!HasBluetoothInstance())
     return;
 
-  if (arc_bridge_service()->bluetooth_version() < kMinBtleVersion) {
+  if (bluetooth_version_ < kMinBtleVersion) {
     LOG(WARNING) << "Bluetooth instance is too old and does not support BTLE";
     return;
   }
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
 
-  arc_bridge_service()->bluetooth_instance()->OnSearchComplete(
+  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 65 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(
-      mojom::BluetoothStatus::SUCCESS, std::move(properties));
+  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(
+  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(
-      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())
     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,
     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(
+  bluetooth_instance_->OnDiscoveryStateChanged(
       mojom::BluetoothDiscoveryState::STARTED);
 
   SendCachedDevicesFound();
 }
 
 void ArcBluetoothBridge::OnDiscoveryStopped() {
   if (!HasBluetoothInstance())
     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 88 matching lines @@
 void ArcBluetoothBridge::StopLEScan() {
   CancelDiscovery();
 }
 
 void ArcBluetoothBridge::OnGattConnectStateChanged(
     mojom::BluetoothAddressPtr addr,
     bool connected) const {
   if (!HasBluetoothInstance())
     return;
 
-  if (arc_bridge_service()->bluetooth_version() < kMinBtleVersion) {
+  if (bluetooth_version_ < kMinBtleVersion) {
     LOG(WARNING) << "Bluetooth instance is too old and does not support BTLE";
     return;
   }
 
   DCHECK(addr);
 
-  arc_bridge_service()->bluetooth_instance()->OnLEConnectionStateChange(
+    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(
-        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())
     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())
     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 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(
-      std::move(remote_addr), std::move(db));
+  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; });
   if (it == gatt_objs.end())
@@ skipping 227 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(
-      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())
     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())
     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())
     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())
     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 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(
-        std::move(properties));
+    bluetooth_instance_->OnDeviceFound(std::move(properties));
 
-    if (arc_bridge_service()->bluetooth_version() >= kMinBtleVersion) {
+    if (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(
-          std::move(addr), rssi, std::move(adv_data));
+      bluetooth_instance_->OnLEDeviceFound(std::move(addr), rssi,
+                                           std::move(adv_data));
     }
   }
 }
 
 bool ArcBluetoothBridge::HasBluetoothInstance() const {
-  if (!arc_bridge_service()->bluetooth_instance()) {
+  if (!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(
-        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 (bluetooth_version_ >= kMinBtleVersion) {
       int rssi = device->GetInquiryRSSI();
       mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
           GetAdvertisingData(device);
-      arc_bridge_service()->bluetooth_instance()->OnLEDeviceFound(
-          addr->Clone(), rssi, std::move(adv_data));
+      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));
   }
 }
 
 }  // namespace arc