bluetooth: Implement FailingConnectionsAdapter.

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // 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.
 
 #include "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_uuid.h"
@@ skipping 24 matching lines @@
 using testing::WithArgs;
 using testing::_;
 
 namespace {
 // Bluetooth UUIDs suitable to pass to BluetoothUUID().
 const char kBatteryServiceUUID[] = "180f";
 const char kGenericAccessServiceUUID[] = "1800";
 const char kGenericAttributeServiceUUID[] = "1801";
 const char kGlucoseServiceUUID[] = "1808";
 const char kHeartRateServiceUUID[] = "180d";
+// UUID prefix for devices that return connection errors.
+const char kPrefixConnectionErrorUUID[] = "0000000";
+// Base Errors UUID. It's used so that we can filter devices and characteristics
+// that return errors. See UnconnectableDevice and ErrorsDevice.
+const char kBaseErrorUUID[] = "-97e5-4cd7-b9f1-f5a427670c59";
+const char kAddressPrefix[] = "00:00:00:00:0";
 
 // Invokes Run() on the k-th argument of the function with no arguments.
 ACTION_TEMPLATE(RunCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_0_VALUE_PARAMS()) {
   return ::testing::get<k>(args).Run();
 }
 
 // Invokes Run() on the k-th argument of the function with 1 argument.
 ACTION_TEMPLATE(RunCallback,
@@ skipping 51 matching lines @@
   else if (fake_adapter_name == "EmptyAdapter")
     return GetEmptyAdapter();
   else if (fake_adapter_name == "FailStartDiscoveryAdapter")
     return GetFailStartDiscoveryAdapter();
   else if (fake_adapter_name == "GlucoseHeartRateAdapter")
     return GetGlucoseHeartRateAdapter();
   else if (fake_adapter_name == "MissingServiceGenericAccessAdapter")
     return GetMissingServiceGenericAccessAdapter();
   else if (fake_adapter_name == "MissingCharacteristicGenericAccessAdapter")
     return GetMissingCharacteristicGenericAccessAdapter();
+  else if (fake_adapter_name == "FailingConnectionsAdapter")
+    return GetFailingConnectionsAdapter();
   else if (fake_adapter_name == "")
     return NULL;
 
   NOTREACHED() << fake_adapter_name;
   return NULL;
 }
 
 // static
 scoped_refptr<NiceMock<MockBluetoothAdapter>>
 LayoutTestBluetoothAdapterProvider::GetBaseAdapter() {
@@ skipping 111 matching lines @@
 
   // Intentionally NOT adding a characteristic to generic_access service.
 
   device->AddMockService(generic_access.Pass());
 
   adapter->AddMockDevice(device.Pass());
 
   return adapter.Pass();
 }
 
+scoped_refptr<NiceMock<MockBluetoothAdapter>>
+LayoutTestBluetoothAdapterProvider::GetFailingConnectionsAdapter() {
+  scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(GetEmptyAdapter());
+
+  for (int error = BluetoothDevice::ERROR_UNKNOWN;

[ortuno, 2015/07/21 21:32:43]

Is this a good way of doing it? I've heard that you should generally avoid
casting enums to ints.

[Jeffrey Yasskin, 2015/07/21 23:08:58]

This is fine. If the relevant enum had a COUNT member, I'd probably use "for
(int error = 0; error < BluetoothDevice::COUNT; ++error)" instead, but it
doesn't matter much.

It's generally good to avoid casting between enums and ints (the int->enum cast
is actually more dangerous due to unspecified behavior when out-of-bounds), but
when you're iterating over all the enumerators, it's the only way to do it.

+       error <= BluetoothDevice::ERROR_UNSUPPORTED_DEVICE; error++) {
+    adapter->AddMockDevice(GetUnconnectableDevice(
+        adapter.get(), static_cast<BluetoothDevice::ConnectErrorCode>(error)));
+  }
+  return adapter.Pass();
+}
+
 // static
 scoped_ptr<NiceMock<MockBluetoothDevice>>
 LayoutTestBluetoothAdapterProvider::GetBaseDevice(
     MockBluetoothAdapter* adapter,
     const std::string& device_name,
     device::BluetoothDevice::UUIDList uuids,
     const std::string& address) {
   scoped_ptr<NiceMock<MockBluetoothDevice>> device(
       new NiceMock<MockBluetoothDevice>(adapter, 0x1F00 /* Bluetooth class */,
                                         device_name, address, true /* paired */,
@@ skipping 74 matching lines @@
           RunCallbackWithResult<0 /* success_callback */>([device_ptr]() {
             return make_scoped_ptr(new NiceMock<MockBluetoothGattConnection>(
                 device_ptr->GetAddress()));
           }));
 
   return device.Pass();
 }
 
 // static
 scoped_ptr<testing::NiceMock<device::MockBluetoothDevice>>
+LayoutTestBluetoothAdapterProvider::GetUnconnectableDevice(
+    MockBluetoothAdapter* adapter,
+    BluetoothDevice::ConnectErrorCode error_code,
+    const std::string& device_name) {
+  BluetoothDevice::UUIDList uuids;
+  uuids.push_back(BluetoothUUID(kPrefixConnectionErrorUUID +

[Jeffrey Yasskin, 2015/07/21 23:08:58]

I think this should use StringPrintf("%08x-97e5-4cd7-b9f1-f5a427670c59",
error_code) instead of string concatenation. You might write an
errorUUID(unsigned) function to encapsulate this, and then you wouldn't need to
extract that format string into a constant.

[ortuno, 2015/07/22 01:06:20]

Done.

+                                std::to_string(error_code) + kBaseErrorUUID));
+
+  scoped_ptr<testing::NiceMock<MockBluetoothDevice>> device(
+      GetBaseDevice(adapter, device_name, uuids,
+                    kAddressPrefix + std::to_string(error_code)));

[Jeffrey Yasskin, 2015/07/21 23:08:58]

Similarly, a format string instead of string concatenation will probably be more
readable, and will deal better with 2-digit error codes if they arise in the
future.

[ortuno, 2015/07/22 01:06:20]

Done.

+
+  ON_CALL(*device, CreateGattConnection(_, _))
+      .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
+
+  return device.Pass();
+}
+
+// static
+scoped_ptr<testing::NiceMock<device::MockBluetoothDevice>>
 LayoutTestBluetoothAdapterProvider::GetGenericAccessDevice(
     MockBluetoothAdapter* adapter,
     const std::string& device_name) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
 
   return GetConnectableDeviceNew(adapter, device_name, uuids);
 }
 
 // static
@@ skipping 156 matching lines @@
 scoped_ptr<NiceMock<MockBluetoothGattCharacteristic>>
 LayoutTestBluetoothAdapterProvider::GetGattCharacteristic(
     MockBluetoothGattService* service,
     const std::string& uuid) {
   return make_scoped_ptr(new NiceMock<MockBluetoothGattCharacteristic>(
       service, uuid /* identifier */, BluetoothUUID(uuid), false /* is_local */,
       NULL /* properties */, NULL /* permissions */));
 }
 
 }  // namespace content