bluetooth: Implement simulatePreconnectedPeripheral.

device/bluetooth/test/fake_central.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_central.h"
 
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/bind_helpers.h"
+#include "base/stl_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "device/bluetooth/bluetooth_discovery_filter.h"
 #include "device/bluetooth/public/interfaces/test/fake_bluetooth.mojom.h"
+#include "device/bluetooth/test/fake_peripheral.h"
 
 namespace bluetooth {
 
 FakeCentral::FakeCentral(mojom::CentralState state,
                          mojom::FakeCentralRequest request)
     : state_(state), binding_(this, std::move(request)) {}
 
-FakeCentral::~FakeCentral() {}
+void FakeCentral::SimulateSystemConnectedPeripheral(
+    const std::string& address,
+    const std::string& name,
+    const SimulateSystemConnectedPeripheralCallback& callback) {
+  auto device_iter = devices_.find(address);
+  if (device_iter == devices_.end()) {

[scheib, 2017/05/03 20:38:49]

If called with the same address but a new name this logic uses the old device
with that address but doesn't update the name. Same will be true for
simulateAdvertisementReceived but in that case we know with certainty we'll be
reusing addresses. 

Here's a proposal: We have a way to create a FakePeripheral with address, name,
but it is an error to reuse an address. Then, the ID of that peripheral can be
used with simulateAdvertisementReceived or
addConnectedLEPeripheral/SimulateSystemConnectedPeripheral

Regarding the name of the previously connected method
Perhaps:
 SimulatePreconnetedPeripheral,
 SimulatePreviouslyConnetedPeripheral,
 SimulatePeripheralAlreadyConnected

Also, should the design doc be updated as we go? OK if not, but just want to
know what the plan is.
https://docs.google.com/document/d/1Nhv_oVDCodd1pEH_jj9k8gF4rPGb_84VYaZ9IG8M_...

[ortuno, 2017/05/04 04:16:21]

Good catch. This is at the JS API level right? A previous iteration of the API
actually had something similar. The issue was that for addConnectedLEPeripheral
the name needs to be defined whereas for simulateAdvertisementReceived one can
omit the name. jyasskin[1] suggested splitting the dictionary needed for both
functions instead of defining the behavior in prose which lead to the current
API.

I planned to revisit having the name in the constructor once other functions
would need to create peripherals with no name. I overlooked the case you
mentioned. Since we'll need it eventually anyway I added a setter for the name.

[1]
https://docs.google.com/a/google.com/document/d/16HJ15evg_QYrWDMTIy1Ucafp2qgw...
Went with simulatePreconnetedPeripheral.
That is my intention. I took another look and updated relevant parts. I'll try
to do a better job once CLs land.

[scheib, 2017/05/04 04:54:20]

Even with your update the logic sets the name if the peripheral hasn't been
created already. But doesn't set the name if the device_iter found a peripheral
already with that address.

I think I go back to my suggestion:

Have the API allow a peripheral to be created, but not known to the central yet.
When doing so, it gets an address and a name.

Have two methods to inform the central of the peripheral:
address = createFakePeripheral({address, name})
  // either error if an address is reused in a test, or just update the name (is
that a thing real devices can do)?
simulatePreconnectedPeripheral(address)
simulateAdvertisementReceived({address, rssi, ...}) 

+    std::unique_ptr<FakePeripheral> fake_peripheral =
+        base::MakeUnique<FakePeripheral>(this, address, name);
+
+    auto insert_iter = devices_.emplace(address, std::move(fake_peripheral));
+    DCHECK(insert_iter.second);
+    device_iter = insert_iter.first;
+  }
+
+  FakePeripheral* fake_peripheral =
+      static_cast<FakePeripheral*>(device_iter->second.get());
+  fake_peripheral->SetGattConnected(true);
+
+  callback.Run(fake_peripheral->GetIdentifier());
+}
 
 std::string FakeCentral::GetAddress() const {
   NOTREACHED();
   return "";
 }
 
 std::string FakeCentral::GetName() const {
   NOTREACHED();
   return "";
 }
@@ skipping 120 matching lines @@
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   NOTREACHED();
 }
 
 void FakeCentral::RemovePairingDelegateInternal(
     device::BluetoothDevice::PairingDelegate* pairing_delegate) {
   NOTREACHED();
 }
 
+FakeCentral::~FakeCentral() {}
+
 }  // namespace bluetooth