Implement BluetoothRemoteGattCharacteristicWin::StartNotifySession and related unit tests

device/bluetooth/test/bluetooth_test_win.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/test/bluetooth_test_win.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/test/test_pending_task.h"
 #include "base/time/time.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
 #include "device/bluetooth/bluetooth_low_energy_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_win.h"
+#include "device/bluetooth/bluetooth_remote_gatt_descriptor_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_win.h"
 
 namespace {
 
 BLUETOOTH_ADDRESS CanonicalStringToBLUETOOTH_ADDRESS(
     std::string device_address) {
   BLUETOOTH_ADDRESS win_addr;
   unsigned int data[6];
   int result =
       sscanf_s(device_address.c_str(), "%02X:%02X:%02X:%02X:%02X:%02X",
@@ skipping 80 matching lines @@
   win::BluetoothClassicWrapper::SetInstanceForTest(fake_bt_classic_wrapper_);
   win::BluetoothLowEnergyWrapper::SetInstanceForTest(fake_bt_le_wrapper_);
   fake_bt_classic_wrapper_->SimulateARadio(
       base::SysUTF8ToWide(kTestAdapterName),
       CanonicalStringToBLUETOOTH_ADDRESS(kTestAdapterAddress));
 
   adapter_ = new BluetoothAdapterWin(base::Bind(
       &BluetoothTestWin::AdapterInitCallback, base::Unretained(this)));
   adapter_win_ = static_cast<BluetoothAdapterWin*>(adapter_.get());
   adapter_win_->InitForTest(nullptr, bluetooth_task_runner_);
-  adapter_win_->GetWinBluetoothTaskManager()->AddObserver(this);
   FinishPendingTasks();
 }
 
 bool BluetoothTestWin::DenyPermission() {
   return false;
 }
 
 void BluetoothTestWin::StartLowEnergyDiscoverySession() {
   __super ::StartLowEnergyDiscoverySession();
   FinishPendingTasks();
@@ skipping 155 matching lines @@
       static_cast<BluetoothRemoteGattCharacteristicWin*>(characteristic)
           ->GetAttributeHandle());
   fake_bt_le_wrapper_->SimulateGattCharacteriscRemove(
       target_service, characteristic_att_handle);
 
   ForceRefreshDevice();
 }
 
 void BluetoothTestWin::RememberCharacteristicForSubsequentAction(
     BluetoothGattCharacteristic* characteristic) {
-  remembered_characteristic_ =
+  CHECK(characteristic);
+  BluetoothRemoteGattCharacteristicWin* win_characteristic =
       static_cast<BluetoothRemoteGattCharacteristicWin*>(characteristic);
+
+  std::string device_address =
+      win_characteristic->GetService()->GetDevice()->GetAddress();
+  win::BLEDevice* target_device =
+      fake_bt_le_wrapper_->GetSimulatedBLEDevice(device_address);
+  CHECK(target_device);
+  win::GattService* target_service =
+      GetSimulatedService(target_device, win_characteristic->GetService());
+  CHECK(target_service);
+  fake_bt_le_wrapper_->RememberCharacteristicForSubsequentAction(
+      target_service, std::to_string(win_characteristic->GetAttributeHandle()));
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicRead(
     BluetoothGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
-  BluetoothGattCharacteristic* target_characteristic = characteristic;
-  if (target_characteristic == nullptr)
-    target_characteristic = remembered_characteristic_;
-  CHECK(target_characteristic);
-
-  win::GattCharacteristic* target_simulated_characteristic =
-      GetSimulatedCharacteristic(target_characteristic);
-  if (target_simulated_characteristic == nullptr)
-    return;
+  win::GattCharacteristic* target_simulated_characteristic = nullptr;
+  if (characteristic) {
+    target_simulated_characteristic =
+        GetSimulatedCharacteristic(characteristic);
+  }
 
   fake_bt_le_wrapper_->SimulateGattCharacteristicValue(
       target_simulated_characteristic, value);
 
   RunPendingTasksUntilCallback();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicReadError(
     BluetoothGattCharacteristic* characteristic,
     BluetoothGattService::GattErrorCode error_code) {
   win::GattCharacteristic* target_characteristic =
       GetSimulatedCharacteristic(characteristic);
   CHECK(target_characteristic);
-  HRESULT hr = ERROR_SEM_TIMEOUT;
+  HRESULT hr = HRESULT_FROM_WIN32(ERROR_SEM_TIMEOUT);
   if (error_code == BluetoothGattService::GATT_ERROR_INVALID_LENGTH)
     hr = E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
   fake_bt_le_wrapper_->SimulateGattCharacteristicReadError(
       target_characteristic, hr);
 
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicWrite(
     BluetoothGattCharacteristic* characteristic) {
   RunPendingTasksUntilCallback();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicWriteError(
     BluetoothGattCharacteristic* characteristic,
     BluetoothGattService::GattErrorCode error_code) {
   win::GattCharacteristic* target_characteristic =
       GetSimulatedCharacteristic(characteristic);
   CHECK(target_characteristic);
-  HRESULT hr = ERROR_SEM_TIMEOUT;
+  HRESULT hr = HRESULT_FROM_WIN32(ERROR_SEM_TIMEOUT);
   if (error_code == BluetoothGattService::GATT_ERROR_INVALID_LENGTH)
     hr = E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
   fake_bt_le_wrapper_->SimulateGattCharacteristicWriteError(
       target_characteristic, hr);
 
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::DeleteDevice(BluetoothDevice* device) {
   CHECK(device);
   fake_bt_le_wrapper_->RemoveSimulatedBLEDevice(device->GetAddress());
+  FinishPendingTasks();
 }
 
 void BluetoothTestWin::SimulateGattDescriptor(
     BluetoothGattCharacteristic* characteristic,
     const std::string& uuid) {
   win::GattCharacteristic* target_characteristic =
       GetSimulatedCharacteristic(characteristic);
   CHECK(target_characteristic);
   fake_bt_le_wrapper_->SimulateGattDescriptor(
       characteristic->GetService()->GetDevice()->GetAddress(),
       target_characteristic, CanonicalStringToBTH_LE_UUID(uuid));
   ForceRefreshDevice();
 }
 
-void BluetoothTestWin::OnAttemptReadGattCharacteristic() {
+void BluetoothTestWin::SimulateGattNotifySessionStarted(
+    BluetoothGattCharacteristic* characteristic) {
+  FinishPendingTasks();
+}
+
+void BluetoothTestWin::SimulateGattCharacteristicChanged(
+    BluetoothGattCharacteristic* characteristic,
+    const std::vector<uint8_t>& value) {
+  win::GattCharacteristic* target_simulated_characteristic = nullptr;
+  if (characteristic) {
+    target_simulated_characteristic =
+        GetSimulatedCharacteristic(characteristic);
+  }
+
+  fake_bt_le_wrapper_->SimulateGattCharacteristicValue(
+      target_simulated_characteristic, value);
+  fake_bt_le_wrapper_->SimulateCharacteristicValueChangeNotification(
+      target_simulated_characteristic);
+
+  FinishPendingTasks();
+}
+
+void BluetoothTestWin::OnReadGattCharacteristicValue() {
   gatt_read_characteristic_attempts_++;
 }
 
-void BluetoothTestWin::OnAttemptWriteGattCharacteristic() {
+void BluetoothTestWin::OnWriteGattCharacteristicValue(
+    const PBTH_LE_GATT_CHARACTERISTIC_VALUE value) {
   gatt_write_characteristic_attempts_++;
-}
-
-void BluetoothTestWin::onWriteGattCharacteristicValue(
-    const PBTH_LE_GATT_CHARACTERISTIC_VALUE value) {
   last_write_value_.clear();
   for (ULONG i = 0; i < value->DataSize; i++)
     last_write_value_.push_back(value->Data[i]);
 }
 
+void BluetoothTestWin::OnStartCharacteristicNotification() {
+  gatt_notify_characteristic_attempts_++;
+}
+
+void BluetoothTestWin::OnWriteGattDescriptorValue(
+    const std::vector<uint8_t>& value) {
+  gatt_write_descriptor_attempts_++;
+  last_write_value_.assign(value.begin(), value.end());
+}
+
 win::GattService* BluetoothTestWin::GetSimulatedService(
     win::BLEDevice* device,
     BluetoothGattService* service) {
   CHECK(device);
   CHECK(service);
 
   std::vector<std::string> chain_of_att_handles;
   BluetoothRemoteGattServiceWin* win_service =
       static_cast<BluetoothRemoteGattServiceWin*>(service);
   chain_of_att_handles.insert(
@@ skipping 54 matching lines @@
 void BluetoothTestWin::ForceRefreshDevice() {
   adapter_win_->force_update_device_for_test_ = true;
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::FinishPendingTasks() {
   bluetooth_task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 }
 }