Implement BluetoothRemoteGattCharacteristicWin::StartNotifySession and related unit tests

device/bluetooth/bluetooth_low_energy_win_fake.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 "device/bluetooth/bluetooth_low_energy_win_fake.h"
 
 #include "base/strings/stringprintf.h"
 #include "device/bluetooth/bluetooth_low_energy_defs_win.h"
 
 namespace {
 const char kPlatformNotSupported[] =
     "Bluetooth Low energy is only supported on Windows 8 and later.";
 }  // namespace
 
 namespace device {
 namespace win {
 
 BLEDevice::BLEDevice() {}
 BLEDevice::~BLEDevice() {}
 
 GattService::GattService() {}
 GattService::~GattService() {}
 
 GattCharacteristic::GattCharacteristic() {}
 GattCharacteristic::~GattCharacteristic() {}
 
 GattDescriptor::GattDescriptor() {}
 GattDescriptor::~GattDescriptor() {}
 
+GattCharacteristicObserver::GattCharacteristicObserver() {}
+GattCharacteristicObserver::~GattCharacteristicObserver() {}
+
 BluetoothLowEnergyWrapperFake::BluetoothLowEnergyWrapperFake()
     : observer_(nullptr) {}
 BluetoothLowEnergyWrapperFake::~BluetoothLowEnergyWrapperFake() {}
 
 bool BluetoothLowEnergyWrapperFake::IsBluetoothLowEnergySupported() {
   return true;
 }
 
 bool BluetoothLowEnergyWrapperFake::EnumerateKnownBluetoothLowEnergyDevices(
     ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
     std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
   }
 
   for (auto& device : simulated_devices_) {
+    if (device.second->marked_as_deleted)
+      continue;
     BluetoothLowEnergyDeviceInfo* device_info =
         new BluetoothLowEnergyDeviceInfo();
     *device_info = *(device.second->device_info);
     devices->push_back(device_info);
   }
   return true;
 }
 
 bool BluetoothLowEnergyWrapperFake::
     EnumerateKnownBluetoothLowEnergyGattServiceDevices(
@@ skipping 140 matching lines @@
     return hr;
   }
 
   PBTH_LE_GATT_CHARACTERISTIC_VALUE ret_value =
       (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
           new UCHAR[sizeof(ULONG) + target_characteristic->value->DataSize]);
   ret_value->DataSize = target_characteristic->value->DataSize;
   for (ULONG i = 0; i < ret_value->DataSize; i++)
     ret_value->Data[i] = target_characteristic->value->Data[i];
   out_value->reset(ret_value);
+  if (observer_)
+    observer_->OnReadGattCharacteristicValue();
   return S_OK;
 }
 
 HRESULT BluetoothLowEnergyWrapperFake::WriteCharacteristicValue(
     base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value) {
   GattCharacteristic* target_characteristic =
       GetSimulatedGattCharacteristic(service_path, characteristic);
   if (target_characteristic == nullptr)
-    return ERROR_NOT_FOUND;
+    return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 
   // Return error simulated by SimulateGattCharacteristicWriteError.
   if (target_characteristic->write_errors.size()) {
     HRESULT hr = *(target_characteristic->write_errors.begin());
     target_characteristic->write_errors.erase(
         target_characteristic->write_errors.begin());
     return hr;
   }
 
   PBTH_LE_GATT_CHARACTERISTIC_VALUE win_value =
       (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
           new UCHAR[new_value->DataSize + sizeof(ULONG)]);
   for (ULONG i = 0; i < new_value->DataSize; i++)
     win_value->Data[i] = new_value->Data[i];
   win_value->DataSize = new_value->DataSize;
   target_characteristic->value.reset(win_value);
   if (observer_)
-    observer_->onWriteGattCharacteristicValue(win_value);
+    observer_->OnWriteGattCharacteristicValue(win_value);
   return S_OK;
 }
 
