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..ea7cd76b032636b806861049a3264bbb0308c613
--- /dev/null
+++ b/device/bluetooth/device_unittest.cc
@@ -0,0 +1,257 @@
+// 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 {
+
+using NiceMockBluetoothAdapter =
+    testing::NiceMock<device::MockBluetoothAdapter>;
+using NiceMockBluetoothDevice = testing::NiceMock<device::MockBluetoothDevice>;
+using NiceMockBluetoothGattService =
+    testing::NiceMock<device::MockBluetoothGattService>;
+using NiceMockBluetoothGattConnection =
+    testing::NiceMock<device::MockBluetoothGattConnection>;
+
+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 BluetoothInterfaceDeviceTest : public testing::Test {
+ public:
+  enum class Call { EXPECTED, NOT_EXPECTED };
+
+  BluetoothInterfaceDeviceTest()
+      : adapter_(new NiceMockBluetoothAdapter),
+        device_(adapter_.get(),
+                0,
+                kTestLeDeviceName0,
+                kTestLeDeviceAddress0,
+                false,
+                true),
+        weak_factory_(this) {
+    ON_CALL(*adapter_, GetDevice(kTestLeDeviceAddress0))
+        .WillByDefault(Return(&device_));
+
+    auto service1 = base::MakeUnique<NiceMockBluetoothGattService>(
+        &device_, kTestServiceId0, device::BluetoothUUID(kTestServiceUuid0),
+        true /* is_primary */, false /* is_local */);
+    auto service2 = base::MakeUnique<NiceMockBluetoothGattService>(
+        &device_, 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_, &device::MockBluetoothDevice::GetMockServices));
+
+    auto connection = base::MakeUnique<NiceMockBluetoothGattConnection>(
+        adapter_, device_.GetAddress());
+
+    device_service_ = new Device(adapter_, std::move(connection));
+    binding_ptr_ = mojo::MakeStrongBinding(base::WrapUnique(device_service_),
+                                           mojo::GetProxy(&proxy_));
+    device_service_->SetStrongBindingPtr(binding_ptr_);
+  }
+
+  void TearDown() override {
+    EXPECT_EQ(expected_success_callback_calls_, actual_success_callback_calls_);
+    EXPECT_EQ(message_pipe_closed_, expect_device_service_deleted_);
+    proxy_.reset();
+  }
+
+  void OnConnectionError(const base::Closure& continuation) {
+    message_pipe_closed_ = true;
+    continuation.Run();

[ortuno, 2016/11/16 04:53:17]

Can you use base::RunLoop to simplify some of this?

[mbrunson, 2016/11/16 22:17:04]

Done.

+  }
+
+ protected:
+  void GetServicesCheckForPrecedingCalls(
+      Call expected,
+      size_t expected_service_count,
+      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_service_count, 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(
+        &BluetoothInterfaceDeviceTest::GetServicesCheckForPrecedingCalls,
+        weak_factory_.GetWeakPtr(), expected, 2 /* expected_service_count */,
+        num_of_preceding_calls, continuation);
+  }
+
+  scoped_refptr<NiceMockBluetoothAdapter> adapter_;
+  NiceMockBluetoothDevice device_;
+  Device* device_service_;
+  base::MessageLoop message_loop_;
+  mojom::DevicePtr proxy_;
+  mojo::StrongBindingPtr<mojom::Device> binding_ptr_;
+
+  bool message_pipe_closed_ = false;
+  bool expect_device_service_deleted_ = false;
+  int expected_success_callback_calls_ = 0;
+  int actual_success_callback_calls_ = 0;
+  int callback_count_ = 0;
+
+  base::WeakPtrFactory<BluetoothInterfaceDeviceTest> weak_factory_;
+};
+}  // namespace
+
+TEST_F(BluetoothInterfaceDeviceTest, GetServices) {
+  EXPECT_CALL(device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(true));
+
+  base::RunLoop loop;
+
+  proxy_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::EXPECTED, 0 /* num_of_preceding_calls */, loop.QuitClosure()));
+
+  loop.Run();
+}
+
+TEST_F(BluetoothInterfaceDeviceTest, GetServicesNotDiscovered) {
+  EXPECT_CALL(device_, IsGattServicesDiscoveryComplete())
+      .WillOnce(Return(false))
+      .WillOnce(Return(false))
+      .WillRepeatedly(Return(true));
+
+  base::RunLoop loop;
+
+  // Client: Sends multiple requests for services.
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::EXPECTED, 0 /* num_of_preceding_calls */, loop.QuitClosure()));
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::EXPECTED, 1 /* num_of_preceding_calls */, loop.QuitClosure()));
+
+  // Simulate: GattServicesDiscovered.
+  device_service_->GattServicesDiscovered(nullptr /* adapter */, &device_);
+
+  // No more GetServices calls will complete.
+  device_service_->GattServicesDiscovered(nullptr /* adapter */, &device_);
+
+  // Client: Sends more requests which run immediately.
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::EXPECTED, 2 /* num_of_preceding_calls */, loop.QuitClosure()));
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::EXPECTED, 3 /* num_of_preceding_calls */, loop.QuitClosure()));
+
+  // No more GetServices calls will complete.
+  device_service_->GattServicesDiscovered(nullptr /* adapter */, &device_);
+
+  loop.Run();
+}
+
+TEST_F(BluetoothInterfaceDeviceTest,
+       GetServicesLostConnectionWithPendingRequests) {
+  EXPECT_CALL(device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(false));
+  // Client: Sends multiple requests for services.
+  base::RunLoop loop;
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::NOT_EXPECTED, 0 /* num_of_preceding_calls */, loop.QuitClosure()));
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::NOT_EXPECTED, 1 /* num_of_preceding_calls */, loop.QuitClosure()));
+  EXPECT_EQ(0, callback_count_);
+
+  base::RunLoop loop2;
+  proxy_.set_connection_error_handler(

[ortuno, 2016/11/16 04:53:17]

I think you can do this when initializing proxy_ if you use base::RunLoop.

[mbrunson, 2016/11/16 22:17:04]

Done.

+      base::Bind(&BluetoothInterfaceDeviceTest::OnConnectionError,
+                 weak_factory_.GetWeakPtr(), loop2.QuitClosure()));
+
+  // Simulate connection loss.
+  device_.SetConnected(false);
+  device_service_->DeviceChanged(nullptr /* adapter */, &device_);
+  expect_device_service_deleted_ = true;

