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,
@@ skipping 139 matching lines @@
   out_included_descriptors->reset(win_descriptors_info);
   return S_OK;
 }
 
 HRESULT BluetoothLowEnergyWrapperFake::ReadCharacteristicValue(
     base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     scoped_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE>* out_value) {
   GattCharacteristic* target_characteristic =
       GetSimulatedGattCharacteristic(service_path, characteristic);
-  if (target_characteristic == nullptr)
-    return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+  if (target_characteristic == nullptr) {
+    target_characteristic = remembered_characteristic_.get();
+    DCHECK(target_characteristic);
+    DCHECK(target_characteristic->characteristic_info->AttributeHandle ==
+           characteristic->AttributeHandle);
+  }
 
   // Return error simulated by SimulateGattCharacteristicReadError.
   if (target_characteristic->read_errors.size()) {
     HRESULT hr = target_characteristic->read_errors[0];
     target_characteristic->read_errors.erase(
         target_characteristic->read_errors.begin());
     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;
+  if (target_characteristic == nullptr) {
+    target_characteristic = remembered_characteristic_.get();
+    DCHECK(target_characteristic);
+    DCHECK(target_characteristic->characteristic_info->AttributeHandle ==
+           characteristic->AttributeHandle);
+  }
 
   // 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));
@@ skipping 86 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(ULONG)]);

[scheib, 2016/04/05 22:44:02]

sizeof(BTH_LE_GATT_CHARACTERISTIC_VALUE) 

[gogerald1, 2016/04/06 22:54:48]

Done.

+  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_.get();
+  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_.get();
+  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);
+  GattCharacteristicsMap::iterator it =
+      parent_service->included_characteristics.find(attribute_handle);
+  DCHECK(it != parent_service->included_characteristics.end());
+  remembered_characteristic_ = std::move(it->second);

[scheib, 2016/04/05 22:44:02]

Are you intending to move the characteristic out of the
parent_service->included_characteristics? 

If so, use remembered_characteristic_.swap(it->second), and call out in comments
what is happening. (it's not as obvious, because of the iterator reference)

remembered_characteristic_.swap(parent_service->included_characteristics[attribute_handle]);
would be even clearer.

But, if we can get away without doing so it would be best. The reason to do so
would be that the unittest code deleting the device must result in the service
being deleted. but if it is possible to only delete the chrome implementation
objects, and keep the fake objects alive, that would be better at reflecting the
intent of the tests: The OS have objects alive and valid while our objects are
destroyed. 

[gogerald1, 2016/04/06 22:54:48]

Done.

+}
+
 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