+HRESULT BluetoothLowEnergyWrapperFake::RegisterGattEvents(
+    base::FilePath& service_path,
+    BTH_LE_GATT_EVENT_TYPE type,
+    PVOID event_parameter,
+    PFNBLUETOOTH_GATT_EVENT_CALLBACK callback,
+    PVOID context,
+    BLUETOOTH_GATT_EVENT_HANDLE* out_handle) {
+  // Right now, only CharacteristicValueChangedEvent is supported.
+  CHECK(CharacteristicValueChangedEvent == type);
+
+  scoped_ptr<GattCharacteristicObserver> observer(
+      new GattCharacteristicObserver());
+  observer->callback = callback;
+  observer->context = context;
+  *out_handle = (BLUETOOTH_GATT_EVENT_HANDLE)observer.get();
+  gatt_characteristic_observers_[*out_handle] = std::move(observer);
+
+  PBLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATION parameter =
+      (PBLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATION)event_parameter;
+  for (USHORT i = 0; i < parameter->NumCharacteristics; i++) {
+    GattCharacteristic* target_characteristic = GetSimulatedGattCharacteristic(
+        service_path, &parameter->Characteristics[i]);
+    CHECK(target_characteristic);
+    target_characteristic->observers.push_back(*out_handle);
+  }
+
+  if (observer_)
+    observer_->OnStartCharacteristicNotification();
+
+  return S_OK;
+}
+
+HRESULT BluetoothLowEnergyWrapperFake::UnregisterGattEvent(
+    BLUETOOTH_GATT_EVENT_HANDLE event_handle) {
+  gatt_characteristic_observers_.erase(event_handle);
+  return S_OK;
+}
+
+HRESULT BluetoothLowEnergyWrapperFake::WriteDescriptorValue(
+    base::FilePath& service_path,
+    const PBTH_LE_GATT_DESCRIPTOR descriptor,
+    PBTH_LE_GATT_DESCRIPTOR_VALUE new_value) {
+  if (new_value->DescriptorType == ClientCharacteristicConfiguration) {
+    // Simulate the value the OS will write.
+    std::vector<UCHAR> write_value;
+    if (new_value->ClientCharacteristicConfiguration
+            .IsSubscribeToNotification) {
+      write_value.push_back(1);
+    } else if (new_value->ClientCharacteristicConfiguration
+                   .IsSubscribeToIndication) {
+      write_value.push_back(2);
+    }
+    write_value.push_back(0);
+    if (observer_)
+      observer_->OnWriteGattDescriptorValue(write_value);
+  }
+  return S_OK;
+}
+
 BLEDevice* BluetoothLowEnergyWrapperFake::SimulateBLEDevice(
     std::string device_name,
     BLUETOOTH_ADDRESS device_address) {
   BLEDevice* device = new BLEDevice();
   BluetoothLowEnergyDeviceInfo* device_info =
       new BluetoothLowEnergyDeviceInfo();
   std::string string_device_address =
       BluetoothAddressToCanonicalString(device_address);
   device_info->path =
       base::FilePath(GenerateBLEDevicePath(string_device_address));
   device_info->friendly_name = device_name;
   device_info->address = device_address;
   device->device_info.reset(device_info);
+  device->marked_as_deleted = false;
   simulated_devices_[string_device_address] = make_scoped_ptr(device);
   return device;
 }
 
 BLEDevice* BluetoothLowEnergyWrapperFake::GetSimulatedBLEDevice(
     std::string device_address) {
   BLEDevicesMap::iterator it_d = simulated_devices_.find(device_address);
   if (it_d == simulated_devices_.end())
     return nullptr;
   return it_d->second.get();
 }
 
 void BluetoothLowEnergyWrapperFake::RemoveSimulatedBLEDevice(
     std::string device_address) {
-  simulated_devices_.erase(device_address);
+  simulated_devices_[device_address]->marked_as_deleted = true;
 }
 
 GattService* BluetoothLowEnergyWrapperFake::SimulateGattService(
     BLEDevice* device,
     GattService* parent_service,
     const BTH_LE_UUID& uuid) {
   CHECK(device);
 
   GattService* service = new GattService();
   PBTH_LE_GATT_SERVICE service_info = new BTH_LE_GATT_SERVICE[1];
@@ skipping 58 matching lines @@
   GattCharacteristic* win_characteristic = new GattCharacteristic();
   PBTH_LE_GATT_CHARACTERISTIC win_characteristic_info =
       new BTH_LE_GATT_CHARACTERISTIC[1];
   *win_characteristic_info = characteristic;
   (win_characteristic->characteristic_info).reset(win_characteristic_info);
   win_characteristic->characteristic_info->AttributeHandle =
       GenerateAUniqueAttributeHandle(device_address);
   parent_service->included_characteristics[std::to_string(
       win_characteristic->characteristic_info->AttributeHandle)] =
       make_scoped_ptr(win_characteristic);
+  // Set default empty value.
+  PBTH_LE_GATT_CHARACTERISTIC_VALUE win_value =
+      (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
+          new UCHAR[sizeof(BTH_LE_GATT_CHARACTERISTIC_VALUE)]);
+  win_value->DataSize = 0;
+  win_characteristic->value.reset(win_value);
   return win_characteristic;
 }
 
 void BluetoothLowEnergyWrapperFake::SimulateGattCharacteriscRemove(
     GattService* parent_service,
     std::string attribute_handle) {
   CHECK(parent_service);
   parent_service->included_characteristics.erase(attribute_handle);
 }
 
 GattCharacteristic*
 BluetoothLowEnergyWrapperFake::GetSimulatedGattCharacteristic(
     GattService* parent_service,
     std::string attribute_handle) {
   CHECK(parent_service);
   GattCharacteristicsMap::iterator it =
       parent_service->included_characteristics.find(attribute_handle);
   if (it != parent_service->included_characteristics.end())
     return it->second.get();
   return nullptr;
 }
 
 void BluetoothLowEnergyWrapperFake::SimulateGattCharacteristicValue(
     GattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
-  CHECK(characteristic);
+  GattCharacteristic* target_characteristic = characteristic;
+  if (target_characteristic == nullptr)
+    target_characteristic = remembered_characteristic_;
+  CHECK(target_characteristic);
+
   PBTH_LE_GATT_CHARACTERISTIC_VALUE win_value =
       (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
           new UCHAR[value.size() + sizeof(ULONG)]);
   win_value->DataSize = (ULONG)value.size();
   for (std::size_t i = 0; i < value.size(); i++)
     win_value->Data[i] = value[i];
-  characteristic->value.reset(win_value);
+  target_characteristic->value.reset(win_value);
+}
+
+void BluetoothLowEnergyWrapperFake::
+    SimulateCharacteristicValueChangeNotification(
+        GattCharacteristic* characteristic) {
+  GattCharacteristic* target_characteristic = characteristic;
+  if (target_characteristic == nullptr)
+    target_characteristic = remembered_characteristic_;
+  CHECK(target_characteristic);
+  for (const auto& observer : target_characteristic->observers) {
+    GattCharacteristicObserverTable::const_iterator it =
+        gatt_characteristic_observers_.find(observer);
+    // Check if |observer| has been unregistered by UnregisterGattEvent.
+    if (it != gatt_characteristic_observers_.end()) {
+      BLUETOOTH_GATT_VALUE_CHANGED_EVENT event;
+      event.ChangedAttributeHandle =
+          target_characteristic->characteristic_info->AttributeHandle;
+      event.CharacteristicValueDataSize =
+          target_characteristic->value->DataSize + sizeof(ULONG);
+      event.CharacteristicValue = target_characteristic->value.get();
+      it->second->callback(CharacteristicValueChangedEvent, &event,
+                           it->second->context);
+    }
+  }
 }
 
 void BluetoothLowEnergyWrapperFake::SimulateGattCharacteristicReadError(
     GattCharacteristic* characteristic,
     HRESULT error) {
   CHECK(characteristic);
   characteristic->read_errors.push_back(error);
 }
 
 void BluetoothLowEnergyWrapperFake::SimulateGattCharacteristicWriteError(
     GattCharacteristic* characteristic,
     HRESULT error) {
   CHECK(characteristic);
   characteristic->write_errors.push_back(error);
 }
 