[ortuno, 2016/11/16 04:53:17]

Why do you test this in TearDown rather than in the test itself?

[mbrunson, 2016/11/16 22:17:04]

I wanted to verify the values after each test was finished. I figured putting it
in the TearDown was best so it applies to all tests.

[ortuno, 2016/11/17 03:54:44]

We are loosing some clarity by doing it in TearDown since readers will have to
go back and look for where the variable is being used to understand its purpose.
Also, we actually end up with more code:

```
// constructor
bool expect_device_service_deleted_ = false;

// tests
expected_device_service_deleted_ = true;

// teardown
EXPECT_EQ(message_pipe_closed_, expect_device_service_deleted_);
```

vs.

```
// tests
EXPECT_TRUE(message_pipe_closed_);
```

+  loop2.Run();
+}
+
+TEST_F(BluetoothInterfaceDeviceTest,
+       GetServicesForcedDisconnectionWithPendingRequests) {
+  EXPECT_CALL(device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(false));
+
+  // Client: Sends multiple requests for services.
+  base::RunLoop loop;
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::NOT_EXPECTED, 0 /* num_of_preceding_calls */, loop.QuitClosure()));
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::NOT_EXPECTED, 1 /* num_of_preceding_calls */, loop.QuitClosure()));
+  EXPECT_EQ(0, callback_count_);
+
+  base::RunLoop loop2;
+  proxy_.set_connection_error_handler(
+      base::Bind(&BluetoothInterfaceDeviceTest::OnConnectionError,
+                 weak_factory_.GetWeakPtr(), loop2.QuitClosure()));
+
+  // Simulate connection loss.
+  device_service_->Disconnect();
+  expect_device_service_deleted_ = true;
+  loop2.Run();
+}
+
+TEST_F(BluetoothInterfaceDeviceTest, GetServicesPipeClosedWithPendingRequests) {
+  EXPECT_CALL(device_, IsGattServicesDiscoveryComplete())
+      .WillRepeatedly(Return(false));
+  // Client: Sends multiple requests for services.
+  base::RunLoop loop;
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::NOT_EXPECTED, 0 /* num_of_preceding_calls */, loop.QuitClosure()));
+  device_service_->GetServices(GetGetServicesCheckForPrecedingCalls(
+      Call::NOT_EXPECTED, 1 /* num_of_preceding_calls */, loop.QuitClosure()));
+  EXPECT_EQ(0, callback_count_);
+
+  base::RunLoop loop2;
+
+  // Bind
+  binding_ptr_->set_connection_error_handler(
+      base::Bind(&BluetoothInterfaceDeviceTest::OnConnectionError,
+                 weak_factory_.GetWeakPtr(), loop2.QuitClosure()));
+
+  // Simulate message pipe error.
+  proxy_.reset();
+  expect_device_service_deleted_ = true;
+
+  loop2.Run();
+}
+
+}  // namespace bluetooth