Implement //device/bt changes for notifications.

device/bluetooth/test/bluetooth_test.h

Index: device/bluetooth/test/bluetooth_test.h
diff --git a/device/bluetooth/test/bluetooth_test.h b/device/bluetooth/test/bluetooth_test.h
index 31a6443b3ba222152e720af7beeb2ca21b8c054c..a410ce34a8f67673bc20412cf2de77c81b68a85c 100644
--- a/device/bluetooth/test/bluetooth_test.h
+++ b/device/bluetooth/test/bluetooth_test.h
@@ -254,6 +254,21 @@ class BluetoothTestBase : public testing::Test {
       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