Bluetooth: Parse the bluez.Error.Failed on pairing error.

chromeos/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 2013 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 "chromeos/dbus/fake_bluetooth_device_client.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 94 matching lines @@
 const uint32 FakeBluetoothDeviceClient::kWeirdDeviceClass = 0x7a020c;
 
 const char FakeBluetoothDeviceClient::kUnconnectableDevicePath[] =
     "/fake/hci0/dev9";
 const char FakeBluetoothDeviceClient::kUnconnectableDeviceAddress[] =
     "20:7D:74:00:00:02";
 const char FakeBluetoothDeviceClient::kUnconnectableDeviceName[] =
     "Unconnectable Device";
 const uint32 FakeBluetoothDeviceClient::kUnconnectableDeviceClass = 0x7a020c;
 
+const char FakeBluetoothDeviceClient::kUnpairableDevicePath[] =
+    "/fake/hci0/devA";
+const char FakeBluetoothDeviceClient::kUnpairableDeviceAddress[] =
+    "20:7D:74:00:00:03";
+const char FakeBluetoothDeviceClient::kUnpairableDeviceName[] =
+    "Unpairable Device";
+const uint32 FakeBluetoothDeviceClient::kUnpairableDeviceClass = 0x002540;
+
 FakeBluetoothDeviceClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : ExperimentalBluetoothDeviceClient::Properties(
           NULL,
           bluetooth_device::kExperimentalBluetoothDeviceInterface,
           callback) {
 }
 
 FakeBluetoothDeviceClient::Properties::~Properties() {
 }
@@ skipping 240 matching lines @@
   } else if (object_path == dbus::ObjectPath(kWeirdDevicePath)) {
     // Request a Passkey from the user.
     agent_service_provider->RequestPasskey(
         object_path,
         base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback,
                    base::Unretained(this),
                    object_path,
                    callback,
                    error_callback));
 
+  } else if (object_path == dbus::ObjectPath(kUnpairableDevicePath)) {
+    // Fails the pairing with an org.bluez.Error.Failed error.
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing,
+                   base::Unretained(this),
+                   object_path, error_callback),
+        base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
+
   } else {
     error_callback.Run(kNoResponseError, "No pairing fake");
   }
 }
 
 void FakeBluetoothDeviceClient::CancelPairing(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "CancelPairing: " << object_path.value();
@@ skipping 260 matching lines @@
       properties->adapter.ReplaceValue(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
       properties_map_[dbus::ObjectPath(kUnconnectableDevicePath)] = properties;
       device_list_.push_back(dbus::ObjectPath(kUnconnectableDevicePath));
       FOR_EACH_OBSERVER(
           ExperimentalBluetoothDeviceClient::Observer, observers_,
           DeviceAdded(dbus::ObjectPath(kUnconnectableDevicePath)));
     }
 
+    if (std::find(device_list_.begin(), device_list_.end(),
+                  dbus::ObjectPath(kUnpairableDevicePath)) ==
+        device_list_.end()) {
+      Properties* properties = new Properties(base::Bind(
+          &FakeBluetoothDeviceClient::OnPropertyChanged,
+          base::Unretained(this),
+          dbus::ObjectPath(kUnpairableDevicePath)));
+      properties->address.ReplaceValue(kUnpairableDeviceAddress);
+      properties->bluetooth_class.ReplaceValue(kUnpairableDeviceClass);
+      properties->name.ReplaceValue("Fake Unpairable Device");
+      properties->alias.ReplaceValue(kUnpairableDeviceName);
+      properties->adapter.ReplaceValue(
+          dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
+
+      properties_map_[dbus::ObjectPath(kUnpairableDevicePath)] = properties;
+      device_list_.push_back(dbus::ObjectPath(kUnpairableDevicePath));
+      FOR_EACH_OBSERVER(
+          ExperimentalBluetoothDeviceClient::Observer, observers_,
+          DeviceAdded(dbus::ObjectPath(kUnpairableDevicePath)));
+    }
+
   } else if (discovery_simulation_step_ == 13) {
     RemoveDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
                  dbus::ObjectPath(kVanishingDevicePath));
 
   } else if (discovery_simulation_step_ == 14) {
     return;
 
   }
 
   ++discovery_simulation_step_;
@@ skipping 45 matching lines @@
 
 void FakeBluetoothDeviceClient::RejectSimulatedPairing(
     const dbus::ObjectPath& object_path,
     const ErrorCallback& error_callback) {
   VLOG(1) << "RejectSimulatedPairing: " << object_path.value();
 
   error_callback.Run(bluetooth_adapter::kErrorAuthenticationRejected,
                      "Rejected");
 }
 
+void FakeBluetoothDeviceClient::FailSimulatedPairing(
+    const dbus::ObjectPath& object_path,
+    const ErrorCallback& error_callback) {
+  VLOG(1) << "FailSimulatedPairing: " << object_path.value();
+
+  error_callback.Run(bluetooth_adapter::kErrorFailed, "Failed");
+}
+
 void FakeBluetoothDeviceClient::AddInputDeviceIfNeeded(
     const dbus::ObjectPath& object_path,
     Properties* properties) {
   // If the paired device is a HID device based on it's bluetooth class,
   // simulate the Input interface.
   FakeBluetoothInputClient* fake_bluetooth_input_client =
       static_cast<FakeBluetoothInputClient*>(
           DBusThreadManager::Get()->GetExperimentalBluetoothInputClient());
 
   if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500)
@@ skipping 138 matching lines @@
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 }  // namespace chromeos