Add support in Chrome to send notifications to a specific device.

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 23 matching lines @@
 
 // A test fixture for Bluetooth that abstracts platform specifics for creating
 // and controlling fake low level objects.
 //
 // Subclasses on each platform implement this, and are then typedef-ed to
 // BluetoothTest.
 class BluetoothTestBase : public testing::Test {
  public:
   enum class Call { EXPECTED, NOT_EXPECTED };
 
+  // Contains the device id, new value being sent and a flag to indicate if
+  // this is an indication instead.
+  using NotificationType = std::tuple<std::string, std::vector<uint8_t>, bool>;

[scheib, 2016/06/07 05:10:04]

Please use a struct with named members instead of the tuple.

[rkc, 2016/06/09 21:08:27]

Using a struct raises several complications.
First, since this has complex types, the struct now will need to have a out of
line constructor, destructor and copy-constructor. Second, this means that we
need to mirror not just this one line between the fake implementation and here
but rather the declaration and implementation of the structure. Looking at all
of these factors, just using a tuple in the tests seemed like a simpler
solution.

[scheib, 2016/06/09 21:34:35]

If not a struct, then named parameters to the methods. The fake can have three
named members. "std::get<1>(value), std::get<2>(value)" style code has poor
readability.

[rkc, 2016/06/12 00:24:28]

Done.

+
   static const std::string kTestAdapterName;
   static const std::string kTestAdapterAddress;
 
   static const std::string kTestDeviceName;
   static const std::string kTestDeviceNameEmpty;
 
   static const std::string kTestDeviceAddress1;
   static const std::string kTestDeviceAddress2;
 
   static const std::string kTestUUIDGenericAccess;
@@ skipping 202 matching lines @@
 
   // 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(
       BluetoothLocalGattCharacteristic* characteristic,
       bool start);
 
   // Returns the value for the last notification that was sent on this
   // characteristic.
-  virtual std::vector<uint8_t> LastNotifactionValueForCharacteristic(
+  virtual NotificationType LastNotifactionValueForCharacteristic(
       BluetoothLocalGattCharacteristic* characteristic);
 
   // 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) {}
 
@@ skipping 120 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_