Implement //device/bt changes for notifications.

device/bluetooth/test/bluetooth_test.h

 // Copyright 2015 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_TEST_BLUETOOTH_TEST_H_
 #define DEVICE_BLUETOOTH_TEST_BLUETOOTH_TEST_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 236 matching lines @@
 
   // Simulates write a value to a locally hosted GATT descriptor by a
   // remote central device.
   virtual void SimulateLocalGattDescriptorValueWriteRequest(
       BluetoothLocalGattService* service,
       BluetoothLocalGattDescriptor* descriptor,
       const std::vector<uint8_t>& value_to_write,
       const base::Closure& success_callback,
       const base::Closure& error_callback) {}
 
+  // Simulates starting or stopping a notification session for a locally
+  // hosted GATT characteristic by a remote device. Returns false if we were
+  // not able to start or stop notifications.
+  virtual bool SimulateLocalGattCharacteristicNotificationsRequest(
+      BluetoothLocalGattService* service,
+      BluetoothLocalGattCharacteristic* characteristic,
+      bool start);
+
+  // Simulates sending a value updated notification to a remote device. Returns

[scheib, 2016/05/12 16:53:19]

I think tests should call characteristic_->NotifyValueChanged(), and have test
framework expose a way to check the result. Similar to
TEST_F(BluetoothRemoteGattCharacteristicTest, WriteRemoteCharacteristic).

Then also test combinations of NotifyValueChanged with various flags including
notify/indicate. 

[rkc, 2016/05/12 20:12:49]

The BlueZ implementation does check the result. I've updated the comment to
indicate that successful completion of this call includes verification of the
notification being sent.

Since we don't have a delegate for this, having the test get back the actual
value set, will require adding platform specific code. Instead, having this
simulate method do the verification allows us to keep the platform specific code
that actually checks the final value to exist in the bluetooth_test_bluez code.


Added the tests to check for error conditions, including incorrect properties
set.

[scheib, 2016/05/12 20:38:27]

I'm not feeling good about this approach. The method under test is
characteristic_->NotifyValueChanged(), so I expect to see it in the test code.
Platform test fixture code is needed to verify that the effect of
NotifyValueChanged made it to the lowest level, yes, but that's also true for
e.g. the Read and Write commands. Please follow a test fixture pattern similar
to those.

[rkc, 2016/05/12 21:19:18]

Actually we don't really need to simulate a notification update, since that is
an action we take in the test. We just need to check the result of our action.
Changed the code accordingly. So now we call NotifyValueChanged directly, then
just check the last notification value with the fake characteristic provider.

Done.

+  // false if the send was unsuccessful.
+  virtual bool SimulateLocalGattCharacteristicSendValueUpdate(
+      BluetoothLocalGattService* service,
+      BluetoothLocalGattCharacteristic* characteristic,
+      const std::vector<uint8_t>& new_value);
+
   // Remembers |descriptor|'s platform specific object to be used in a
   // subsequent call to methods such as SimulateGattDescriptorRead that
   // accept a nullptr value to select this remembered descriptor. This
   // enables tests where the platform attempts to reference descriptor
   // objects after the Chrome objects have been deleted, e.g. with DeleteDevice.
   virtual void RememberDescriptorForSubsequentAction(
       BluetoothRemoteGattDescriptor* descriptor) {}
 
   // Simulates a Descriptor Read operation succeeding, returning |value|.
   // If |descriptor| is null, acts upon the descriptor provided to
@@ skipping 118 matching lines @@
   int actual_error_callback_calls_ = 0;
   bool unexpected_success_callback_ = false;
   bool unexpected_error_callback_ = false;
 
   base::WeakPtrFactory<BluetoothTestBase> weak_factory_;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_TEST_BLUETOOTH_TEST_H_