bluetooth: Add Device connection logic and accompanying user interface.

device/bluetooth/device_unittest.cc

Index: device/bluetooth/device_unittest.cc
diff --git a/device/bluetooth/device_unittest.cc b/device/bluetooth/device_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1cf73c51718b2a3a2c6ec71c69606649dc7e2238
--- /dev/null
+++ b/device/bluetooth/device_unittest.cc
@@ -0,0 +1,225 @@
+// Copyright 2016 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/device.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
+#include "base/run_loop.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "device/bluetooth/test/mock_bluetooth_device.h"
+#include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::Return;
+
+namespace bluetooth {
+
+typedef testing::NiceMock<device::MockBluetoothAdapter>
+    NiceMockBluetoothAdapter;
+typedef testing::NiceMock<device::MockBluetoothDevice> NiceMockBluetoothDevice;
+typedef testing::NiceMock<device::MockBluetoothGattService>
+    NiceMockBluetoothGattService;
+typedef testing::NiceMock<device::MockBluetoothGattConnection>
+    NiceMockBluetoothGattConnection;
+
+namespace {
+const char kTestLeDeviceAddress0[] = "11:22:33:44:55:66";
+const char kTestLeDeviceName0[] = "Test LE Device 0";
+
+const char kTestServiceId0[] = "service_id0";
+const char kTestServiceUuid0[] = "1234";
+
+const char kTestServiceId1[] = "service_id1";
+const char kTestServiceUuid1[] = "5678";
+
+class DeviceTest : public testing::Test {
+ public:
+  enum class Call { EXPECTED, NOT_EXPECTED };
+
+  DeviceTest()
+      : adapter_(new NiceMockBluetoothAdapter),
+        message_loop_(new base::MessageLoop),
+        weak_factory_(this) {
+    device_.reset(
+        new NiceMockBluetoothDevice(adapter_.get(), 0, kTestLeDeviceName0,
+                                    kTestLeDeviceAddress0, false, true));
+
+    ON_CALL(*adapter_, GetDevice(kTestLeDeviceAddress0))
+        .WillByDefault(Return(device_.get()));
+
+    std::unique_ptr<NiceMockBluetoothGattService> service1(
+        new NiceMockBluetoothGattService(
+            device_.get(), kTestServiceId0,
+            device::BluetoothUUID(kTestServiceUuid0), true /* is_primary */,
+            false /* is_local */));
+    std::unique_ptr<NiceMockBluetoothGattService> service2(
+        new NiceMockBluetoothGattService(
+            device_.get(), kTestServiceId1,
+            device::BluetoothUUID(kTestServiceUuid1), true /* is_primary */,
+            false /* is_local */));
+
+    device_->AddMockService(std::move(service1));
+    device_->AddMockService(std::move(service2));
+
+    EXPECT_CALL(*device_, GetGattServices())
+        .WillRepeatedly(Invoke(device_.get(),
+                               &device::MockBluetoothDevice::GetMockServices));
+
+    std::unique_ptr<NiceMockBluetoothGattConnection> connection(
+        new NiceMockBluetoothGattConnection(adapter_, device_->GetAddress()));
+
+    // Owns itself.
+    device_service_ =
+        new Device(adapter_, std::move(connection), mojo::GetProxy(&proxy_));
+  }
+
+  void TearDown() override {
+    EXPECT_EQ(expected_success_callback_calls_, actual_success_callback_calls_);
+
+    if (!expect_device_service_deleted_) {
+      delete device_service_;
+    }
+  }
+
+ protected:
+  void GetServicesCheckForPrecedingCalls(
+      Call expected,
+      size_t expected_length,
+      int num_of_preceding_calls,
+      const base::Closure& continuation,
+      std::vector<mojom::ServiceInfoPtr> services) {
+    EXPECT_EQ(num_of_preceding_calls, callback_count_);
+    ++callback_count_;
+
+    if (expected == Call::EXPECTED)
+      ++actual_success_callback_calls_;
+
+    EXPECT_EQ(expected_length, services.size());
+    continuation.Run();
+  }
+
+  Device::GetServicesCallback GetGetServicesCheckForPrecedingCalls(
+      Call expected,
+      int num_of_preceding_calls,
+      const base::Closure& continuation) {
+    if (expected == Call::EXPECTED)
+      ++expected_success_callback_calls_;
+
+    return base::Bind(&DeviceTest::GetServicesCheckForPrecedingCalls,
+                      weak_factory_.GetWeakPtr(), expected, 2,
+                      num_of_preceding_calls, continuation);
+  }
+
+  void MakeGetServicesRequests(int num_of_preceding_calls,
+                               int expected_calls,
+                               Call expected,
+                               const base::Closure& continuation) {
+    for (int i = 0; i < expected_calls; i++) {
+      device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+          expected, num_of_preceding_calls + i, continuation));
+    }
+  }
+
+  scoped_refptr<NiceMockBluetoothAdapter> adapter_;
+  std::unique_ptr<NiceMockBluetoothDevice> device_;
+  Device* device_service_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
+  mojom::DevicePtr proxy_;
+
+  bool expect_device_service_deleted_ = false;
+  int expected_success_callback_calls_ = 0;
+  int actual_success_callback_calls_ = 0;
+  int callback_count_ = 0;
+
+  base::WeakPtrFactory<DeviceTest> weak_factory_;
+};
+}  // namespace
+
+TEST_F(DeviceTest, GetServices) {
+  EXPECT_CALL(*device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(true));
+
+  base::RunLoop loop;
+  MakeGetServicesRequests(0, 1, Call::EXPECTED, loop.QuitClosure());
+  EXPECT_EQ(0, device_service_->GetPendingServiceRequestCountForTesting());
+
+  loop.Run();
+}
+
+TEST_F(DeviceTest, GetServicesNotDiscovered) {
+  EXPECT_CALL(*device_, IsGattServicesDiscoveryComplete())
+      .WillOnce(Return(false))
+      .WillOnce(Return(false))
+      .WillRepeatedly(Return(true));
+
+  base::RunLoop loop;
+
+  // Client: Sends multiple requests for services.
+  MakeGetServicesRequests(0, 2, Call::EXPECTED, loop.QuitWhenIdleClosure());

[ortuno, 2016/11/02 07:56:04]

nit: I think scheib was proposing wrapping the GattServicesDiscovered() in
SimulateGattServicesDiscovered() rather than wrapping GetServices() calls.

Optional: I think wrapping GetServices() calls makes the code harder to follow,
consider unwrapping them. If not add comments to the arguments; see Function
Arguments Comments in
https://google.github.io/styleguide/cppguide.html#Implementation_Comments

[mbrunson, 2016/11/02 21:57:08]

Hmm ok. I'll just unwrap them then.

+  EXPECT_EQ(2, device_service_->GetPendingServiceRequestCountForTesting());

[ortuno, 2016/11/02 07:56:04]

I'm curious as to why you expose this function. You have n calls coming in and
there should be n calls coming out. And if you want to be sure that the queue is
empty you can just simulate another event.

[mbrunson, 2016/11/02 21:57:08]

Yeah. I probably don't need it here. It was really for the tests for
disconnection to make sure the requests were actually in the queue since they're
never actually called for me to verify they exist.

+
+  // Simulate: GattServicesDiscovered.
+  device_service_->GattServicesDiscovered(nullptr /* adapter */, device_.get());
+  EXPECT_EQ(0, device_service_->GetPendingServiceRequestCountForTesting());
+
+  // No more GetServices calls will complete.
+  device_service_->GattServicesDiscovered(nullptr /* adapter */, device_.get());
+
+  // Client: Sends more requests which run immediately.
+  MakeGetServicesRequests(2, 2, Call::EXPECTED, loop.QuitWhenIdleClosure());
+  EXPECT_EQ(0, device_service_->GetPendingServiceRequestCountForTesting());
+
+  // No more GetServices calls will complete.
+  device_service_->GattServicesDiscovered(nullptr /* adapter */, device_.get());
+
+  loop.Run();
+}
+
+TEST_F(DeviceTest, GetServicesLostConnectionWithPendingRequests) {

[ortuno, 2016/11/02 07:56:04]

In theory the following destructor in Device should cause this test to crash.
Does it actually crash?

pending_services_requests_.clear();
binding_.close();

[mbrunson, 2016/11/02 21:57:08]

No. It doesn't crash. Let me make sure DCHECK is turned on.

[ortuno, 2016/11/04 01:50:42]

Where you able to get it to crash?

[mbrunson, 2016/11/04 02:47:06]

No. I've tried multiple configurations and orders and can't get a crash. Not
sure what's going on there.

+  EXPECT_CALL(*device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(false));
+  // Client: Sends multiple requests for services.
+  base::RunLoop loop;
+  MakeGetServicesRequests(0, 2, Call::NOT_EXPECTED, loop.QuitClosure());
+  EXPECT_EQ(2, device_service_->GetPendingServiceRequestCountForTesting());
+
+  // Simulate connection loss.
+  device_->SetConnected(false);
+  device_service_->DeviceChanged(nullptr /* adapter */, device_.get());
+  expect_device_service_deleted_ = true;
+}
+
+TEST_F(DeviceTest, GetServicesForcedDisconnectionWithPendingRequests) {
+  EXPECT_CALL(*device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(false));
+  // Client: Sends multiple requests for services.
+  base::RunLoop loop;
+  MakeGetServicesRequests(0, 2, Call::NOT_EXPECTED, loop.QuitClosure());
+  EXPECT_EQ(2, device_service_->GetPendingServiceRequestCountForTesting());
+
+  // Simulate connection loss.
+  device_service_->Disconnect();
+  expect_device_service_deleted_ = true;
+}
+
+TEST_F(DeviceTest, GetServicesPipeClosedWithPendingRequests) {
+  EXPECT_CALL(*device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(false));
+  // Client: Sends multiple requests for services.
+  base::RunLoop loop;
+  MakeGetServicesRequests(0, 2, Call::NOT_EXPECTED, loop.QuitClosure());
+  EXPECT_EQ(2, device_service_->GetPendingServiceRequestCountForTesting());
+
+  // Simulate connection loss.
+  proxy_.reset();
+  expect_device_service_deleted_ = true;
+}
+
+}  // namespace bluetooth