+void BluetoothLowEnergyWrapperFake::RememberCharacteristicForSubsequentAction(
+    GattService* parent_service,
+    std::string attribute_handle) {
+  CHECK(parent_service);
+  remembered_characteristic_ =
+      parent_service->included_characteristics[attribute_handle].get();
+  CHECK(remembered_characteristic_);
+}
+
 void BluetoothLowEnergyWrapperFake::SimulateGattDescriptor(
     std::string device_address,
     GattCharacteristic* characteristic,
     const BTH_LE_UUID& uuid) {
   scoped_ptr<GattDescriptor> descriptor(new GattDescriptor());
   descriptor->descriptor_info.reset(new BTH_LE_GATT_DESCRIPTOR[1]);
   descriptor->descriptor_info->DescriptorUuid = uuid;
   descriptor->descriptor_info->AttributeHandle =
       GenerateAUniqueAttributeHandle(device_address);
   characteristic->included_descriptors[std::to_string(
@@ skipping 104 matching lines @@
 std::string BluetoothLowEnergyWrapperFake::BluetoothAddressToCanonicalString(
     const BLUETOOTH_ADDRESS& btha) {
   std::string result = base::StringPrintf(
       "%02X:%02X:%02X:%02X:%02X:%02X", btha.rgBytes[5], btha.rgBytes[4],
       btha.rgBytes[3], btha.rgBytes[2], btha.rgBytes[1], btha.rgBytes[0]);
   return result;
 }
 
 }  // namespace win
 }  // namespace device