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 "base/strings/stringprintf.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"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothAdapter;
@@ skipping 89 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;
+       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(errorUUID(error_code)));
+
+  scoped_ptr<testing::NiceMock<MockBluetoothDevice>> device(
+      GetBaseDevice(adapter, device_name, uuids, canonicalAddress(error_code)));
+
+  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 10 matching lines @@
       .WillByDefault(Invoke(service.get(),
                             &MockBluetoothGattService::GetMockCharacteristics));
 
   ON_CALL(*service, GetCharacteristic(_))
       .WillByDefault(Invoke(service.get(),
                             &MockBluetoothGattService::GetMockCharacteristic));
 
   return service.Pass();
 }
 
+// static
+std::string LayoutTestBluetoothAdapterProvider::errorUUID(uint32_t alias) {
+  return base::StringPrintf("%08x-97e5-4cd7-b9f1-f5a427670c59", alias);
+}
+
+// static
+std::string LayoutTestBluetoothAdapterProvider::canonicalAddress(int addr) {
+  return BluetoothDevice::CanonicalizeAddress(
+      base::StringPrintf("%012x", addr));
+}
+
 // The functions after this haven't been updated to the new design yet.
 
 // static
 scoped_refptr<NiceMock<MockBluetoothAdapter>>
 LayoutTestBluetoothAdapterProvider::GetSingleEmptyDeviceAdapter() {
   scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetEmptyDevice(adapter.get()));
 
   return adapter.Pass();
@@ skipping 126 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