Implement read & write remote GATT characteristic value for Windows

device/bluetooth/bluetooth_low_energy_win_fake.h

 // 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_LOW_ENERGY_WIN_FAKE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_LOW_ENERGY_WIN_FAKE_H_
 
 #include "device/bluetooth/bluetooth_low_energy_win.h"
 
 #include <set>
@@ skipping 35 matching lines @@
   GattServicesMap included_services;
   GattCharacteristicsMap included_characteristics;
 };
 
 struct GattCharacteristic {
   GattCharacteristic();
   ~GattCharacteristic();
   scoped_ptr<BTH_LE_GATT_CHARACTERISTIC> characteristic_info;
   scoped_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE> value;
   GattDescriptorsMap included_descriptors;
+  std::vector<HRESULT> read_errors;
+  std::vector<HRESULT> write_errors;
 };
 
 struct GattDescriptor {
   GattDescriptor();
   ~GattDescriptor();
   scoped_ptr<BTH_LE_GATT_DESCRIPTOR> descriptor_info;
   scoped_ptr<BTH_LE_GATT_DESCRIPTOR_VALUE> value;
 };
 
 // Fake implementation of BluetoothLowEnergyWrapper. Used for BluetoothTestWin.
 class BluetoothLowEnergyWrapperFake : public BluetoothLowEnergyWrapper {
  public:
+  class Observer {
+   public:
+    Observer() {}
+    ~Observer() {}
+
+    virtual void onWriteGattCharacteristicValue(
+        PBTH_LE_GATT_CHARACTERISTIC_VALUE value) = 0;

[Roger Tawa OOO till Jul 10th, 2016/03/01 15:22:54]

Should this be const?

[gogerald1, 2016/03/01 20:56:08]

Done.

+  };
+
   BluetoothLowEnergyWrapperFake();
   ~BluetoothLowEnergyWrapperFake() override;
 
   bool IsBluetoothLowEnergySupported() override;
   bool EnumerateKnownBluetoothLowEnergyDevices(
       ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
       std::string* error) override;
   bool EnumerateKnownBluetoothLowEnergyGattServiceDevices(
       ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
       std::string* error) override;
   bool EnumerateKnownBluetoothLowEnergyServices(
       const base::FilePath& device_path,
       ScopedVector<BluetoothLowEnergyServiceInfo>* services,
       std::string* error) override;
   HRESULT ReadCharacteristicsOfAService(
       base::FilePath& service_path,
       const PBTH_LE_GATT_SERVICE service,
       scoped_ptr<BTH_LE_GATT_CHARACTERISTIC>* out_included_characteristics,
       USHORT* out_counts) override;
   HRESULT ReadDescriptorsOfACharacteristic(
       base::FilePath& service_path,
       const PBTH_LE_GATT_CHARACTERISTIC characteristic,
       scoped_ptr<BTH_LE_GATT_DESCRIPTOR>* out_included_descriptors,
       USHORT* out_counts) override;
+  HRESULT ReadTheValueOfACharacteristic(
+      base::FilePath& service_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      scoped_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE>* out_value) override;
+  HRESULT WriteTheValueOfACharacteristic(
+      base::FilePath& service_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value) override;
 
   BLEDevice* SimulateBLEDevice(std::string device_name,
                                BLUETOOTH_ADDRESS device_address);
   BLEDevice* GetSimulatedBLEDevice(std::string device_address);
+  void RemoveSimulatedBLEDevice(std::string device_address);
 
   // Note: |parent_service| may be nullptr to indicate a primary service.
   GattService* SimulateGattService(BLEDevice* device,
                                    GattService* parent_service,
                                    const BTH_LE_UUID& uuid);
 
   // Note: |parent_service| may be nullptr to indicate a primary service.
   void SimulateGattServiceRemoved(BLEDevice* device,
                                   GattService* parent_service,
                                   std::string attribute_handle);
 
   // Note: |chain_of_att_handle| contains the attribute handles of the services
   // in order from primary service to target service. The last item in
   // |chain_of_att_handle| is the target service's attribute handle.
   GattService* GetSimulatedGattService(
       BLEDevice* device,
       const std::vector<std::string>& chain_of_att_handle);
   GattCharacteristic* SimulateGattCharacterisc(
       std::string device_address,
       GattService* parent_service,
       const BTH_LE_GATT_CHARACTERISTIC& characteristic);
   void SimulateGattCharacteriscRemove(GattService* parent_service,
                                       std::string attribute_handle);
   GattCharacteristic* GetSimulatedGattCharacteristic(
       GattService* parent_service,
       std::string attribute_handle);
+  void SimulateGattCharacteristicValue(GattCharacteristic* characteristic,
+                                       const std::vector<uint8_t>& value);
+  void SimulateGattCharacteristicReadError(GattCharacteristic* characteristic,
+                                           HRESULT error);
+  void SimulateGattCharacteristicWriteError(GattCharacteristic* characteristic,
+                                            HRESULT error);
   void SimulateGattDescriptor(std::string device_address,
                               GattCharacteristic* characteristic,
                               const BTH_LE_UUID& uuid);
+  void AddObserver(Observer* observer);
 
  private:
   // Get simulated characteristic by |service_path| and |characteristic| info.
   GattCharacteristic* GetSimulatedGattCharacteristic(
       base::FilePath& service_path,
       const PBTH_LE_GATT_CHARACTERISTIC characteristic);
 
   // Generate an unique attribute handle on |device_address|.
   USHORT GenerateAUniqueAttributeHandle(std::string device_address);
 
@@ skipping 16 matching lines @@
   std::vector<std::string> ExtractServiceAttributeHandlesFromDevicePath(
       base::string16 path);
 
   // The canonical BLE device address string format is the
   // BluetoothDevice::CanonicalizeAddress.
   std::string BluetoothAddressToCanonicalString(const BLUETOOTH_ADDRESS& btha);
 
   // Table to store allocated attribute handle for a device.
   BLEAttributeHandleTable attribute_handle_table_;
   BLEDevicesMap simulated_devices_;
+  Observer* observer_;
 };
 
 }  // namespace win
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_LOW_ENERGY_WIN_FAKE_H_