bluetooth: Implement simulateGATTConnectionResponse()

device/bluetooth/test/fake_peripheral.cc

 // Copyright 2017 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/fake_peripheral.h"
 
+#include "device/bluetooth/bluetooth_gatt_connection.h"
+
 namespace bluetooth {
 
 FakePeripheral::FakePeripheral(FakeCentral* fake_central,
                                const std::string& address)
     : device::BluetoothDevice(fake_central),
       address_(address),
       gatt_connected_(false) {}
 
 FakePeripheral::~FakePeripheral() {}
 
 void FakePeripheral::SetName(base::Optional<std::string> name) {
   name_ = std::move(name);
 }
 
 void FakePeripheral::SetGattConnected(bool connected) {
   gatt_connected_ = connected;
 }
 
 void FakePeripheral::SetServiceUUIDs(UUIDSet service_uuids) {
   service_uuids_ = std::move(service_uuids);
 }
 
+void FakePeripheral::SimulateGATTConnectionResponse(uint16_t code) {
+  CreateGattConnectionCallbacks callbacks =

[scheib, 2017/05/12 05:43:55]

Call up to BluetoothDevice::DidConnectGatt DidFailToConnectGatt, and reuse
BluetoothDevice code.. or if not feasible, then at least flush all entries in
the queue, not just one.

if above is wrong, then at least:
  DCHECK(!create_____.empty());

[ortuno, 2017/05/15 07:01:30]

Happy to change it but I would like to understand why we would like to flush the
queue? See reply in test.

+      create_gatt_connection_callbacks_.front();
+  create_gatt_connection_callbacks_.pop();
+  if (code == mojom::kHCISuccess) {
+    gatt_connected_ = true;
+    callbacks.first.Run(
+        base::MakeUnique<device::BluetoothGattConnection>(adapter_, address_));
+    adapter_->NotifyDeviceChanged(this);
+  } else if (code == mojom::kHCIConnectionTimeout) {
+    callbacks.second.Run(ERROR_FAILED);
+  } else {
+    callbacks.second.Run(ERROR_UNKNOWN);
+  }
+}
+
 uint32_t FakePeripheral::GetBluetoothClass() const {
   NOTREACHED();
   return 0;
 }
 
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
 device::BluetoothTransport FakePeripheral::GetType() const {
   NOTREACHED();
   return device::BLUETOOTH_TRANSPORT_INVALID;
 }
@@ skipping 132 matching lines @@
   NOTREACHED();
 }
 
 void FakePeripheral::ConnectToServiceInsecurely(
     const device::BluetoothUUID& uuid,
     const ConnectToServiceCallback& callback,
     const ConnectToServiceErrorCallback& error_callback) {
   NOTREACHED();
 }
 
+void FakePeripheral::CreateGattConnection(
+    const GattConnectionCallback& callback,
+    const ConnectErrorCallback& error_callback) {
+  create_gatt_connection_callbacks_.push({callback, error_callback});
+}
+
 void FakePeripheral::CreateGattConnectionImpl() {
   NOTREACHED();
 }
 
 void FakePeripheral::DisconnectGatt() {
-  NOTREACHED();
 }
 }  // namespace bluetooth