The Tor Browser: dom/bluetooth/bluez/BluetoothDBusService.cpp@b8a032363ba2 (annotated)

dom/bluetooth/bluez/BluetoothDBusService.cpp@b8a032363ba2 (annotated)

dom/bluetooth/bluez/BluetoothDBusService.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /*
 ** Copyright 2006, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 #include "base/basictypes.h"
 #include "BluetoothDBusService.h"
 #include "BluetoothA2dpManager.h"
 #include "BluetoothHfpManager.h"
 #include "BluetoothHidManager.h"
 #include "BluetoothOppManager.h"
 #include "BluetoothProfileController.h"
 #include "BluetoothReplyRunnable.h"
 #include "BluetoothUnixSocketConnector.h"
 #include "BluetoothUtils.h"
 #include "BluetoothUuid.h"
 #include <cstdio>
 #include <dbus/dbus.h>
 #include "nsAutoPtr.h"
 #include "nsThreadUtils.h"
 #include "nsDebug.h"
 #include "nsDataHashtable.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/dom/bluetooth/BluetoothTypes.h"
 #include "mozilla/Hal.h"
 #include "mozilla/ipc/UnixSocket.h"
 #include "mozilla/ipc/DBusUtils.h"
 #include "mozilla/ipc/RawDBusConnection.h"
 #include "mozilla/LazyIdleThread.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/NullPtr.h"
 #include "mozilla/StaticMutex.h"
 #include "mozilla/unused.h"
 #if defined(MOZ_WIDGET_GONK)
 #include "cutils/properties.h"
 #include <dlfcn.h>
 #endif
 /**
  * Some rules for dealing with memory in DBus:
  * - A DBusError only needs to be deleted if it's been set, not just
  *   initialized. This is why LOG_AND_FREE... is called only when an error is
  *   set, and the macro cleans up the error itself.
  * - A DBusMessage needs to be unrefed when it is newed explicitly. DBusMessages
  *   from signals do not need to be unrefed, as they will be cleaned by DBus
  *   after DBUS_HANDLER_RESULT_HANDLED is returned from the filter.
  */
 using namespace mozilla;
 using namespace mozilla::ipc;
 USING_BLUETOOTH_NAMESPACE
 #define B2G_AGENT_CAPABILITIES "DisplayYesNo"
 #define DBUS_MANAGER_IFACE BLUEZ_DBUS_BASE_IFC  ".Manager"
 #define DBUS_ADAPTER_IFACE BLUEZ_DBUS_BASE_IFC  ".Adapter"
 #define DBUS_DEVICE_IFACE  BLUEZ_DBUS_BASE_IFC  ".Device"
 #define DBUS_AGENT_IFACE   BLUEZ_DBUS_BASE_IFC  ".Agent"
 #define DBUS_SINK_IFACE    BLUEZ_DBUS_BASE_IFC  ".AudioSink"
 #define DBUS_CTL_IFACE     BLUEZ_DBUS_BASE_IFC  ".Control"
 #define DBUS_INPUT_IFACE   BLUEZ_DBUS_BASE_IFC  ".Input"
 #define BLUEZ_DBUS_BASE_PATH      "/org/bluez"
 #define BLUEZ_DBUS_BASE_IFC       "org.bluez"
 #define BLUEZ_ERROR_IFC           "org.bluez.Error"
 #define ERR_A2DP_IS_DISCONNECTED      "A2dpIsDisconnected"
 #define ERR_AVRCP_IS_DISCONNECTED     "AvrcpIsDisconnected"
 /**
  * To not lock Bluetooth switch button on Settings UI because of any accident,
  * we will force disabling Bluetooth 5 seconds after the user requesting to
  * turn off Bluetooth.
  */
 #define TIMEOUT_FORCE_TO_DISABLE_BT 5
 #define BT_LAZY_THREAD_TIMEOUT_MS 3000
 #ifdef MOZ_WIDGET_GONK
 class Bluedroid
 {
   struct ScopedDlHandleTraits
   {
     typedef void* type;
     static void* empty()
     {
       return nullptr;
     }
     static void release(void* handle)
     {
       if (!handle) {
         return;
       }
       int res = dlclose(handle);
       if (res) {
         BT_WARNING("Failed to close libbluedroid.so: %s", dlerror());
       }
     }
   };
 public:
   Bluedroid()
   : m_bt_enable(nullptr)
   , m_bt_disable(nullptr)
   , m_bt_is_enabled(nullptr)
   {}
   bool Enable()
   {
     MOZ_ASSERT(!NS_IsMainThread()); // BT thread
     if (!mHandle && !Init()) {
       return false;
     } else if (m_bt_is_enabled() == 1) {
       return true;
     }
     // 0 == success, -1 == error
     return !m_bt_enable();
   }
   bool Disable()
   {
     MOZ_ASSERT(!NS_IsMainThread()); // BT thread
     if (!IsEnabled()) {
       return true;
     }
     // 0 == success, -1 == error
     return !m_bt_disable();
   }
   bool IsEnabled() const
   {
     MOZ_ASSERT(!NS_IsMainThread()); // BT thread
     if (!mHandle) {
       return false;
     }
     // 1 == enabled, 0 == disabled, -1 == error
     return m_bt_is_enabled() > 0;
   }
 private:
   bool Init()
   {
     MOZ_ASSERT(!mHandle);
     Scoped<ScopedDlHandleTraits> handle(dlopen("libbluedroid.so", RTLD_LAZY));
     if (!handle) {
       BT_WARNING("Failed to open libbluedroid.so: %s", dlerror());
       return false;
     }
     int (*bt_enable)() = (int (*)())dlsym(handle, "bt_enable");
     if (!bt_enable) {
       BT_WARNING("Failed to lookup bt_enable: %s", dlerror());
       return false;
     }
     int (*bt_disable)() = (int (*)())dlsym(handle, "bt_disable");
     if (!bt_disable) {
       BT_WARNING("Failed to lookup bt_disable: %s", dlerror());
       return false;
     }
     int (*bt_is_enabled)() = (int (*)())dlsym(handle, "bt_is_enabled");
     if (!bt_is_enabled) {
       BT_WARNING("Failed to lookup bt_is_enabled: %s", dlerror());
       return false;
     }
     m_bt_enable = bt_enable;
     m_bt_disable = bt_disable;
     m_bt_is_enabled = bt_is_enabled;
     mHandle.reset(handle.forget());
     return true;
   }
   Scoped<ScopedDlHandleTraits> mHandle;
   int (* m_bt_enable)(void);
   int (* m_bt_disable)(void);
   int (* m_bt_is_enabled)(void);
 };
 //
 // BT-thread-only variables
 //
 // The variables below must only be accessed from within the BT thread.
 //
 static class Bluedroid sBluedroid;
 #endif
 //
 // Read-only constants
 //
 // The constants below are read-only and may be accessed from any
 // thread. Most of the contain DBus state or settings, so keep them
 // on the I/O thread if somehow possible.
 //
 typedef struct {
   const char* name;
   int type;
 } Properties;
 static const Properties sDeviceProperties[] = {
   {"Address", DBUS_TYPE_STRING},
   {"Name", DBUS_TYPE_STRING},
   {"Icon", DBUS_TYPE_STRING},
   {"Class", DBUS_TYPE_UINT32},
   {"UUIDs", DBUS_TYPE_ARRAY},
   {"Paired", DBUS_TYPE_BOOLEAN},
   {"Connected", DBUS_TYPE_BOOLEAN},
   {"Trusted", DBUS_TYPE_BOOLEAN},
   {"Blocked", DBUS_TYPE_BOOLEAN},
   {"Alias", DBUS_TYPE_STRING},
   {"Nodes", DBUS_TYPE_ARRAY},
   {"Adapter", DBUS_TYPE_OBJECT_PATH},
   {"LegacyPairing", DBUS_TYPE_BOOLEAN},
   {"RSSI", DBUS_TYPE_INT16},
   {"TX", DBUS_TYPE_UINT32},
   {"Type", DBUS_TYPE_STRING},
   {"Broadcaster", DBUS_TYPE_BOOLEAN},
   {"Services", DBUS_TYPE_ARRAY}
 };
 static const Properties sAdapterProperties[] = {
   {"Address", DBUS_TYPE_STRING},
   {"Name", DBUS_TYPE_STRING},
   {"Class", DBUS_TYPE_UINT32},
   {"Powered", DBUS_TYPE_BOOLEAN},
   {"Discoverable", DBUS_TYPE_BOOLEAN},
   {"DiscoverableTimeout", DBUS_TYPE_UINT32},
   {"Pairable", DBUS_TYPE_BOOLEAN},
   {"PairableTimeout", DBUS_TYPE_UINT32},
   {"Discovering", DBUS_TYPE_BOOLEAN},
   {"Devices", DBUS_TYPE_ARRAY},
   {"UUIDs", DBUS_TYPE_ARRAY},
   {"Type", DBUS_TYPE_STRING}
 };
 static const Properties sManagerProperties[] = {
   {"Adapters", DBUS_TYPE_ARRAY},
 };
 static const Properties sSinkProperties[] = {
   {"State", DBUS_TYPE_STRING},
   {"Connected", DBUS_TYPE_BOOLEAN},
   {"Playing", DBUS_TYPE_BOOLEAN}
 };
 static const Properties sControlProperties[] = {
   {"Connected", DBUS_TYPE_BOOLEAN}
 };
 static const Properties sInputProperties[] = {
   {"Connected", DBUS_TYPE_BOOLEAN}
 };
 static const char* const sBluetoothDBusIfaces[] = {
   DBUS_MANAGER_IFACE,
   DBUS_ADAPTER_IFACE,
   DBUS_DEVICE_IFACE
 };
 static const char* const sBluetoothDBusSignals[] = {
   "type='signal',interface='org.freedesktop.DBus'",
   "type='signal',interface='org.bluez.Adapter'",
   "type='signal',interface='org.bluez.Manager'",
   "type='signal',interface='org.bluez.Device'",
   "type='signal',interface='org.bluez.Input'",
   "type='signal',interface='org.bluez.Network'",
   "type='signal',interface='org.bluez.NetworkServer'",
   "type='signal',interface='org.bluez.HealthDevice'",
   "type='signal',interface='org.bluez.AudioSink'",
   "type='signal',interface='org.bluez.Control'"
 };
 // Only A2DP and HID are authorized.
 static const BluetoothServiceClass sAuthorizedServiceClass[] = {
   BluetoothServiceClass::A2DP,
   BluetoothServiceClass::HID
 };
 /**
  * The adapter name may not be ready whenever event 'AdapterAdded' is received,
  * so we'd like to wait for a bit. Only used on main thread.
  */
 static const int sWaitingForAdapterNameInterval = 1000; // unit: ms
 //
 // main-thread-only variables
 //
 // The variables below must be accessed from within the main thread.
 //
 // A queue for connect/disconnect request. See Bug 913372 for details.
 static nsTArray<nsRefPtr<BluetoothProfileController> > sControllerArray;
 //
 // I/O-thread-only variables
 //
 // The variables below must be accessed from within the I/O thread.
 //
 // The DBus connection to the BlueZ daemon
 static StaticAutoPtr<RawDBusConnection> sDBusConnection;
 // Keep the pairing requests.
 static unsigned int sIsPairing = 0;
 static nsDataHashtable<nsStringHashKey, DBusMessage* >* sPairingReqTable;
 // The object path of the adapter that should
 // be updated after switching Bluetooth.
 static nsString sAdapterPath;
 //
 // The variables below are currently accessed from within multiple
 // threads and should be moved to one specific thread if possible.
 //
 // TODO: Concurrency control is implemented by locking. Maybe there's
 //       a non-blocking way to implement this.
 //
 // Disconnect all profiles before turning off Bluetooth. Please see Bug 891257
 // for more details. |sStopBluetoothMonitor| protects access to this variable.
 static int sConnectedDeviceCount = 0;
 static StaticAutoPtr<Monitor> sStopBluetoothMonitor;
 // Protects against bug 969447.
 static StaticAutoPtr<Monitor> sGetPropertyMonitor;
 typedef void (*UnpackFunc)(DBusMessage*, DBusError*, BluetoothValue&, nsAString&);
 typedef bool (*FilterFunc)(const BluetoothValue&);
 static void
 DispatchToDBusThread(Task* task)
 {
   XRE_GetIOMessageLoop()->PostTask(FROM_HERE, task);
 }
 static nsresult
 DispatchToBtThread(nsIRunnable* aRunnable)
 {
   /* Due to the fact that the startup and shutdown of the Bluetooth
    * system can take an indefinite amount of time, a separate thread
    * is used for running blocking calls. The thread is not intended
    * for regular Bluetooth operations though.
    */
   static StaticRefPtr<LazyIdleThread> sBluetoothThread;
   MOZ_ASSERT(NS_IsMainThread());
   if (!sBluetoothThread) {
     sBluetoothThread = new LazyIdleThread(BT_LAZY_THREAD_TIMEOUT_MS,
                                           NS_LITERAL_CSTRING("BluetoothDBusService"),
                                           LazyIdleThread::ManualShutdown);
   }
   return sBluetoothThread->Dispatch(aRunnable, NS_DISPATCH_NORMAL);
 }
 BluetoothDBusService::BluetoothDBusService()
 {
   sGetPropertyMonitor = new Monitor("BluetoothService.sGetPropertyMonitor");
   sStopBluetoothMonitor = new Monitor("BluetoothService.sStopBluetoothMonitor");
 }
 BluetoothDBusService::~BluetoothDBusService()
 {
   sStopBluetoothMonitor = nullptr;
   sGetPropertyMonitor = nullptr;
 }
 static bool
 GetConnectedDevicesFilter(const BluetoothValue& aValue)
 {
   // We don't have to filter device here
   return true;
 }
 static bool
 GetPairedDevicesFilter(const BluetoothValue& aValue)
 {
   // Check property 'Paired' and only paired device will be returned
   if (aValue.type() != BluetoothValue::TArrayOfBluetoothNamedValue) {
     BT_WARNING("Not a BluetoothNamedValue array!");
     return false;
   }
   const InfallibleTArray<BluetoothNamedValue>& deviceProperties =
     aValue.get_ArrayOfBluetoothNamedValue();
   uint32_t length = deviceProperties.Length();
   for (uint32_t p = 0; p < length; ++p) {
     if (deviceProperties[p].name().EqualsLiteral("Paired")) {
       return deviceProperties[p].value().get_bool();
     }
   }
   return false;
 }
 class DistributeBluetoothSignalTask : public nsRunnable
 {
 public:
   DistributeBluetoothSignalTask(const BluetoothSignal& aSignal)
     : mSignal(aSignal)
   {
   }
   nsresult Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     BluetoothService* bs = BluetoothService::Get();
     NS_ENSURE_TRUE(bs, NS_ERROR_FAILURE);
     bs->DistributeSignal(mSignal);
     return NS_OK;
   }
 private:
   BluetoothSignal mSignal;
 };
 class ControlPropertyChangedHandler : public nsRunnable
 {
 public:
   ControlPropertyChangedHandler(const BluetoothSignal& aSignal)
     : mSignal(aSignal)
   {
   }
   nsresult Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (mSignal.value().type() != BluetoothValue::TArrayOfBluetoothNamedValue) {
        BT_WARNING("Wrong value type for ControlPropertyChangedHandler");
        return NS_ERROR_FAILURE;
     }
     InfallibleTArray<BluetoothNamedValue>& arr =
       mSignal.value().get_ArrayOfBluetoothNamedValue();
     MOZ_ASSERT(arr[0].name().EqualsLiteral("Connected"));
     MOZ_ASSERT(arr[0].value().type() == BluetoothValue::Tbool);
     bool connected = arr[0].value().get_bool();
     BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
     NS_ENSURE_TRUE(a2dp, NS_ERROR_FAILURE);
     a2dp->SetAvrcpConnected(connected);
     return NS_OK;
   }
 private:
   BluetoothSignal mSignal;
 };
 class SinkPropertyChangedHandler : public nsRunnable
 {
 public:
   SinkPropertyChangedHandler(const BluetoothSignal& aSignal)
     : mSignal(aSignal)
   {
   }
   NS_IMETHOD
   Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(mSignal.name().EqualsLiteral("PropertyChanged"));
     MOZ_ASSERT(mSignal.value().type() ==
                BluetoothValue::TArrayOfBluetoothNamedValue);
     // Replace object path with device address
     nsString address = GetAddressFromObjectPath(mSignal.path());
     mSignal.path() = address;
     BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
     NS_ENSURE_TRUE(a2dp, NS_ERROR_FAILURE);
     a2dp->HandleSinkPropertyChanged(mSignal);
     return NS_OK;
   }
 private:
   BluetoothSignal mSignal;
 };
 class InputPropertyChangedHandler : public nsRunnable
 {
 public:
   InputPropertyChangedHandler(const BluetoothSignal& aSignal)
     : mSignal(aSignal)
   {
   }
   NS_IMETHOD
   Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(mSignal.name().EqualsLiteral("PropertyChanged"));
     MOZ_ASSERT(mSignal.value().type() == BluetoothValue::TArrayOfBluetoothNamedValue);
     // Replace object path with device address
     nsString address = GetAddressFromObjectPath(mSignal.path());
     mSignal.path() = address;
     BluetoothHidManager* hid = BluetoothHidManager::Get();
     NS_ENSURE_TRUE(hid, NS_ERROR_FAILURE);
     hid->HandleInputPropertyChanged(mSignal);
     return NS_OK;
   }
 private:
   BluetoothSignal mSignal;
 };
 class TryFiringAdapterAddedTask : public Task
 {
 public:
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(NS_IsMainThread());
     BluetoothService* bs = BluetoothService::Get();
     NS_ENSURE_TRUE_VOID(bs);
     bs->AdapterAddedReceived();
     bs->TryFiringAdapterAdded();
   }
 };
 class TryFiringAdapterAddedRunnable : public nsRunnable
 {
 public:
   TryFiringAdapterAddedRunnable(bool aDelay)
     : mDelay(aDelay)
   { }
   nsresult Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (mDelay) {
       MessageLoop::current()->
         PostDelayedTask(FROM_HERE, new TryFiringAdapterAddedTask(),
                         sWaitingForAdapterNameInterval);
     } else {
       MessageLoop::current()->
         PostTask(FROM_HERE, new TryFiringAdapterAddedTask());
     }
     return NS_OK;
   }
 private:
   bool mDelay;
 };
 static bool
 IsDBusMessageError(DBusMessage* aMsg, DBusError* aErr, nsAString& aErrorStr)
 {
   if (aErr && dbus_error_is_set(aErr)) {
     aErrorStr = NS_ConvertUTF8toUTF16(aErr->message);
     LOG_AND_FREE_DBUS_ERROR(aErr);
     return true;
   }
   DBusError err;
   dbus_error_init(&err);
   if (dbus_message_get_type(aMsg) == DBUS_MESSAGE_TYPE_ERROR) {
     const char* error_msg;
     if (!dbus_message_get_args(aMsg, &err, DBUS_TYPE_STRING,
                                &error_msg, DBUS_TYPE_INVALID) ||
         !error_msg) {
       if (dbus_error_is_set(&err)) {
         aErrorStr = NS_ConvertUTF8toUTF16(err.message);
         LOG_AND_FREE_DBUS_ERROR(&err);
         return true;
       } else {
         aErrorStr.AssignLiteral("Unknown Error");
         return true;
       }
     } else {
       aErrorStr = NS_ConvertUTF8toUTF16(error_msg);
       return true;
     }
   }
   return false;
 }
 static void
 UnpackObjectPathMessage(DBusMessage* aMsg, DBusError* aErr,
                         BluetoothValue& aValue, nsAString& aErrorStr)
 {
   DBusError err;
   dbus_error_init(&err);
   if (!IsDBusMessageError(aMsg, aErr, aErrorStr)) {
     MOZ_ASSERT(dbus_message_get_type(aMsg) == DBUS_MESSAGE_TYPE_METHOD_RETURN,
                "Got dbus callback that's not a METHOD_RETURN!");
     const char* object_path;
     if (!dbus_message_get_args(aMsg, &err, DBUS_TYPE_OBJECT_PATH,
                                &object_path, DBUS_TYPE_INVALID) ||
         !object_path) {
       if (dbus_error_is_set(&err)) {
         aErrorStr = NS_ConvertUTF8toUTF16(err.message);
         LOG_AND_FREE_DBUS_ERROR(&err);
       }
     } else {
       aValue = NS_ConvertUTF8toUTF16(object_path);
     }
   }
 }
 class PrepareProfileManagersRunnable : public nsRunnable
 {
 public:
   nsresult Run()
   {
     BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
     if (!hfp || !hfp->Listen()) {
       BT_WARNING("Failed to start listening for BluetoothHfpManager!");
       return NS_ERROR_FAILURE;
     }
     BluetoothOppManager* opp = BluetoothOppManager::Get();
     if (!opp || !opp->Listen()) {
       BT_WARNING("Failed to start listening for BluetoothOppManager!");
       return NS_ERROR_FAILURE;
     }
     BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
     NS_ENSURE_TRUE(a2dp, NS_ERROR_FAILURE);
     a2dp->Reset();
     return NS_OK;
   }
 };
 static void
 RunDBusCallback(DBusMessage* aMsg, void* aBluetoothReplyRunnable,
                 UnpackFunc aFunc)
 {
 #ifdef MOZ_WIDGET_GONK
   // Due to the fact that we're running two dbus loops on desktop implicitly by
   // being gtk based, sometimes we'll get signals/reply coming in on the main
   // thread. There's not a lot we can do about that for the time being and it
   // (technically) shouldn't hurt anything. However, on gonk, die.
   MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
 #endif
   nsRefPtr<BluetoothReplyRunnable> replyRunnable =
     dont_AddRef(static_cast< BluetoothReplyRunnable* >(aBluetoothReplyRunnable));
   MOZ_ASSERT(replyRunnable, "Callback reply runnable is null!");
   nsAutoString replyError;
   BluetoothValue v;
   aFunc(aMsg, nullptr, v, replyError);
   // Bug 941462. When blueZ replys 'I/O error', we treat it as 'internal error'.
   // This usually happned when the first pairing request has not yet finished,
   // the second pairing request issued immediately.
   if (replyError.EqualsLiteral("I/O error")) {
     replyError.AssignLiteral(ERR_INTERNAL_ERROR);
   }
   DispatchBluetoothReply(replyRunnable, v, replyError);
 }
 static void
 GetObjectPathCallback(DBusMessage* aMsg, void* aBluetoothReplyRunnable)
 {
   if (sIsPairing) {
     RunDBusCallback(aMsg, aBluetoothReplyRunnable,
                     UnpackObjectPathMessage);
     sIsPairing--;
   }
 }
 static void
 UnpackVoidMessage(DBusMessage* aMsg, DBusError* aErr, BluetoothValue& aValue,
                   nsAString& aErrorStr)
 {
   DBusError err;
   dbus_error_init(&err);
   if (!IsDBusMessageError(aMsg, aErr, aErrorStr) &&
       dbus_message_get_type(aMsg) == DBUS_MESSAGE_TYPE_METHOD_RETURN &&
       !dbus_message_get_args(aMsg, &err, DBUS_TYPE_INVALID)) {
     if (dbus_error_is_set(&err)) {
       aErrorStr = NS_ConvertUTF8toUTF16(err.message);
       LOG_AND_FREE_DBUS_ERROR(&err);
     }
   }
   aValue = aErrorStr.IsEmpty();
 }
 static void
 GetVoidCallback(DBusMessage* aMsg, void* aBluetoothReplyRunnable)
 {
   RunDBusCallback(aMsg, aBluetoothReplyRunnable,
                   UnpackVoidMessage);
 }
 class ReplyErrorToProfileManager : public nsRunnable
 {
 public:
   ReplyErrorToProfileManager(BluetoothServiceClass aServiceClass,
                              bool aConnect,
                              const nsAString& aErrorString)
     : mServiceClass(aServiceClass)
     , mConnect(aConnect)
     , mErrorString(aErrorString)
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
   }
   nsresult Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     BluetoothProfileManagerBase* profile;
     if (mServiceClass == BluetoothServiceClass::HID) {
       profile = BluetoothHidManager::Get();
     } else if (mServiceClass == BluetoothServiceClass::A2DP) {
       profile = BluetoothA2dpManager::Get();
     } else {
       MOZ_ASSERT(false);
       return NS_ERROR_FAILURE;
     }
     if (mConnect) {
       profile->OnConnect(mErrorString);
     } else {
       profile->OnDisconnect(mErrorString);
     }
     return NS_OK;
   }
 private:
   BluetoothServiceClass mServiceClass;
   bool mConnect;
   nsString mErrorString;
 };
 static void
 CheckDBusReply(DBusMessage* aMsg, void* aServiceClass, bool aConnect)
 {
   MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
   NS_ENSURE_TRUE_VOID(aMsg);
   BluetoothValue v;
   nsAutoString replyError;
   UnpackVoidMessage(aMsg, nullptr, v, replyError);
   nsAutoPtr<BluetoothServiceClass> serviceClass(
     static_cast<BluetoothServiceClass*>(aServiceClass));
   if (!replyError.IsEmpty()) {
     NS_DispatchToMainThread(
       new ReplyErrorToProfileManager(*serviceClass, aConnect, replyError));
   }
 }
 static void
 InputConnectCallback(DBusMessage* aMsg, void* aParam)
 {
   CheckDBusReply(aMsg, aParam, true);
 }
 static void
 InputDisconnectCallback(DBusMessage* aMsg, void* aParam)
 {
   CheckDBusReply(aMsg, aParam, false);
 }
 static void
 SinkConnectCallback(DBusMessage* aMsg, void* aParam)
 {
   CheckDBusReply(aMsg, aParam, true);
 }
 static void
 SinkDisconnectCallback(DBusMessage* aMsg, void* aParam)
 {
   CheckDBusReply(aMsg, aParam, false);
 }
 static bool
 HasAudioService(uint32_t aCodValue)
 {
   return ((aCodValue & 0x200000) == 0x200000);
 }
 static bool
 ContainsIcon(const InfallibleTArray<BluetoothNamedValue>& aProperties)
 {
   for (uint8_t i = 0; i < aProperties.Length(); i++) {
     if (aProperties[i].name().EqualsLiteral("Icon")) {
       return true;
     }
   }
   return false;
 }
 static bool
 GetProperty(DBusMessageIter aIter, const Properties* aPropertyTypes,
             int aPropertyTypeLen, int* aPropIndex,
             InfallibleTArray<BluetoothNamedValue>& aProperties)
 {
   /**
    * Ensure GetProperty runs in critical section otherwise
    * crash due to timing issue occurs when BT is enabled.
    *
    * TODO: Revise GetProperty to solve the crash
    */
   MonitorAutoLock lock(*sGetPropertyMonitor);
   DBusMessageIter prop_val, array_val_iter;
   char* property = nullptr;
   uint32_t array_type;
   int i, expectedType, receivedType;
   if (dbus_message_iter_get_arg_type(&aIter) != DBUS_TYPE_STRING) {
     return false;
   }
   dbus_message_iter_get_basic(&aIter, &property);
   if (!dbus_message_iter_next(&aIter) ||
       dbus_message_iter_get_arg_type(&aIter) != DBUS_TYPE_VARIANT) {
     return false;
   }
   for (i = 0; i < aPropertyTypeLen; i++) {
     if (!strncmp(property, aPropertyTypes[i].name, strlen(property))) {
       break;
     }
   }
   if (i == aPropertyTypeLen) {
     BT_LOGR("unknown property: %s", property);
     return false;
   }
   nsAutoString propertyName;
   propertyName.AssignASCII(aPropertyTypes[i].name);
   *aPropIndex = i;
   // Preprocessing
   dbus_message_iter_recurse(&aIter, &prop_val);
   expectedType = aPropertyTypes[*aPropIndex].type;
   receivedType = dbus_message_iter_get_arg_type(&prop_val);
   /**
    * Bug 857896. Since device property "Connected" could be a boolean value or
    * an 2-byte array, we need to check the value type here and convert the
    * first byte into a boolean manually.
    */
   bool convert = false;
   if (propertyName.EqualsLiteral("Connected") &&
       receivedType == DBUS_TYPE_ARRAY) {
     MOZ_ASSERT(aPropertyTypes == sDeviceProperties);
     convert = true;
   }
   if ((receivedType != expectedType) && !convert) {
     BT_WARNING("Iterator not type we expect! Property name: %s,"
       "Property Type Expected: %d, Property Type Received: %d",
       NS_ConvertUTF16toUTF8(propertyName).get(), expectedType, receivedType);
     return false;
   }
   // Extract data
   BluetoothValue propertyValue;
   switch (receivedType) {
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
       const char* c;
       dbus_message_iter_get_basic(&prop_val, &c);
       propertyValue = NS_ConvertUTF8toUTF16(c);
       break;
     case DBUS_TYPE_UINT32:
     case DBUS_TYPE_INT16:
       uint32_t i;
       dbus_message_iter_get_basic(&prop_val, &i);
       propertyValue = i;
       break;
     case DBUS_TYPE_BOOLEAN:
       bool b;
       dbus_message_iter_get_basic(&prop_val, &b);
       propertyValue = b;
       break;
     case DBUS_TYPE_ARRAY:
       dbus_message_iter_recurse(&prop_val, &array_val_iter);
       array_type = dbus_message_iter_get_arg_type(&array_val_iter);
       if (array_type == DBUS_TYPE_OBJECT_PATH ||
           array_type == DBUS_TYPE_STRING) {
         InfallibleTArray<nsString> arr;
         do {
           const char* tmp;
           dbus_message_iter_get_basic(&array_val_iter, &tmp);
           nsAutoString s;
           s = NS_ConvertUTF8toUTF16(tmp);
           arr.AppendElement(s);
         } while (dbus_message_iter_next(&array_val_iter));
         propertyValue = arr;
       } else if (array_type == DBUS_TYPE_BYTE) {
         InfallibleTArray<uint8_t> arr;
         do {
           uint8_t tmp;
           dbus_message_iter_get_basic(&array_val_iter, &tmp);
           arr.AppendElement(tmp);
         } while (dbus_message_iter_next(&array_val_iter));
         propertyValue = arr;
       } else {
         // This happens when the array is 0-length. Apparently we get a
         // DBUS_TYPE_INVALID type.
         propertyValue = InfallibleTArray<nsString>();
       }
       break;
     default:
       NS_NOTREACHED("Cannot find dbus message type!");
   }
   // Postprocessing
   if (convert) {
     MOZ_ASSERT(propertyValue.type() == BluetoothValue::TArrayOfuint8_t);
     bool b = propertyValue.get_ArrayOfuint8_t()[0];
     propertyValue = BluetoothValue(b);
   } else if (propertyName.EqualsLiteral("Devices")) {
     MOZ_ASSERT(aPropertyTypes == sAdapterProperties);
     MOZ_ASSERT(propertyValue.type() == BluetoothValue::TArrayOfnsString);
     uint32_t length = propertyValue.get_ArrayOfnsString().Length();
     for (uint32_t i= 0; i < length; i++) {
       nsString& data = propertyValue.get_ArrayOfnsString()[i];
       data = GetAddressFromObjectPath(data);
     }
   }
   aProperties.AppendElement(BluetoothNamedValue(propertyName, propertyValue));
   return true;
 }
 static void
 ParseProperties(DBusMessageIter* aIter,
                 BluetoothValue& aValue,
                 nsAString& aErrorStr,
                 const Properties* aPropertyTypes,
                 const int aPropertyTypeLen)
 {
   DBusMessageIter dict_entry, dict;
   int prop_index = -1;
   MOZ_ASSERT(dbus_message_iter_get_arg_type(aIter) == DBUS_TYPE_ARRAY,
              "Trying to parse a property from sth. that's not an array");
   dbus_message_iter_recurse(aIter, &dict);
   InfallibleTArray<BluetoothNamedValue> props;
   do {
     MOZ_ASSERT(dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY,
                "Trying to parse a property from sth. that's not an dict!");
     dbus_message_iter_recurse(&dict, &dict_entry);
     if (!GetProperty(dict_entry, aPropertyTypes, aPropertyTypeLen, &prop_index,
                      props)) {
       aErrorStr.AssignLiteral("Can't Create Property!");
       BT_WARNING("Can't create property!");
       return;
     }
   } while (dbus_message_iter_next(&dict));
   aValue = props;
 }
 static bool
 UnpackPropertiesMessage(DBusMessage* aMsg, DBusError* aErr,
                         BluetoothValue& aValue, const char* aIface)
 {
   MOZ_ASSERT(aMsg);
   const Properties* propertyTypes;
   int propertyTypesLength;
   nsAutoString errorStr;
   if (IsDBusMessageError(aMsg, aErr, errorStr) ||
       dbus_message_get_type(aMsg) != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
     BT_WARNING("dbus message has an error.");
     return false;
   }
   DBusMessageIter iter;
   if (!dbus_message_iter_init(aMsg, &iter)) {
     BT_WARNING("Cannot create dbus message iter!");
     return false;
   }
   if (!strcmp(aIface, DBUS_DEVICE_IFACE)) {
     propertyTypes = sDeviceProperties;
     propertyTypesLength = ArrayLength(sDeviceProperties);
   } else if (!strcmp(aIface, DBUS_ADAPTER_IFACE)) {
     propertyTypes = sAdapterProperties;
     propertyTypesLength = ArrayLength(sAdapterProperties);
   } else if (!strcmp(aIface, DBUS_MANAGER_IFACE)) {
     propertyTypes = sManagerProperties;
     propertyTypesLength = ArrayLength(sManagerProperties);
   } else {
     return false;
   }
   ParseProperties(&iter, aValue, errorStr, propertyTypes,
                   propertyTypesLength);
   return true;
 }
 static void
 ParsePropertyChange(DBusMessage* aMsg, BluetoothValue& aValue,
                     nsAString& aErrorStr, const Properties* aPropertyTypes,
                     const int aPropertyTypeLen)
 {
   DBusMessageIter iter;
   DBusError err;
   int prop_index = -1;
   InfallibleTArray<BluetoothNamedValue> props;
   dbus_error_init(&err);
   if (!dbus_message_iter_init(aMsg, &iter)) {
     BT_WARNING("Can't create iterator!");
     return;
   }
   if (!GetProperty(iter, aPropertyTypes, aPropertyTypeLen,
                    &prop_index, props)) {
     BT_WARNING("Can't get property!");
     aErrorStr.AssignLiteral("Can't get property!");
     return;
   }
   aValue = props;
 }
 class AppendDeviceNameReplyHandler: public DBusReplyHandler
 {
 public:
   AppendDeviceNameReplyHandler(const nsCString& aIface,
                                const nsString& aDevicePath,
                                const BluetoothSignal& aSignal)
     : mIface(aIface)
     , mDevicePath(aDevicePath)
     , mSignal(aSignal)
   {
     MOZ_ASSERT(!mIface.IsEmpty());
     MOZ_ASSERT(!mDevicePath.IsEmpty());
   }
   void Handle(DBusMessage* aReply) MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     if (!aReply || (dbus_message_get_type(aReply) == DBUS_MESSAGE_TYPE_ERROR)) {
       return;
     }
     // Get device properties from result of GetProperties
     DBusError err;
     dbus_error_init(&err);
     BluetoothValue deviceProperties;
     bool success = UnpackPropertiesMessage(aReply, &err, deviceProperties,
                                            mIface.get());
     if (!success) {
       BT_WARNING("Failed to get device properties");
       return;
     }
     // First we replace object path with device address.
     InfallibleTArray<BluetoothNamedValue>& parameters =
       mSignal.value().get_ArrayOfBluetoothNamedValue();
     nsString address =
       GetAddressFromObjectPath(mDevicePath);
     parameters[0].name().AssignLiteral("address");
     parameters[0].value() = address;
     // Then we append the device's name to the original signal's data.
     InfallibleTArray<BluetoothNamedValue>& properties =
       deviceProperties.get_ArrayOfBluetoothNamedValue();
     uint32_t i;
     for (i = 0; i < properties.Length(); i++) {
       if (properties[i].name().EqualsLiteral("Name")) {
         properties[i].name().AssignLiteral("name");
         parameters.AppendElement(properties[i]);
         break;
       }
     }
     MOZ_ASSERT_IF(i == properties.Length(), "failed to get device name");
     nsRefPtr<DistributeBluetoothSignalTask> task =
       new DistributeBluetoothSignalTask(mSignal);
     NS_DispatchToMainThread(task);
   }
 private:
   nsCString mIface;
   nsString mDevicePath;
   BluetoothSignal mSignal;
 };
 static void
 AppendDeviceName(BluetoothSignal& aSignal)
 {
   MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
   MOZ_ASSERT(sDBusConnection);
   BluetoothValue v = aSignal.value();
   if (v.type() != BluetoothValue::TArrayOfBluetoothNamedValue ||
       v.get_ArrayOfBluetoothNamedValue().Length() == 0) {
     BT_WARNING("Invalid argument type for AppendDeviceNameRunnable");
     return;
   }
   const InfallibleTArray<BluetoothNamedValue>& arr =
     v.get_ArrayOfBluetoothNamedValue();
   // Device object path should be put in the first element
   if (!arr[0].name().EqualsLiteral("path") ||
        arr[0].value().type() != BluetoothValue::TnsString) {
     BT_WARNING("Invalid object path for AppendDeviceNameRunnable");
     return;
   }
   nsString devicePath = arr[0].value().get_nsString();
   nsRefPtr<AppendDeviceNameReplyHandler> handler =
     new AppendDeviceNameReplyHandler(nsCString(DBUS_DEVICE_IFACE),
                                      devicePath, aSignal);
   bool success = sDBusConnection->SendWithReply(
     AppendDeviceNameReplyHandler::Callback, handler.get(), 1000,
     BLUEZ_DBUS_BASE_IFC, NS_ConvertUTF16toUTF8(devicePath).get(),
     DBUS_DEVICE_IFACE, "GetProperties", DBUS_TYPE_INVALID);
   NS_ENSURE_TRUE_VOID(success);
   unused << handler.forget(); // picked up by callback handler
 }
 class SetPairingConfirmationTask : public Task
 {
 public:
   SetPairingConfirmationTask(const nsAString& aDeviceAddress,
                              bool aConfirm,
                              BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mConfirm(aConfirm)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     nsAutoString errorStr;
     BluetoothValue v = true;
     DBusMessage *msg;
     if (!sPairingReqTable->Get(mDeviceAddress, &msg) && mRunnable) {
       BT_WARNING("%s: Couldn't get original request message.", __FUNCTION__);
       errorStr.AssignLiteral("Couldn't get original request message.");
       DispatchBluetoothReply(mRunnable, v, errorStr);
       return;
     }
     DBusMessage *reply;
     if (mConfirm) {
       reply = dbus_message_new_method_return(msg);
     } else {
       reply = dbus_message_new_error(msg, "org.bluez.Error.Rejected",
                                      "User rejected confirmation");
     }
     if (!reply) {
       BT_WARNING("%s: Memory can't be allocated for the message.", __FUNCTION__);
       dbus_message_unref(msg);
       errorStr.AssignLiteral("Memory can't be allocated for the message.");
       if (mRunnable) {
         DispatchBluetoothReply(mRunnable, v, errorStr);
       }
       return;
     }
     bool result = sDBusConnection->Send(reply);
     if (!result) {
       errorStr.AssignLiteral("Can't send message!");
     }
     dbus_message_unref(msg);
     dbus_message_unref(reply);
     sPairingReqTable->Remove(mDeviceAddress);
     if (mRunnable) {
       DispatchBluetoothReply(mRunnable, v, errorStr);
     }
   }
 private:
   nsString mDeviceAddress;
   bool mConfirm;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 static DBusHandlerResult
 AgentEventFilter(DBusConnection *conn, DBusMessage *msg, void *data)
 {
   if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL) {
     BT_WARNING("%s: agent handler not interested (not a method call).\n",
                __FUNCTION__);
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
   DBusError err;
   dbus_error_init(&err);
   BT_LOGD("%s: %s, %s", __FUNCTION__,
                        dbus_message_get_path(msg),
                        dbus_message_get_member(msg));
   nsString signalPath = NS_ConvertUTF8toUTF16(dbus_message_get_path(msg));
   nsString signalName = NS_ConvertUTF8toUTF16(dbus_message_get_member(msg));
   nsString errorStr;
   BluetoothValue v;
   InfallibleTArray<BluetoothNamedValue> parameters;
   bool isPairingReq = false;
   BluetoothSignal signal(signalName, signalPath, v);
   char *objectPath;
   // The following descriptions of each signal are retrieved from:
   //
   // http://maemo.org/api_refs/5.0/beta/bluez/agent.html
   //
   if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE, "Cancel")) {
     // This method gets called to indicate that the agent request failed before
     // a reply was returned.
     // Return directly
     DBusMessage *reply = dbus_message_new_method_return(msg);
     if (!reply) {
       errorStr.AssignLiteral("Memory can't be allocated for the message.");
       goto handle_error;
     }
     dbus_connection_send(conn, reply, nullptr);
     dbus_message_unref(reply);
     v = parameters;
   } else if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE, "Authorize")) {
     // This method gets called when the service daemon needs to authorize a
     // connection/service request.
     const char *uuid;
     if (!dbus_message_get_args(msg, nullptr,
                                DBUS_TYPE_OBJECT_PATH, &objectPath,
                                DBUS_TYPE_STRING, &uuid,
                                DBUS_TYPE_INVALID)) {
       errorStr.AssignLiteral("Invalid arguments for Authorize() method");
       goto handle_error;
     }
     NS_ConvertUTF8toUTF16 uuidStr(uuid);
     BluetoothServiceClass serviceClass =
       BluetoothUuidHelper::GetBluetoothServiceClass(uuidStr);
     if (serviceClass == BluetoothServiceClass::UNKNOWN) {
       errorStr.AssignLiteral("Failed to get service class");
       goto handle_error;
     }
     DBusMessage* reply = nullptr;
     uint32_t i;
     for (i = 0; i < MOZ_ARRAY_LENGTH(sAuthorizedServiceClass); i++) {
       if (serviceClass == sAuthorizedServiceClass[i]) {
         reply = dbus_message_new_method_return(msg);
         break;
       }
     }
     // The uuid isn't authorized
     if (i == MOZ_ARRAY_LENGTH(sAuthorizedServiceClass)) {
       BT_WARNING("Uuid is not authorized.");
       reply = dbus_message_new_error(msg, "org.bluez.Error.Rejected",
                                      "The uuid is not authorized");
     }
     if (!reply) {
       errorStr.AssignLiteral("Memory can't be allocated for the message.");
       goto handle_error;
     }
     dbus_connection_send(conn, reply, nullptr);
     dbus_message_unref(reply);
     return DBUS_HANDLER_RESULT_HANDLED;
   } else if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE,
                                          "RequestConfirmation")) {
     // This method gets called when the service daemon needs to confirm a
     // passkey for an authentication.
     uint32_t passkey;
     if (!dbus_message_get_args(msg, nullptr,
                                DBUS_TYPE_OBJECT_PATH, &objectPath,
                                DBUS_TYPE_UINT32, &passkey,
                                DBUS_TYPE_INVALID)) {
       errorStr.AssignLiteral("Invalid arguments: RequestConfirmation()");
       goto handle_error;
     }
     parameters.AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("path"),
                           NS_ConvertUTF8toUTF16(objectPath)));
     parameters.AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("method"),
                           NS_LITERAL_STRING("confirmation")));
     parameters.AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("passkey"), passkey));
     v = parameters;
     isPairingReq = true;
   } else if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE,
                                          "RequestPinCode")) {
     // This method gets called when the service daemon needs to get the passkey
     // for an authentication. The return value should be a string of 1-16
     // characters length. The string can be alphanumeric.
     if (!dbus_message_get_args(msg, nullptr,
                                DBUS_TYPE_OBJECT_PATH, &objectPath,
                                DBUS_TYPE_INVALID)) {
       errorStr.AssignLiteral("Invalid arguments for RequestPinCode() method");
       goto handle_error;
     }
     parameters.AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("path"),
                           NS_ConvertUTF8toUTF16(objectPath)));
     parameters.AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("method"),
                           NS_LITERAL_STRING("pincode")));
     v = parameters;
     isPairingReq = true;
   } else if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE,
                                          "RequestPasskey")) {
     // This method gets called when the service daemon needs to get the passkey
     // for an authentication. The return value should be a numeric value
     // between 0-999999.
     if (!dbus_message_get_args(msg, nullptr,
                                DBUS_TYPE_OBJECT_PATH, &objectPath,
                                DBUS_TYPE_INVALID)) {
       errorStr.AssignLiteral("Invalid arguments for RequestPasskey() method");
       goto handle_error;
     }
     parameters.AppendElement(BluetoothNamedValue(
                                NS_LITERAL_STRING("path"),
                                NS_ConvertUTF8toUTF16(objectPath)));
     parameters.AppendElement(BluetoothNamedValue(
                                NS_LITERAL_STRING("method"),
                                NS_LITERAL_STRING("passkey")));
     v = parameters;
     isPairingReq = true;
   } else if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE, "Release")) {
     // This method gets called when the service daemon unregisters the agent.
     // An agent can use it to do cleanup tasks. There is no need to unregister
     // the agent, because when this method gets called it has already been
     // unregistered.
     DBusMessage *reply = dbus_message_new_method_return(msg);
     if (!reply) {
       errorStr.AssignLiteral("Memory can't be allocated for the message.");
       goto handle_error;
     }
     dbus_connection_send(conn, reply, nullptr);
     dbus_message_unref(reply);
     // Do not send a notification to upper layer, too annoying.
     return DBUS_HANDLER_RESULT_HANDLED;
   } else if (dbus_message_is_method_call(msg, DBUS_AGENT_IFACE, "RequestPairingConsent")) {
     // Directly SetPairingconfirmation for RequestPairingConsent here
     if (!dbus_message_get_args(msg, nullptr,
                                DBUS_TYPE_OBJECT_PATH, &objectPath,
                                DBUS_TYPE_INVALID)) {
       errorStr.AssignLiteral("Invalid arguments: RequestPairingConsent()");
       goto handle_error;
     }
     nsString address = GetAddressFromObjectPath(NS_ConvertUTF8toUTF16(objectPath));
     sPairingReqTable->Put(address, msg);
     Task* task = new SetPairingConfirmationTask(address, true, nullptr);
     DispatchToDBusThread(task);
     // Increase dbus message reference counts, it will be decreased in
     // SetPairingConfirmationTask
     dbus_message_ref(msg);
     // Do not send a notification to upper layer
     return DBUS_HANDLER_RESULT_HANDLED;
   } else {
 #ifdef DEBUG
     BT_WARNING("agent handler %s: Unhandled event. Ignore.", __FUNCTION__);
 #endif
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
   if (!errorStr.IsEmpty()) {
     BT_WARNING(NS_ConvertUTF16toUTF8(errorStr).get());
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
   // Update value after parsing DBus message
   signal.value() = v;
   if (isPairingReq) {
     sPairingReqTable->Put(
       GetAddressFromObjectPath(NS_ConvertUTF8toUTF16(objectPath)), msg);
     // Increase ref count here because we need this message later.
     // It'll be unrefed when set*Internal() is called.
     dbus_message_ref(msg);
     AppendDeviceName(signal);
   } else {
     NS_DispatchToMainThread(new DistributeBluetoothSignalTask(signal));
   }
   return DBUS_HANDLER_RESULT_HANDLED;
 handle_error:
   BT_WARNING(NS_ConvertUTF16toUTF8(errorStr).get());
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 class RegisterAgentReplyHandler : public DBusReplyHandler
 {
 public:
   RegisterAgentReplyHandler(const DBusObjectPathVTable* aAgentVTable)
     : mAgentVTable(aAgentVTable)
   {
     MOZ_ASSERT(aAgentVTable);
   }
   void Handle(DBusMessage* aReply)
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     if (!aReply || (dbus_message_get_type(aReply) == DBUS_MESSAGE_TYPE_ERROR)) {
       return;
     }
     // There is no "RegisterAgent" function defined in device interface.
     // When we call "CreatePairedDevice", it will do device agent registration
     // for us. (See maemo.org/api_refs/5.0/beta/bluez/adapter.html)
     if (!dbus_connection_register_object_path(sDBusConnection->GetConnection(),
                                               KEY_REMOTE_AGENT,
                                               mAgentVTable,
                                               nullptr)) {
       BT_WARNING("%s: Can't register object path %s for remote device agent!",
                  __FUNCTION__, KEY_REMOTE_AGENT);
       return;
     }
     NS_DispatchToMainThread(new PrepareProfileManagersRunnable());
   }
 private:
   const DBusObjectPathVTable* mAgentVTable;
 };
 class AddReservedServiceRecordsReplyHandler : public DBusReplyHandler
 {
 public:
   void Handle(DBusMessage* aReply)
   {
     static const DBusObjectPathVTable sAgentVTable = {
       nullptr, AgentEventFilter, nullptr, nullptr, nullptr, nullptr
     };
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     if (!aReply || (dbus_message_get_type(aReply) == DBUS_MESSAGE_TYPE_ERROR)) {
       return;
     }
     // TODO/qdot: This needs to be held for the life of the bluetooth connection
     // so we could clean it up. For right now though, we can throw it away.
     nsTArray<uint32_t> handles;
     ExtractHandles(aReply, handles);
     if(!RegisterAgent(&sAgentVTable)) {
       BT_WARNING("Failed to register agent");
     }
   }
 private:
   void ExtractHandles(DBusMessage *aMessage, nsTArray<uint32_t>& aOutHandles)
   {
     DBusError error;
     int length;
     uint32_t* handles = nullptr;
     dbus_error_init(&error);
     bool success = dbus_message_get_args(aMessage, &error,
                                          DBUS_TYPE_ARRAY,
                                          DBUS_TYPE_UINT32,
                                          &handles, &length,
                                          DBUS_TYPE_INVALID);
     if (success != TRUE) {
       LOG_AND_FREE_DBUS_ERROR(&error);
       return;
     }
     if (!handles) {
       BT_WARNING("Null array in extract_handles");
       return;
     }
     for (int i = 0; i < length; ++i) {
       aOutHandles.AppendElement(handles[i]);
     }
   }
   bool RegisterAgent(const DBusObjectPathVTable* aAgentVTable)
   {
     const char* agentPath = KEY_LOCAL_AGENT;
     const char* capabilities = B2G_AGENT_CAPABILITIES;
     MOZ_ASSERT(sDBusConnection);
     // Local agent means agent for Adapter, not agent for Device. Some signals
     // will be passed to local agent, some will be passed to device agent.
     // For example, if a remote device would like to pair with us, then the
     // signal will be passed to local agent. If we start pairing process with
     // calling CreatePairedDevice, we'll get signal which should be passed to
     // device agent.
     if (!dbus_connection_register_object_path(sDBusConnection->GetConnection(),
                                               KEY_LOCAL_AGENT,
                                               aAgentVTable,
                                               nullptr)) {
       BT_WARNING("%s: Can't register object path %s for agent!",
                  __FUNCTION__, KEY_LOCAL_AGENT);
       return false;
     }
     nsRefPtr<RegisterAgentReplyHandler> handler =
       new RegisterAgentReplyHandler(aAgentVTable);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     bool success = sDBusConnection->SendWithReply(
       RegisterAgentReplyHandler::Callback, handler.get(), -1,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(sAdapterPath).get(),
       DBUS_ADAPTER_IFACE, "RegisterAgent",
       DBUS_TYPE_OBJECT_PATH, &agentPath,
       DBUS_TYPE_STRING, &capabilities,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE(success, false);
     unused << handler.forget(); // picked up by callback handler
     return true;
   }
 };
 class AddReservedServiceRecordsTask : public Task
 {
 public:
   AddReservedServiceRecordsTask()
   { }
   void Run()
   {
     static const dbus_uint32_t sServices[] = {
       BluetoothServiceClass::HANDSFREE_AG,
       BluetoothServiceClass::HEADSET_AG,
       BluetoothServiceClass::OBJECT_PUSH
     };
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     nsRefPtr<DBusReplyHandler> handler =
       new AddReservedServiceRecordsReplyHandler();
     const dbus_uint32_t* services = sServices;
     bool success = sDBusConnection->SendWithReply(
       DBusReplyHandler::Callback, handler.get(), -1,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(sAdapterPath).get(),
       DBUS_ADAPTER_IFACE, "AddReservedServiceRecords",
       DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
       &services, ArrayLength(sServices), DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << handler.forget(); /* picked up by callback handler */
   }
 };
 class PrepareAdapterRunnable : public nsRunnable
 {
 public:
   PrepareAdapterRunnable()
   { }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     Task* task = new AddReservedServiceRecordsTask();
     DispatchToDBusThread(task);
     return NS_OK;
   }
 };
 class RequestPlayStatusTask : public nsRunnable
 {
 public:
   RequestPlayStatusTask()
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
   }
   nsresult Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     BluetoothSignal signal(NS_LITERAL_STRING(REQUEST_MEDIA_PLAYSTATUS_ID),
                            NS_LITERAL_STRING(KEY_ADAPTER),
                            InfallibleTArray<BluetoothNamedValue>());
     BluetoothService* bs = BluetoothService::Get();
     NS_ENSURE_TRUE(bs, NS_ERROR_FAILURE);
     bs->DistributeSignal(signal);
     return NS_OK;
   }
 };
 // Called by dbus during WaitForAndDispatchEventNative()
 // This function is called on the IOThread
 static DBusHandlerResult
 EventFilter(DBusConnection* aConn, DBusMessage* aMsg, void* aData)
 {
   // I/O thread
   MOZ_ASSERT(!NS_IsMainThread(), "Shouldn't be called from Main Thread!");
   if (dbus_message_get_type(aMsg) != DBUS_MESSAGE_TYPE_SIGNAL) {
     BT_WARNING("%s: event handler not interested in %s (not a signal).\n",
         __FUNCTION__, dbus_message_get_member(aMsg));
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
   if (dbus_message_get_path(aMsg) == nullptr) {
     BT_WARNING("DBusMessage %s has no bluetooth destination, ignoring\n",
                dbus_message_get_member(aMsg));
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
   DBusError err;
   dbus_error_init(&err);
   nsAutoString signalPath;
   nsAutoString signalName;
   nsAutoString signalInterface;
   BT_LOGD("%s: %s, %s, %s", __FUNCTION__,
                           dbus_message_get_interface(aMsg),
                           dbus_message_get_path(aMsg),
                           dbus_message_get_member(aMsg));
   signalInterface = NS_ConvertUTF8toUTF16(dbus_message_get_interface(aMsg));
   signalPath = NS_ConvertUTF8toUTF16(dbus_message_get_path(aMsg));
   signalName = NS_ConvertUTF8toUTF16(dbus_message_get_member(aMsg));
   nsString errorStr;
   BluetoothValue v;
   // Since the signalPath extracted from dbus message is a object path,
   // we'd like to re-assign them to corresponding key entry in
   // BluetoothSignalObserverTable
   if (signalInterface.EqualsLiteral(DBUS_MANAGER_IFACE)) {
     signalPath.AssignLiteral(KEY_MANAGER);
   } else if (signalInterface.EqualsLiteral(DBUS_ADAPTER_IFACE)) {
     signalPath.AssignLiteral(KEY_ADAPTER);
   } else if (signalInterface.EqualsLiteral(DBUS_DEVICE_IFACE)){
     signalPath = GetAddressFromObjectPath(signalPath);
   }
   if (dbus_message_is_signal(aMsg, DBUS_ADAPTER_IFACE, "DeviceFound")) {
     DBusMessageIter iter;
     if (!dbus_message_iter_init(aMsg, &iter)) {
       BT_WARNING("Can't create iterator!");
       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
     const char* addr;
     dbus_message_iter_get_basic(&iter, &addr);
     if (!dbus_message_iter_next(&iter)) {
       errorStr.AssignLiteral("Unexpected message struct in msg DeviceFound");
     } else {
       ParseProperties(&iter,
                       v,
                       errorStr,
                       sDeviceProperties,
                       ArrayLength(sDeviceProperties));
       InfallibleTArray<BluetoothNamedValue>& properties =
         v.get_ArrayOfBluetoothNamedValue();
       // The DBus DeviceFound message actually passes back a key value object
       // with the address as the key and the rest of the device properties as
       // a dict value. After we parse out the properties, we need to go back
       // and add the address to the ipdl dict we've created to make sure we
       // have all of the information to correctly build the device.
       nsAutoString address = NS_ConvertUTF8toUTF16(addr);
       properties.AppendElement(
         BluetoothNamedValue(NS_LITERAL_STRING("Address"), address));
       properties.AppendElement(
         BluetoothNamedValue(NS_LITERAL_STRING("Path"),
                             GetObjectPathFromAddress(signalPath, address)));
       if (!ContainsIcon(properties)) {
         for (uint32_t i = 0; i < properties.Length(); i++) {
           // It is possible that property Icon missed due to CoD of major
           // class is TOY but service class is "Audio", we need to assign
           // Icon as audio-card. This is for PTS test TC_AG_COD_BV_02_I.
           // As HFP specification defined that
           // service class is "Audio" can be considered as HFP AG.
           if (properties[i].name().EqualsLiteral("Class")) {
             if (HasAudioService(properties[i].value().get_uint32_t())) {
               v.get_ArrayOfBluetoothNamedValue().AppendElement(
                 BluetoothNamedValue(NS_LITERAL_STRING("Icon"),
                                     NS_LITERAL_STRING("audio-card")));
             }
             break;
           }
         }
       }
     }
   } else if (dbus_message_is_signal(aMsg, DBUS_ADAPTER_IFACE,
                                     "DeviceDisappeared")) {
     const char* str;
     if (!dbus_message_get_args(aMsg, &err,
                                DBUS_TYPE_STRING, &str,
                                DBUS_TYPE_INVALID)) {
       LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, aMsg);
       errorStr.AssignLiteral("Cannot parse device address!");
     } else {
       v = NS_ConvertUTF8toUTF16(str);
     }
   } else if (dbus_message_is_signal(aMsg, DBUS_ADAPTER_IFACE,
                                     "DeviceCreated")) {
     const char* str;
     if (!dbus_message_get_args(aMsg, &err,
                                DBUS_TYPE_OBJECT_PATH, &str,
                                DBUS_TYPE_INVALID)) {
       LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, aMsg);
       errorStr.AssignLiteral("Cannot parse device path!");
     } else {
       v = NS_ConvertUTF8toUTF16(str);
     }
   } else if (dbus_message_is_signal(aMsg, DBUS_ADAPTER_IFACE,
                                     "DeviceRemoved")) {
     const char* str;
     if (!dbus_message_get_args(aMsg, &err,
                                DBUS_TYPE_OBJECT_PATH, &str,
                                DBUS_TYPE_INVALID)) {
       LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, aMsg);
       errorStr.AssignLiteral("Cannot parse device path!");
     } else {
       v = NS_ConvertUTF8toUTF16(str);
     }
   } else if (dbus_message_is_signal(aMsg, DBUS_ADAPTER_IFACE,
                                     "PropertyChanged")) {
     ParsePropertyChange(aMsg,
                         v,
                         errorStr,
                         sAdapterProperties,
                         ArrayLength(sAdapterProperties));
   } else if (dbus_message_is_signal(aMsg, DBUS_DEVICE_IFACE,
                                     "PropertyChanged")) {
     ParsePropertyChange(aMsg,
                         v,
                         errorStr,
                         sDeviceProperties,
                         ArrayLength(sDeviceProperties));
     if (v.type() == BluetoothValue::T__None) {
       BT_WARNING("PropertyChanged event couldn't be parsed.");
       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
     BluetoothNamedValue& property = v.get_ArrayOfBluetoothNamedValue()[0];
     if (property.name().EqualsLiteral("Paired")) {
       // Original approach: Broadcast system message of
       // "bluetooth-pairedstatuschanged" from BluetoothService.
       BluetoothValue newValue(v);
       ToLowerCase(newValue.get_ArrayOfBluetoothNamedValue()[0].name());
       BluetoothSignal signal(NS_LITERAL_STRING(PAIRED_STATUS_CHANGED_ID),
                              NS_LITERAL_STRING(KEY_LOCAL_AGENT),
                              newValue);
       NS_DispatchToMainThread(new DistributeBluetoothSignalTask(signal));
       // New approach: Dispatch event from BluetoothAdapter
       bool status = property.value();
       InfallibleTArray<BluetoothNamedValue> parameters;
       parameters.AppendElement(
         BluetoothNamedValue(NS_LITERAL_STRING("address"), signalPath));
       parameters.AppendElement(
         BluetoothNamedValue(NS_LITERAL_STRING("status"), status));
       signal.path() = NS_LITERAL_STRING(KEY_ADAPTER);
       signal.value() = parameters;
       NS_DispatchToMainThread(new DistributeBluetoothSignalTask(signal));
     } else if (property.name().EqualsLiteral("Connected")) {
       MonitorAutoLock lock(*sStopBluetoothMonitor);
       if (property.value().get_bool()) {
         ++sConnectedDeviceCount;
       } else {
         MOZ_ASSERT(sConnectedDeviceCount > 0);
         if (--sConnectedDeviceCount == 0) {
           lock.Notify();
         }
       }
     }
   } else if (dbus_message_is_signal(aMsg, DBUS_MANAGER_IFACE, "AdapterAdded")) {
     const char* str;
     if (!dbus_message_get_args(aMsg, &err,
                                DBUS_TYPE_OBJECT_PATH, &str,
                                DBUS_TYPE_INVALID)) {
       LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, aMsg);
       errorStr.AssignLiteral("Cannot parse manager path!");
     } else {
       v = NS_ConvertUTF8toUTF16(str);
       sAdapterPath = v.get_nsString();
       NS_DispatchToMainThread(new TryFiringAdapterAddedRunnable(true));
       NS_DispatchToMainThread(new PrepareAdapterRunnable());
       /**
        * The adapter name isn't ready for the time being. Wait for the upcoming
        * signal PropertyChanged of adapter name, and then propagate signal
        * AdapterAdded to BluetoothManager.
        */
       return DBUS_HANDLER_RESULT_HANDLED;
     }
   } else if (dbus_message_is_signal(aMsg, DBUS_MANAGER_IFACE,
                                     "PropertyChanged")) {
     ParsePropertyChange(aMsg,
                         v,
                         errorStr,
                         sManagerProperties,
                         ArrayLength(sManagerProperties));
   } else if (dbus_message_is_signal(aMsg, DBUS_SINK_IFACE,
                                     "PropertyChanged")) {
     ParsePropertyChange(aMsg,
                         v,
                         errorStr,
                         sSinkProperties,
                         ArrayLength(sSinkProperties));
   } else if (dbus_message_is_signal(aMsg, DBUS_CTL_IFACE, "GetPlayStatus")) {
     NS_DispatchToMainThread(new RequestPlayStatusTask());
     return DBUS_HANDLER_RESULT_HANDLED;
   } else if (dbus_message_is_signal(aMsg, DBUS_CTL_IFACE, "PropertyChanged")) {
     ParsePropertyChange(aMsg,
                         v,
                         errorStr,
                         sControlProperties,
                         ArrayLength(sControlProperties));
   } else if (dbus_message_is_signal(aMsg, DBUS_INPUT_IFACE,
                                     "PropertyChanged")) {
     ParsePropertyChange(aMsg,
                         v,
                         errorStr,
                         sInputProperties,
                         ArrayLength(sInputProperties));
   } else {
     errorStr = NS_ConvertUTF8toUTF16(dbus_message_get_member(aMsg));
     errorStr.AppendLiteral(" Signal not handled!");
   }
   if (!errorStr.IsEmpty()) {
     BT_WARNING(NS_ConvertUTF16toUTF8(errorStr).get());
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
   BluetoothSignal signal(signalName, signalPath, v);
   nsRefPtr<nsRunnable> task;
   if (signalInterface.EqualsLiteral(DBUS_SINK_IFACE)) {
     task = new SinkPropertyChangedHandler(signal);
   } else if (signalInterface.EqualsLiteral(DBUS_CTL_IFACE)) {
     task = new ControlPropertyChangedHandler(signal);
   } else if (signalInterface.EqualsLiteral(DBUS_INPUT_IFACE)) {
     task = new InputPropertyChangedHandler(signal);
   } else {
     task = new DistributeBluetoothSignalTask(signal);
   }
   NS_DispatchToMainThread(task);
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 static void
 OnDefaultAdapterReply(DBusMessage* aReply, void* aData)
 {
   MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
   if (!aReply || dbus_message_is_error(aReply, DBUS_ERROR_TIMEOUT)) {
     return;
   }
   DBusError err;
   dbus_error_init(&err);
   BluetoothValue v;
   nsAutoString errorString;
   UnpackObjectPathMessage(aReply, &err, v, errorString);
   if (!errorString.IsEmpty()) {
     return;
   }
   sAdapterPath = v.get_nsString();
   nsRefPtr<PrepareAdapterRunnable> b = new PrepareAdapterRunnable();
   if (NS_FAILED(NS_DispatchToMainThread(b))) {
     BT_WARNING("Failed to dispatch to main thread!");
   }
 }
 bool
 BluetoothDBusService::IsReady()
 {
   if (!IsEnabled() || !sDBusConnection || IsToggling()) {
     BT_WARNING("Bluetooth service is not ready yet!");
     return false;
   }
   return true;
 }
 class StartDBusConnectionTask : public Task
 {
 public:
   StartDBusConnectionTask(RawDBusConnection* aConnection)
   : mConnection(aConnection)
   {
     MOZ_ASSERT(mConnection);
   }
   void Run()
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     if (sDBusConnection) {
       BT_WARNING("DBus connection has already been established.");
       nsRefPtr<nsRunnable> runnable = new BluetoothService::ToggleBtAck(true);
       if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
         BT_WARNING("Failed to dispatch to main thread!");
       }
       return;
     }
     // Add a filter for all incoming messages_base
     if (!dbus_connection_add_filter(mConnection->GetConnection(),
                                     EventFilter, nullptr, nullptr)) {
       BT_WARNING("Cannot create DBus Event Filter for DBus Thread!");
       nsRefPtr<nsRunnable> runnable = new BluetoothService::ToggleBtAck(false);
       if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
         BT_WARNING("Failed to dispatch to main thread!");
       }
       return;
     }
     mConnection->Watch();
     if (!sPairingReqTable) {
       sPairingReqTable = new nsDataHashtable<nsStringHashKey, DBusMessage* >;
     }
     sDBusConnection = mConnection.forget();
     nsRefPtr<nsRunnable> runnable =
       new BluetoothService::ToggleBtAck(true);
     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
       BT_WARNING("Failed to dispatch to main thread!");
       return;
     }
     /* Normally we'll receive the signal 'AdapterAdded' with the adapter object
      * path from the DBus daemon during start up. So, there's no need to query
      * the object path of default adapter here. However, if we restart from a
      * crash, the default adapter might already be available, so we ask the daemon
      * explicitly here.
      */
     if (sAdapterPath.IsEmpty()) {
       bool success = sDBusConnection->SendWithReply(OnDefaultAdapterReply, nullptr,
 , BLUEZ_DBUS_BASE_IFC, "/",
                                                     DBUS_MANAGER_IFACE,
                                                     "DefaultAdapter",
                                                     DBUS_TYPE_INVALID);
       if (!success) {
         BT_WARNING("Failed to query default adapter!");
       }
     }
   }
 private:
   nsAutoPtr<RawDBusConnection> mConnection;
 };
 class StartBluetoothRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   NS_IMETHOD Run()
   {
     // This could block. It should never be run on the main thread.
     MOZ_ASSERT(!NS_IsMainThread()); // BT thread
 #ifdef MOZ_WIDGET_GONK
     if (!sBluedroid.Enable()) {
       BT_WARNING("Bluetooth not available.");
       nsRefPtr<nsRunnable> runnable = new BluetoothService::ToggleBtAck(false);
       if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
         BT_WARNING("Failed to dispatch to main thread!");
       }
       return NS_ERROR_FAILURE;
     }
 #endif
     RawDBusConnection* connection = new RawDBusConnection();
     nsresult rv = connection->EstablishDBusConnection();
     if (NS_FAILED(rv)) {
       BT_WARNING("Failed to establish connection to BlueZ daemon");
       nsRefPtr<nsRunnable> runnable = new BluetoothService::ToggleBtAck(false);
       if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
         BT_WARNING("Failed to dispatch to main thread!");
       }
       return NS_ERROR_FAILURE;
     }
     DBusError err;
     dbus_error_init(&err);
     // Set which messages will be processed by this dbus connection.
     // Since we are maintaining a single thread for all the DBus bluez
     // signals we want, register all of them in this thread at startup.
     // The event handler will sort the destinations out as needed. The
     // call to dbus_bus_add_match has to run on the BT thread because
     // it can block.
     for (uint32_t i = 0; i < ArrayLength(sBluetoothDBusSignals); ++i) {
       dbus_bus_add_match(connection->GetConnection(),
                          sBluetoothDBusSignals[i],
                          &err);
       if (dbus_error_is_set(&err)) {
         LOG_AND_FREE_DBUS_ERROR(&err);
       }
     }
     Task* task = new StartDBusConnectionTask(connection);
     DispatchToDBusThread(task);
     return NS_OK;
   }
 };
 nsresult
 BluetoothDBusService::StartInternal()
 {
   nsRefPtr<nsRunnable> runnable = new StartBluetoothRunnable();
   nsresult rv = DispatchToBtThread(runnable);
   if (NS_FAILED(rv)) {
     BT_WARNING("Failed to dispatch to BT thread!");
   }
   return rv;
 }
 class DisableBluetoothRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   NS_IMETHOD Run()
   {
     if (NS_IsMainThread()) {
       // Clear |sControllerArray| here while we're on the main thread
       sControllerArray.Clear();
       // Forward this runnable to BT thread
       return DispatchToBtThread(this);
     }
 #ifdef MOZ_WIDGET_GONK
     MOZ_ASSERT(sBluedroid.IsEnabled());
     // Disable() return true on success, so we need to invert it
     bool isEnabled = !sBluedroid.Disable();
 #else
     bool isEnabled = false;
 #endif
     nsRefPtr<nsRunnable> runnable =
       new BluetoothService::ToggleBtAck(isEnabled);
     nsresult rv = NS_DispatchToMainThread(runnable);
     if (NS_FAILED(rv)) {
       BT_WARNING("Failed to dispatch to main thread!");
     }
     return rv;
   }
 };
 class DeleteDBusConnectionTask MOZ_FINAL : public Task
 {
 public:
   DeleteDBusConnectionTask()
   { }
   void Run()
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     if (!sDBusConnection) {
       BT_WARNING("DBus connection has not been established.");
       nsRefPtr<nsRunnable> runnable = new BluetoothService::ToggleBtAck(false);
       if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
         BT_WARNING("Failed to dispatch to main thread!");
       }
       return;
     }
     for (uint32_t i = 0; i < ArrayLength(sBluetoothDBusSignals); ++i) {
       dbus_bus_remove_match(sDBusConnection->GetConnection(),
                             sBluetoothDBusSignals[i], NULL);
     }
     dbus_connection_remove_filter(sDBusConnection->GetConnection(),
                                   EventFilter, nullptr);
     if (!dbus_connection_unregister_object_path(sDBusConnection->GetConnection(),
                                                 KEY_LOCAL_AGENT)) {
       BT_WARNING("%s: Can't unregister object path %s for agent!",
           __FUNCTION__, KEY_LOCAL_AGENT);
     }
     if (!dbus_connection_unregister_object_path(sDBusConnection->GetConnection(),
                                                 KEY_REMOTE_AGENT)) {
       BT_WARNING("%s: Can't unregister object path %s for agent!",
           __FUNCTION__, KEY_REMOTE_AGENT);
     }
     // unref stored DBusMessages before clearing the hashtable
     sPairingReqTable->EnumerateRead(UnrefDBusMessage, nullptr);
     sPairingReqTable->Clear();
     sIsPairing = 0;
     sConnectedDeviceCount = 0;
     // This command closes the DBus connection and all its instances
     // of DBusWatch will be removed and free'd.
     sDBusConnection = nullptr;
     // We can only dispatch to the BT thread if we're on the main
     // thread. Thus we dispatch our runnable to the main thread
     // from where it will forward itself to the BT thread.
     nsRefPtr<nsRunnable> runnable = new DisableBluetoothRunnable();
     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
       BT_WARNING("Failed to dispatch to BT thread!");
     }
   }
 private:
   static PLDHashOperator
   UnrefDBusMessage(const nsAString& key, DBusMessage* value, void* arg)
   {
     dbus_message_unref(value);
     return PL_DHASH_NEXT;
   }
 };
 class StopBluetoothRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(!NS_IsMainThread()); // BT thread
     // This could block. It should never be run on the main thread.
     MonitorAutoLock lock(*sStopBluetoothMonitor);
     if (sConnectedDeviceCount > 0) {
       lock.Wait(PR_SecondsToInterval(TIMEOUT_FORCE_TO_DISABLE_BT));
     }
     DispatchToDBusThread(new DeleteDBusConnectionTask());
     return NS_OK;
   }
 };
 nsresult
 BluetoothDBusService::StopInternal()
 {
   nsRefPtr<nsRunnable> runnable = new StopBluetoothRunnable();
   nsresult rv = DispatchToBtThread(runnable);
   if (NS_FAILED(rv)) {
     BT_WARNING("Failed to dispatch to BT thread!");
   }
   return rv;
 }
 class DefaultAdapterPathReplyHandler : public DBusReplyHandler
 {
 public:
   DefaultAdapterPathReplyHandler(BluetoothReplyRunnable* aRunnable)
     : mRunnable(aRunnable)
   {
     MOZ_ASSERT(mRunnable);
   }
   void Handle(DBusMessage* aReply) MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     if (!aReply || (dbus_message_get_type(aReply) == DBUS_MESSAGE_TYPE_ERROR)) {
       const char* errStr = "Timeout in DefaultAdapterPathReplyHandler";
       if (aReply) {
         errStr = dbus_message_get_error_name(aReply);
         if (!errStr) {
           errStr = "Bluetooth DBus Error";
         }
       }
       DispatchBluetoothReply(mRunnable, BluetoothValue(),
                              NS_ConvertUTF8toUTF16(errStr));
       return;
     }
     bool success;
     nsAutoString replyError;
     if (mAdapterPath.IsEmpty()) {
       success = HandleDefaultAdapterPathReply(aReply, replyError);
     } else {
       success = HandleGetPropertiesReply(aReply, replyError);
     }
     if (!success) {
       DispatchBluetoothReply(mRunnable, BluetoothValue(), replyError);
     }
   }
 protected:
   bool HandleDefaultAdapterPathReply(DBusMessage* aReply,
                                      nsAString& aReplyError)
   {
     BluetoothValue value;
     DBusError error;
     dbus_error_init(&error);
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     UnpackObjectPathMessage(aReply, &error, value, aReplyError);
     if (!aReplyError.IsEmpty()) {
       return false;
     }
     mAdapterPath = value.get_nsString();
     // Acquire another reference to this reply handler
     nsRefPtr<DefaultAdapterPathReplyHandler> handler = this;
     bool success = sDBusConnection->SendWithReply(
       DefaultAdapterPathReplyHandler::Callback, handler.get(), 1000,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(mAdapterPath).get(),
       DBUS_ADAPTER_IFACE, "GetProperties", DBUS_TYPE_INVALID);
     if (!success) {
       aReplyError = NS_LITERAL_STRING("SendWithReply failed");
       return false;
     }
     unused << handler.forget(); // picked up by callback handler
     return true;
   }
   bool HandleGetPropertiesReply(DBusMessage* aReply,
                                 nsAutoString& aReplyError)
   {
     BluetoothValue value;
     DBusError error;
     dbus_error_init(&error);
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     bool success = UnpackPropertiesMessage(aReply, &error, value,
                                            DBUS_ADAPTER_IFACE);
     if (!success) {
       aReplyError = NS_ConvertUTF8toUTF16(error.message);
       return false;
     }
     // We have to manually attach the path to the rest of the elements
     value.get_ArrayOfBluetoothNamedValue().AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("Path"), mAdapterPath));
     // Dispatch result
     DispatchBluetoothReply(mRunnable, value, aReplyError);
     return true;
   }
 private:
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
   nsString mAdapterPath;
 };
 class DefaultAdapterTask : public Task
 {
 public:
   DefaultAdapterTask(BluetoothReplyRunnable* aRunnable)
     : mRunnable(aRunnable)
   {
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     nsRefPtr<DefaultAdapterPathReplyHandler> handler =
       new DefaultAdapterPathReplyHandler(mRunnable);
     bool success = sDBusConnection->SendWithReply(
       DefaultAdapterPathReplyHandler::Callback,
       handler.get(), 1000, BLUEZ_DBUS_BASE_IFC,
       "/", DBUS_MANAGER_IFACE, "DefaultAdapter",
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << handler.forget(); // picked up by callback handler
   }
 private:
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 nsresult
 BluetoothDBusService::GetDefaultAdapterPathInternal(
                                               BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return NS_OK;
   }
   Task* task = new DefaultAdapterTask(aRunnable);
   DispatchToDBusThread(task);
   return NS_OK;
 }
 static void
 OnSendDiscoveryMessageReply(DBusMessage *aReply, void *aData)
 {
   MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
   nsAutoString errorStr;
   if (!aReply) {
     errorStr.AssignLiteral("SendDiscovery failed");
   }
   nsRefPtr<BluetoothReplyRunnable> runnable =
     dont_AddRef<BluetoothReplyRunnable>(static_cast<BluetoothReplyRunnable*>(aData));
   DispatchBluetoothReply(runnable.get(), BluetoothValue(true), errorStr);
 }
 class SendDiscoveryMessageTask : public Task
 {
 public:
   SendDiscoveryMessageTask(const char* aMessageName,
                            BluetoothReplyRunnable* aRunnable)
     : mMessageName(aMessageName)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mMessageName.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     bool success = sDBusConnection->SendWithReply(
       OnSendDiscoveryMessageReply,
       static_cast<void*>(mRunnable.get()), -1,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(sAdapterPath).get(),
       DBUS_ADAPTER_IFACE, mMessageName.get(),
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << mRunnable.forget(); // picked up by callback handler
   }
 private:
   const nsCString mMessageName;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 nsresult
 BluetoothDBusService::SendDiscoveryMessage(const char* aMessageName,
                                            BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!sAdapterPath.IsEmpty());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return NS_OK;
   }
   Task* task = new SendDiscoveryMessageTask(aMessageName, aRunnable);
   DispatchToDBusThread(task);
   return NS_OK;
 }
 nsresult
 BluetoothDBusService::SendInputMessage(const nsAString& aDeviceAddress,
                                        const nsAString& aMessage)
 {
   DBusReplyCallback callback;
   if (aMessage.EqualsLiteral("Connect")) {
     callback = InputConnectCallback;
   } else if (aMessage.EqualsLiteral("Disconnect")) {
     callback = InputDisconnectCallback;
   } else {
     MOZ_ASSERT(false);
     return NS_ERROR_FAILURE;
   }
   MOZ_ASSERT(!sAdapterPath.IsEmpty());
   nsString objectPath = GetObjectPathFromAddress(sAdapterPath, aDeviceAddress);
   return SendAsyncDBusMessage(objectPath, DBUS_INPUT_IFACE, aMessage, callback);
 }
 class SendAsyncDBusMessageTask : public Task
 {
 public:
   SendAsyncDBusMessageTask(DBusReplyCallback aCallback,
                            BluetoothServiceClass* aServiceClass,
                            const nsACString& aObjectPath,
                            const char* aInterface,
                            const nsACString& aMessage)
     : mCallback(aCallback)
     , mServiceClass(aServiceClass)
     , mObjectPath(aObjectPath)
     , mInterface(aInterface)
     , mMessage(aMessage)
   {
     MOZ_ASSERT(mServiceClass);
     MOZ_ASSERT(!mObjectPath.IsEmpty());
     MOZ_ASSERT(!mInterface.IsEmpty());
     MOZ_ASSERT(!mMessage.IsEmpty());
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     bool success = sDBusConnection->SendWithReply(
       mCallback, static_cast<void*>(mServiceClass), -1,
       BLUEZ_DBUS_BASE_IFC, mObjectPath.get(), mInterface.get(),
       mMessage.get(), DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     mServiceClass.forget();
   }
 private:
   DBusReplyCallback mCallback;
   nsAutoPtr<BluetoothServiceClass> mServiceClass;
   const nsCString mObjectPath;
   const nsCString mInterface;
   const nsCString mMessage;
 };
 nsresult
 BluetoothDBusService::SendAsyncDBusMessage(const nsAString& aObjectPath,
                                            const char* aInterface,
                                            const nsAString& aMessage,
                                            DBusReplyCallback aCallback)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(IsEnabled());
   MOZ_ASSERT(aCallback);
   MOZ_ASSERT(!aObjectPath.IsEmpty());
   MOZ_ASSERT(aInterface);
   nsAutoPtr<BluetoothServiceClass> serviceClass(new BluetoothServiceClass());
   if (!strcmp(aInterface, DBUS_SINK_IFACE)) {
     *serviceClass = BluetoothServiceClass::A2DP;
   } else if (!strcmp(aInterface, DBUS_INPUT_IFACE)) {
     *serviceClass = BluetoothServiceClass::HID;
   } else {
     MOZ_ASSERT(false);
     return NS_ERROR_FAILURE;
   }
   Task* task = new SendAsyncDBusMessageTask(aCallback,
                                             serviceClass.forget(),
                                             NS_ConvertUTF16toUTF8(aObjectPath),
                                             aInterface,
                                             NS_ConvertUTF16toUTF8(aMessage));
   DispatchToDBusThread(task);
   return NS_OK;
 }
 nsresult
 BluetoothDBusService::SendSinkMessage(const nsAString& aDeviceAddress,
                                       const nsAString& aMessage)
 {
   DBusReplyCallback callback;
   if (aMessage.EqualsLiteral("Connect")) {
     callback = SinkConnectCallback;
   } else if (aMessage.EqualsLiteral("Disconnect")) {
     callback = SinkDisconnectCallback;
   } else {
     MOZ_ASSERT(false);
     return NS_ERROR_FAILURE;
   }
   MOZ_ASSERT(!sAdapterPath.IsEmpty());
   nsString objectPath = GetObjectPathFromAddress(sAdapterPath, aDeviceAddress);
   return SendAsyncDBusMessage(objectPath, DBUS_SINK_IFACE, aMessage, callback);
 }
 nsresult
 BluetoothDBusService::StopDiscoveryInternal(BluetoothReplyRunnable* aRunnable)
 {
   return SendDiscoveryMessage("StopDiscovery", aRunnable);
 }
 nsresult
 BluetoothDBusService::StartDiscoveryInternal(BluetoothReplyRunnable* aRunnable)
 {
   return SendDiscoveryMessage("StartDiscovery", aRunnable);
 }
 class BluetoothArrayOfDevicePropertiesReplyHandler : public DBusReplyHandler
 {
 public:
   BluetoothArrayOfDevicePropertiesReplyHandler(
     const nsTArray<nsString>& aDeviceAddresses,
     const FilterFunc aFilterFunc, BluetoothReplyRunnable* aRunnable)
     : mDeviceAddresses(aDeviceAddresses)
     , mProcessedDeviceAddresses(0)
     , mFilterFunc(aFilterFunc)
     , mRunnable(aRunnable)
     , mValues(InfallibleTArray<BluetoothNamedValue>())
   {
     MOZ_ASSERT(mRunnable);
   }
   void Handle(DBusMessage* aReply) MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     MOZ_ASSERT(!mObjectPath.IsEmpty());
     MOZ_ASSERT(mProcessedDeviceAddresses < mDeviceAddresses.Length());
     const nsTArray<nsString>::index_type i = mProcessedDeviceAddresses++;
     if (!aReply ||
         (dbus_message_get_type(aReply) == DBUS_MESSAGE_TYPE_ERROR)) {
       BT_WARNING("Invalid DBus message");
       ProcessRemainingDeviceAddresses();
       return;
     }
     // Get device properties from result of GetProperties
     DBusError err;
     dbus_error_init(&err);
     BluetoothValue deviceProperties;
     bool success = UnpackPropertiesMessage(aReply, &err, deviceProperties,
                                            DBUS_DEVICE_IFACE);
     if (!success) {
       BT_WARNING("Failed to get device properties");
       ProcessRemainingDeviceAddresses();
       return;
     }
     InfallibleTArray<BluetoothNamedValue>& devicePropertiesArray =
       deviceProperties.get_ArrayOfBluetoothNamedValue();
     // We have to manually attach the path to the rest of the elements
     devicePropertiesArray.AppendElement(
       BluetoothNamedValue(NS_LITERAL_STRING("Path"), mObjectPath));
     // It is possible that property Icon missed due to CoD of major
     // class is TOY but service class is "Audio", we need to assign
     // Icon as audio-card. This is for PTS test TC_AG_COD_BV_02_I.
     // As HFP specification defined that
     // service class is "Audio" can be considered as HFP AG.
     if (!ContainsIcon(devicePropertiesArray)) {
       for (uint32_t j = 0; j < devicePropertiesArray.Length(); ++j) {
         BluetoothNamedValue& deviceProperty = devicePropertiesArray[j];
         if (deviceProperty.name().EqualsLiteral("Class")) {
           if (HasAudioService(deviceProperty.value().get_uint32_t())) {
             devicePropertiesArray.AppendElement(
               BluetoothNamedValue(NS_LITERAL_STRING("Icon"),
                                   NS_LITERAL_STRING("audio-card")));
           }
           break;
         }
       }
     }
     if (mFilterFunc(deviceProperties)) {
       mValues.get_ArrayOfBluetoothNamedValue().AppendElement(
         BluetoothNamedValue(mDeviceAddresses[i], deviceProperties));
     }
     ProcessRemainingDeviceAddresses();
   }
   void ProcessRemainingDeviceAddresses()
   {
     if (mProcessedDeviceAddresses < mDeviceAddresses.Length()) {
       if (!SendNextGetProperties()) {
         DispatchBluetoothReply(mRunnable, BluetoothValue(),
                                NS_LITERAL_STRING(
                                  "SendNextGetProperties failed"));
       }
     } else {
       // Send resulting device properties
       DispatchBluetoothReply(mRunnable, mValues, EmptyString());
     }
   }
 protected:
   bool SendNextGetProperties()
   {
     MOZ_ASSERT(mProcessedDeviceAddresses < mDeviceAddresses.Length());
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     MOZ_ASSERT(sDBusConnection);
     // cache object path for reply
     mObjectPath = GetObjectPathFromAddress(sAdapterPath,
       mDeviceAddresses[mProcessedDeviceAddresses]);
     nsRefPtr<BluetoothArrayOfDevicePropertiesReplyHandler> handler = this;
     bool success = sDBusConnection->SendWithReply(
       BluetoothArrayOfDevicePropertiesReplyHandler::Callback,
       handler.get(), 1000, BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(mObjectPath).get(),
       DBUS_DEVICE_IFACE, "GetProperties",
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE(success, false);
     unused << handler.forget(); // picked up by callback handler
     return true;
   }
 private:
   nsString mObjectPath;
   const nsTArray<nsString> mDeviceAddresses;
   nsTArray<nsString>::size_type mProcessedDeviceAddresses;
   const FilterFunc mFilterFunc;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
   BluetoothValue mValues;
 };
 class ProcessRemainingDeviceAddressesTask : public Task
 {
 public:
   ProcessRemainingDeviceAddressesTask(
     BluetoothArrayOfDevicePropertiesReplyHandler* aHandler,
     BluetoothReplyRunnable* aRunnable)
     : mHandler(aHandler)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(mHandler);
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     mHandler->ProcessRemainingDeviceAddresses();
   }
 private:
   nsRefPtr<BluetoothArrayOfDevicePropertiesReplyHandler> mHandler;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 nsresult
 BluetoothDBusService::GetConnectedDevicePropertiesInternal(uint16_t aServiceUuid,
                                               BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsAutoString errorStr;
   BluetoothValue values = InfallibleTArray<BluetoothNamedValue>();
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return NS_OK;
   }
   nsTArray<nsString> deviceAddresses;
   BluetoothProfileManagerBase* profile =
     BluetoothUuidHelper::GetBluetoothProfileManager(aServiceUuid);
   if (!profile) {
     DispatchBluetoothReply(aRunnable, values,
                            NS_LITERAL_STRING(ERR_UNKNOWN_PROFILE));
     return NS_OK;
   }
   if (profile->IsConnected()) {
     nsString address;
     profile->GetAddress(address);
     deviceAddresses.AppendElement(address);
   }
   BluetoothArrayOfDevicePropertiesReplyHandler* handler =
     new BluetoothArrayOfDevicePropertiesReplyHandler(deviceAddresses,
                                                      GetConnectedDevicesFilter,
                                                      aRunnable);
   Task* task = new ProcessRemainingDeviceAddressesTask(handler, aRunnable);
   DispatchToDBusThread(task);
   return NS_OK;
 }
 nsresult
 BluetoothDBusService::GetPairedDevicePropertiesInternal(
                                      const nsTArray<nsString>& aDeviceAddresses,
                                      BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return NS_OK;
   }
   BluetoothArrayOfDevicePropertiesReplyHandler* handler =
     new BluetoothArrayOfDevicePropertiesReplyHandler(aDeviceAddresses,
                                                      GetPairedDevicesFilter,
                                                      aRunnable);
   Task* task = new ProcessRemainingDeviceAddressesTask(handler, aRunnable);
   DispatchToDBusThread(task);
   return NS_OK;
 }
 class SetPropertyTask : public Task
 {
 public:
   SetPropertyTask(BluetoothObjectType aType,
                   const nsACString& aName,
                   BluetoothReplyRunnable* aRunnable)
     : mType(aType)
     , mName(aName)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(mRunnable);
   }
   void Send(unsigned int aType, const void* aValue)
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     DBusMessage* msg =
       dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
                                    NS_ConvertUTF16toUTF8(sAdapterPath).get(),
                                    sBluetoothDBusIfaces[mType],
                                    "SetProperty");
     if (!msg) {
       BT_WARNING("Could not allocate D-Bus message object!");
       return;
     }
     const char* name = mName.get();
     if (!dbus_message_append_args(msg, DBUS_TYPE_STRING, &name,
                                   DBUS_TYPE_INVALID)) {
       BT_WARNING("Couldn't append arguments to dbus message!");
       return;
     }
     DBusMessageIter value_iter, iter;
     dbus_message_iter_init_append(msg, &iter);
     char var_type[2] = {(char)aType, '\0'};
     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
                                           var_type, &value_iter) ||
         !dbus_message_iter_append_basic(&value_iter, aType, aValue) ||
         !dbus_message_iter_close_container(&iter, &value_iter)) {
       BT_WARNING("Could not append argument to method call!");
       dbus_message_unref(msg);
       return;
     }
     // msg is unref'd as part of SendWithReply
     bool success = sDBusConnection->SendWithReply(
       GetVoidCallback,
       static_cast<void*>(mRunnable),
 , msg);
     NS_ENSURE_TRUE_VOID(success);
     unused << mRunnable.forget(); // picked up by callback handler
   }
 private:
   BluetoothObjectType mType;
   const nsCString mName;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 class SetUInt32PropertyTask : public SetPropertyTask
 {
 public:
   SetUInt32PropertyTask(BluetoothObjectType aType,
                         const nsACString& aName,
                         uint32_t aValue,
                         BluetoothReplyRunnable* aRunnable)
     : SetPropertyTask(aType, aName, aRunnable)
     , mValue(aValue)
   { }
   void Run() MOZ_OVERRIDE
   {
     Send(DBUS_TYPE_UINT32, &mValue);
   }
 private:
   dbus_uint32_t mValue;
 };
 class SetStringPropertyTask : public SetPropertyTask
 {
 public:
   SetStringPropertyTask(BluetoothObjectType aType,
                         const nsACString& aName,
                         const nsACString& aValue,
                         BluetoothReplyRunnable* aRunnable)
     : SetPropertyTask(aType, aName, aRunnable)
     , mValue(aValue)
   { }
   void Run() MOZ_OVERRIDE
   {
     const char* value = mValue.get();
     Send(DBUS_TYPE_STRING, &value);
   }
 private:
   const nsCString mValue;
 };
 class SetBooleanPropertyTask : public SetPropertyTask
 {
 public:
   SetBooleanPropertyTask(BluetoothObjectType aType,
                          const nsACString& aName,
                          dbus_bool_t aValue,
                          BluetoothReplyRunnable* aRunnable)
     : SetPropertyTask(aType, aName, aRunnable)
     , mValue(aValue)
   {
   }
   void Run() MOZ_OVERRIDE
   {
     Send(DBUS_TYPE_BOOLEAN, &mValue);
   }
 private:
   dbus_bool_t mValue;
 };
 nsresult
 BluetoothDBusService::SetProperty(BluetoothObjectType aType,
                                   const BluetoothNamedValue& aValue,
                                   BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return NS_OK;
   }
   Task* task;
   if (aValue.value().type() == BluetoothValue::Tuint32_t) {
     task = new SetUInt32PropertyTask(aType,
       NS_ConvertUTF16toUTF8(aValue.name()),
       aValue.value().get_uint32_t(), aRunnable);
   } else if (aValue.value().type() == BluetoothValue::TnsString) {
     task = new SetStringPropertyTask(aType,
       NS_ConvertUTF16toUTF8(aValue.name()),
       NS_ConvertUTF16toUTF8(aValue.value().get_nsString()), aRunnable);
   } else if (aValue.value().type() == BluetoothValue::Tbool) {
     task = new SetBooleanPropertyTask(aType,
       NS_ConvertUTF16toUTF8(aValue.name()),
       aValue.value().get_bool(), aRunnable);
   } else {
     BT_WARNING("Property type not handled!");
     return NS_ERROR_FAILURE;
   }
   DispatchToDBusThread(task);
   return NS_OK;
 }
 class CreatePairedDeviceInternalTask : public Task
 {
 public:
   CreatePairedDeviceInternalTask(const nsACString& aDeviceAddress,
                                  int aTimeout,
                                  BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mTimeout(aTimeout)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     const char *deviceAddress = mDeviceAddress.get();
     const char *deviceAgentPath = KEY_REMOTE_AGENT;
     const char *capabilities = B2G_AGENT_CAPABILITIES;
     // Then send CreatePairedDevice, it will register a temp device agent then
     // unregister it after pairing process is over
     bool success = sDBusConnection->SendWithReply(
       GetObjectPathCallback, static_cast<void*>(mRunnable), mTimeout,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(sAdapterPath).get(),
       DBUS_ADAPTER_IFACE,
       "CreatePairedDevice",
       DBUS_TYPE_STRING, &deviceAddress,
       DBUS_TYPE_OBJECT_PATH, &deviceAgentPath,
       DBUS_TYPE_STRING, &capabilities,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << mRunnable.forget(); // picked up by callback handler
     /**
      * FIXME: Bug 820274
      *
      * If the user turns off Bluetooth in the middle of pairing process,
      * the callback function GetObjectPathCallback may still be called
      * while enabling next time by dbus daemon. To prevent this from
      * happening, added a flag to distinguish if Bluetooth has been
      * turned off. Nevertheless, we need a check if there is a better
      * solution.
      *
      * Please see Bug 818696 for more information.
      */
     sIsPairing++;
   }
 private:
   const nsCString mDeviceAddress;
   int mTimeout;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 nsresult
 BluetoothDBusService::CreatePairedDeviceInternal(
                                               const nsAString& aDeviceAddress,
                                               int aTimeout,
                                               BluetoothReplyRunnable* aRunnable)
 {
   Task* task = new CreatePairedDeviceInternalTask(
     NS_ConvertUTF16toUTF8(aDeviceAddress),
     aTimeout, aRunnable);
   DispatchToDBusThread(task);
   return NS_OK;
 }
 class RemoveDeviceTask : public Task
 {
 public:
   RemoveDeviceTask(const nsAString& aDeviceAddress,
                    BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     nsCString deviceObjectPath =
       NS_ConvertUTF16toUTF8(GetObjectPathFromAddress(sAdapterPath,
                                                      mDeviceAddress));
     const char* cstrDeviceObjectPath = deviceObjectPath.get();
     bool success = sDBusConnection->SendWithReply(
       OnRemoveDeviceReply, static_cast<void*>(mRunnable.get()), -1,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(sAdapterPath).get(),
       DBUS_ADAPTER_IFACE, "RemoveDevice",
       DBUS_TYPE_OBJECT_PATH, &cstrDeviceObjectPath,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << mRunnable.forget(); // picked up by callback handler
   }
 protected:
   static void OnRemoveDeviceReply(DBusMessage* aReply, void* aData)
   {
     nsAutoString errorStr;
     if (!aReply) {
       errorStr.AssignLiteral("RemoveDevice failed");
     }
     nsRefPtr<BluetoothReplyRunnable> runnable =
       dont_AddRef<BluetoothReplyRunnable>(
         static_cast<BluetoothReplyRunnable*>(aData));
     DispatchBluetoothReply(runnable.get(), BluetoothValue(true), errorStr);
   }
 private:
   const nsString mDeviceAddress;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 nsresult
 BluetoothDBusService::RemoveDeviceInternal(const nsAString& aDeviceAddress,
                                            BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return NS_OK;
   }
   Task* task = new RemoveDeviceTask(aDeviceAddress, aRunnable);
   DispatchToDBusThread(task);
   return NS_OK;
 }
 class SetPinCodeTask : public Task
 {
 public:
   SetPinCodeTask(const nsAString& aDeviceAddress,
                  const nsACString& aPinCode,
                  BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mPinCode(aPinCode)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     nsAutoString errorStr;
     BluetoothValue v = true;
     DBusMessage *msg;
     if (!sPairingReqTable->Get(mDeviceAddress, &msg)) {
       BT_WARNING("%s: Couldn't get original request message.", __FUNCTION__);
       errorStr.AssignLiteral("Couldn't get original request message.");
       DispatchBluetoothReply(mRunnable, v, errorStr);
       return;
     }
     DBusMessage *reply = dbus_message_new_method_return(msg);
     if (!reply) {
       BT_WARNING("%s: Memory can't be allocated for the message.", __FUNCTION__);
       dbus_message_unref(msg);
       errorStr.AssignLiteral("Memory can't be allocated for the message.");
       DispatchBluetoothReply(mRunnable, v, errorStr);
       return;
     }
     const char* pinCode = mPinCode.get();
     if (!dbus_message_append_args(reply,
                                   DBUS_TYPE_STRING, &pinCode,
                                   DBUS_TYPE_INVALID)) {
       BT_WARNING("%s: Couldn't append arguments to dbus message.", __FUNCTION__);
       errorStr.AssignLiteral("Couldn't append arguments to dbus message.");
     } else {
       MOZ_ASSERT(sDBusConnection);
       sDBusConnection->Send(reply);
     }
     dbus_message_unref(msg);
     dbus_message_unref(reply);
     sPairingReqTable->Remove(mDeviceAddress);
     DispatchBluetoothReply(mRunnable, v, errorStr);
   }
 private:
   const nsString mDeviceAddress;
   const nsCString mPinCode;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 bool
 BluetoothDBusService::SetPinCodeInternal(const nsAString& aDeviceAddress,
                                          const nsAString& aPinCode,
                                          BluetoothReplyRunnable* aRunnable)
 {
   Task* task = new SetPinCodeTask(aDeviceAddress,
                                   NS_ConvertUTF16toUTF8(aPinCode),
                                   aRunnable);
   DispatchToDBusThread(task);
   return true;
 }
 class SetPasskeyTask : public Task
 {
 public:
   SetPasskeyTask(const nsAString& aDeviceAddress,
                  uint32_t aPasskey,
                  BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mPasskey(aPasskey)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     nsAutoString errorStr;
     BluetoothValue v = true;
     DBusMessage *msg;
     if (!sPairingReqTable->Get(mDeviceAddress, &msg)) {
       BT_WARNING("%s: Couldn't get original request message.", __FUNCTION__);
       errorStr.AssignLiteral("Couldn't get original request message.");
       DispatchBluetoothReply(mRunnable, v, errorStr);
       return;
     }
     DBusMessage *reply = dbus_message_new_method_return(msg);
     if (!reply) {
       BT_WARNING("%s: Memory can't be allocated for the message.", __FUNCTION__);
       dbus_message_unref(msg);
       errorStr.AssignLiteral("Memory can't be allocated for the message.");
       DispatchBluetoothReply(mRunnable, v, errorStr);
       return;
     }
     uint32_t passkey = mPasskey;
     if (!dbus_message_append_args(reply,
                                   DBUS_TYPE_UINT32, &passkey,
                                   DBUS_TYPE_INVALID)) {
       BT_WARNING("%s: Couldn't append arguments to dbus message.", __FUNCTION__);
       errorStr.AssignLiteral("Couldn't append arguments to dbus message.");
     } else {
       MOZ_ASSERT(sDBusConnection);
       sDBusConnection->Send(reply);
     }
     dbus_message_unref(msg);
     dbus_message_unref(reply);
     sPairingReqTable->Remove(mDeviceAddress);
     DispatchBluetoothReply(mRunnable, v, errorStr);
   }
 private:
   nsString mDeviceAddress;
   uint32_t mPasskey;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 bool
 BluetoothDBusService::SetPasskeyInternal(const nsAString& aDeviceAddress,
                                          uint32_t aPasskey,
                                          BluetoothReplyRunnable* aRunnable)
 {
   Task* task = new SetPasskeyTask(aDeviceAddress,
                                   aPasskey,
                                   aRunnable);
   DispatchToDBusThread(task);
   return true;
 }
 bool
 BluetoothDBusService::SetPairingConfirmationInternal(
                                               const nsAString& aDeviceAddress,
                                               bool aConfirm,
                                               BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   Task* task = new SetPairingConfirmationTask(aDeviceAddress,
                                               aConfirm,
                                               aRunnable);
   DispatchToDBusThread(task);
   return true;
 }
 static void
 NextBluetoothProfileController()
 {
   MOZ_ASSERT(NS_IsMainThread());
   // First, remove the task at the front which has been already done.
   NS_ENSURE_FALSE_VOID(sControllerArray.IsEmpty());
   sControllerArray.RemoveElementAt(0);
   // Re-check if the task array is empty, if it's not, the next task will begin.
   NS_ENSURE_FALSE_VOID(sControllerArray.IsEmpty());
   sControllerArray[0]->StartSession();
 }
 static void
 ConnectDisconnect(bool aConnect, const nsAString& aDeviceAddress,
                   BluetoothReplyRunnable* aRunnable,
                   uint16_t aServiceUuid, uint32_t aCod = 0)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aRunnable);
   BluetoothProfileController* controller =
     new BluetoothProfileController(aConnect, aDeviceAddress, aRunnable,
                                    NextBluetoothProfileController,
                                    aServiceUuid, aCod);
   sControllerArray.AppendElement(controller);
   /**
    * If the request is the first element of the quene, start from here. Note
    * that other request is pushed into the quene and is popped out after the
    * first one is completed. See NextBluetoothProfileController() for details.
    */
   if (sControllerArray.Length() == 1) {
     sControllerArray[0]->StartSession();
   }
 }
 void
 BluetoothDBusService::Connect(const nsAString& aDeviceAddress,
                               uint32_t aCod,
                               uint16_t aServiceUuid,
                               BluetoothReplyRunnable* aRunnable)
 {
   ConnectDisconnect(true, aDeviceAddress, aRunnable, aServiceUuid, aCod);
 }
 void
 BluetoothDBusService::Disconnect(const nsAString& aDeviceAddress,
                                  uint16_t aServiceUuid,
                                  BluetoothReplyRunnable* aRunnable)
 {
   ConnectDisconnect(false, aDeviceAddress, aRunnable, aServiceUuid);
 }
 bool
 BluetoothDBusService::IsConnected(const uint16_t aServiceUuid)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothProfileManagerBase* profile =
     BluetoothUuidHelper::GetBluetoothProfileManager(aServiceUuid);
   if (!profile) {
     BT_WARNING(ERR_UNKNOWN_PROFILE);
     return false;
   }
   NS_ENSURE_TRUE(profile, false);
   return profile->IsConnected();
 }
 #ifdef MOZ_B2G_RIL
 void
 BluetoothDBusService::AnswerWaitingCall(BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   hfp->AnswerWaitingCall();
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());
 }
 void
 BluetoothDBusService::IgnoreWaitingCall(BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   hfp->IgnoreWaitingCall();
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());
 }
 void
 BluetoothDBusService::ToggleCalls(BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   hfp->ToggleCalls();
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());
 }
 #endif // MOZ_B2G_RIL
 class OnUpdateSdpRecordsRunnable : public nsRunnable
 {
 public:
   OnUpdateSdpRecordsRunnable(const nsAString& aObjectPath,
                              BluetoothProfileManagerBase* aManager)
     : mManager(aManager)
   {
     MOZ_ASSERT(!aObjectPath.IsEmpty());
     MOZ_ASSERT(aManager);
     mDeviceAddress = GetAddressFromObjectPath(aObjectPath);
   }
   nsresult
   Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     mManager->OnUpdateSdpRecords(mDeviceAddress);
     return NS_OK;
   }
 private:
   nsString mDeviceAddress;
   BluetoothProfileManagerBase* mManager;
 };
 class OnGetServiceChannelRunnable : public nsRunnable
 {
 public:
   OnGetServiceChannelRunnable(const nsAString& aDeviceAddress,
                               const nsAString& aServiceUuid,
                               int aChannel,
                               BluetoothProfileManagerBase* aManager)
     : mDeviceAddress(aDeviceAddress)
     , mServiceUuid(aServiceUuid)
     , mChannel(aChannel)
     , mManager(aManager)
   {
     MOZ_ASSERT(!aDeviceAddress.IsEmpty());
     MOZ_ASSERT(!aServiceUuid.IsEmpty());
     MOZ_ASSERT(aManager);
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     mManager->OnGetServiceChannel(mDeviceAddress, mServiceUuid, mChannel);
     return NS_OK;
   }
 private:
   nsString mDeviceAddress;
   nsString mServiceUuid;
   int mChannel;
   BluetoothProfileManagerBase* mManager;
 };
 class OnGetServiceChannelReplyHandler : public DBusReplyHandler
 {
 public:
   OnGetServiceChannelReplyHandler(const nsAString& aDeviceAddress,
                                   const nsAString& aServiceUUID,
                                   BluetoothProfileManagerBase* aBluetoothProfileManager)
   : mDeviceAddress(aDeviceAddress),
     mServiceUUID(aServiceUUID),
     mBluetoothProfileManager(aBluetoothProfileManager)
   {
     MOZ_ASSERT(mBluetoothProfileManager);
   }
   void Handle(DBusMessage* aReply)
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     // The default channel is an invalid value of -1. We
     // update it if we have received a correct reply. Both
     // cases, valid and invalid channel numbers, are handled
     // in BluetoothProfileManagerBase::OnGetServiceChannel.
     int channel = -1;
     if (aReply && (dbus_message_get_type(aReply) != DBUS_MESSAGE_TYPE_ERROR)) {
       channel = dbus_returns_int32(aReply);
     }
     nsRefPtr<nsRunnable> r = new OnGetServiceChannelRunnable(mDeviceAddress,
                                                              mServiceUUID,
                                                              channel,
                                                              mBluetoothProfileManager);
     nsresult rv = NS_DispatchToMainThread(r);
     NS_ENSURE_SUCCESS_VOID(rv);
   }
 private:
   nsString mDeviceAddress;
   nsString mServiceUUID;
   BluetoothProfileManagerBase* mBluetoothProfileManager;
 };
 class GetServiceChannelTask : public Task
 {
 public:
   GetServiceChannelTask(const nsAString& aDeviceAddress,
                         const nsAString& aServiceUUID,
                         BluetoothProfileManagerBase* aBluetoothProfileManager)
     : mDeviceAddress(aDeviceAddress)
     , mServiceUUID(aServiceUUID)
     , mBluetoothProfileManager(aBluetoothProfileManager)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mBluetoothProfileManager);
   }
   void Run() MOZ_OVERRIDE
   {
     static const int sProtocolDescriptorList = 0x0004;
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     nsString objectPath =
       GetObjectPathFromAddress(sAdapterPath, mDeviceAddress);
     nsRefPtr<OnGetServiceChannelReplyHandler> handler =
       new OnGetServiceChannelReplyHandler(mDeviceAddress, mServiceUUID,
                                           mBluetoothProfileManager);
     nsCString serviceUUID = NS_ConvertUTF16toUTF8(mServiceUUID);
     const char* cstrServiceUUID = serviceUUID.get();
     bool success = sDBusConnection->SendWithReply(
       OnGetServiceChannelReplyHandler::Callback, handler, -1,
       BLUEZ_DBUS_BASE_IFC,
       NS_ConvertUTF16toUTF8(objectPath).get(),
       DBUS_DEVICE_IFACE, "GetServiceAttributeValue",
       DBUS_TYPE_STRING, &cstrServiceUUID,
       DBUS_TYPE_UINT16, &sProtocolDescriptorList,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << handler.forget(); // picked up by callback handler
   }
 private:
   nsString mDeviceAddress;
   nsString mServiceUUID;
   BluetoothProfileManagerBase* mBluetoothProfileManager;
 };
 nsresult
 BluetoothDBusService::GetServiceChannel(const nsAString& aDeviceAddress,
                                         const nsAString& aServiceUUID,
                                         BluetoothProfileManagerBase* aManager)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     return NS_OK;
   }
 #ifdef MOZ_WIDGET_GONK
   // GetServiceAttributeValue only exists in android's bluez dbus binding
   // implementation
   Task* task = new GetServiceChannelTask(aDeviceAddress,
                                          aServiceUUID,
                                          aManager);
   DispatchToDBusThread(task);
 #else
   // FIXME/Bug 793977 qdot: Just set something for desktop, until we have a
   // parser for the GetServiceAttributes xml block
   //
   // Even though we are on the main thread already, we need to dispatch a
   // runnable here. OnGetServiceChannel needs mRunnable to be set, which
   // happens after GetServiceChannel returns.
   nsRefPtr<nsRunnable> r = new OnGetServiceChannelRunnable(aDeviceAddress,
                                                            aServiceUUID,
 ,
                                                            aManager);
   NS_DispatchToMainThread(r);
 #endif
   return NS_OK;
 }
 class UpdateSdpRecordsTask : public Task
 {
 public:
   UpdateSdpRecordsTask(const nsAString& aDeviceAddress,
                        BluetoothProfileManagerBase* aBluetoothProfileManager)
     : mDeviceAddress(aDeviceAddress)
     , mBluetoothProfileManager(aBluetoothProfileManager)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mBluetoothProfileManager);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     const nsString objectPath =
       GetObjectPathFromAddress(sAdapterPath, mDeviceAddress);
     // I choose to use raw pointer here because this is going to be passed as an
     // argument into SendWithReply() at once.
     OnUpdateSdpRecordsRunnable* callbackRunnable =
       new OnUpdateSdpRecordsRunnable(objectPath, mBluetoothProfileManager);
     sDBusConnection->SendWithReply(DiscoverServicesCallback,
                                    (void*)callbackRunnable, -1,
                                    BLUEZ_DBUS_BASE_IFC,
                                    NS_ConvertUTF16toUTF8(objectPath).get(),
                                    DBUS_DEVICE_IFACE,
                                    "DiscoverServices",
                                    DBUS_TYPE_STRING, &EmptyCString(),
                                    DBUS_TYPE_INVALID);
   }
 protected:
   static void DiscoverServicesCallback(DBusMessage* aMsg, void* aData)
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     nsRefPtr<OnUpdateSdpRecordsRunnable> r(
       static_cast<OnUpdateSdpRecordsRunnable*>(aData));
     NS_DispatchToMainThread(r);
   }
 private:
   const nsString mDeviceAddress;
   BluetoothProfileManagerBase* mBluetoothProfileManager;
 };
 bool
 BluetoothDBusService::UpdateSdpRecords(const nsAString& aDeviceAddress,
                                        BluetoothProfileManagerBase* aManager)
 {
   MOZ_ASSERT(NS_IsMainThread());
   Task* task = new UpdateSdpRecordsTask(aDeviceAddress, aManager);
   DispatchToDBusThread(task);
   return true;
 }
 void
 BluetoothDBusService::SendFile(const nsAString& aDeviceAddress,
                                BlobParent* aBlobParent,
                                BlobChild* aBlobChild,
                                BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Currently we only support one device sending one file at a time,
   // so we don't need aDeviceAddress here because the target device
   // has been determined when calling 'Connect()'. Nevertheless, keep
   // it for future use.
   BluetoothOppManager* opp = BluetoothOppManager::Get();
   nsAutoString errorStr;
   if (!opp || !opp->SendFile(aDeviceAddress, aBlobParent)) {
     errorStr.AssignLiteral("Calling SendFile() failed");
   }
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);
 }
 void
 BluetoothDBusService::SendFile(const nsAString& aDeviceAddress,
                                nsIDOMBlob* aBlob,
                                BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Currently we only support one device sending one file at a time,
   // so we don't need aDeviceAddress here because the target device
   // has been determined when calling 'Connect()'. Nevertheless, keep
   // it for future use.
   BluetoothOppManager* opp = BluetoothOppManager::Get();
   nsAutoString errorStr;
   if (!opp || !opp->SendFile(aDeviceAddress, aBlob)) {
     errorStr.AssignLiteral("Calling SendFile() failed");
   }
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);
 }
 void
 BluetoothDBusService::StopSendingFile(const nsAString& aDeviceAddress,
                                       BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Currently we only support one device sending one file at a time,
   // so we don't need aDeviceAddress here because the target device
   // has been determined when calling 'Connect()'. Nevertheless, keep
   // it for future use.
   BluetoothOppManager* opp = BluetoothOppManager::Get();
   nsAutoString errorStr;
   if (!opp || !opp->StopSendingFile()) {
     errorStr.AssignLiteral("Calling StopSendingFile() failed");
   }
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);
 }
 void
 BluetoothDBusService::ConfirmReceivingFile(const nsAString& aDeviceAddress,
                                            bool aConfirm,
                                            BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Must be called from main thread!");
   // Currently we only support one device sending one file at a time,
   // so we don't need aDeviceAddress here because the target device
   // has been determined when calling 'Connect()'. Nevertheless, keep
   // it for future use.
   BluetoothOppManager* opp = BluetoothOppManager::Get();
   nsAutoString errorStr;
   if (!opp || !opp->ConfirmReceivingFile(aConfirm)) {
     errorStr.AssignLiteral("Calling ConfirmReceivingFile() failed");
   }
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);
 }
 void
 BluetoothDBusService::ConnectSco(BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   if (!hfp || !hfp->ConnectSco(aRunnable)) {
     NS_NAMED_LITERAL_STRING(replyError, "Calling ConnectSco() failed");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), replyError);
   }
 }
 void
 BluetoothDBusService::DisconnectSco(BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   if (!hfp || !hfp->DisconnectSco()) {
     NS_NAMED_LITERAL_STRING(replyError, "Calling DisconnectSco() failed");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), replyError);
     return;
   }
   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());
 }
 void
 BluetoothDBusService::IsScoConnected(BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   if (!hfp) {
     NS_NAMED_LITERAL_STRING(replyError, "Fail to get BluetoothHfpManager");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), replyError);
     return;
   }
   DispatchBluetoothReply(aRunnable, hfp->IsScoConnected(), EmptyString());
 }
 class SendMetadataTask : public Task
 {
 public:
   SendMetadataTask(const nsAString& aDeviceAddress,
                    const nsACString& aTitle,
                    const nsACString& aArtist,
                    const nsACString& aAlbum,
                    int64_t aMediaNumber,
                    int64_t aTotalMediaCount,
                    int64_t aDuration,
                    BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mTitle(aTitle)
     , mArtist(aArtist)
     , mAlbum(aAlbum)
     , mMediaNumber(aMediaNumber)
     , mTotalMediaCount(aTotalMediaCount)
     , mDuration(aDuration)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     // We currently don't support genre field in music player.
     // In order to send media metadata through AVRCP, we set genre to an empty
     // string to match the BlueZ method "UpdateMetaData" with signature "sssssss",
     // which takes genre field as the last parameter.
     nsCString tempGenre = EmptyCString();
     nsCString tempMediaNumber = EmptyCString();
     nsCString tempTotalMediaCount = EmptyCString();
     nsCString tempDuration = EmptyCString();
     if (mMediaNumber >= 0) {
       tempMediaNumber.AppendInt(mMediaNumber);
     }
     if (mTotalMediaCount >= 0) {
       tempTotalMediaCount.AppendInt(mTotalMediaCount);
     }
     if (mDuration >= 0) {
       tempDuration.AppendInt(mDuration);
     }
     const nsCString objectPath = NS_ConvertUTF16toUTF8(
       GetObjectPathFromAddress(sAdapterPath, mDeviceAddress));
     const char* title = mTitle.get();
     const char* album = mAlbum.get();
     const char* artist = mArtist.get();
     const char* mediaNumber = tempMediaNumber.get();
     const char* totalMediaCount = tempTotalMediaCount.get();
     const char* duration = tempDuration.get();
     const char* genre = tempGenre.get();
     bool success = sDBusConnection->SendWithReply(
       GetVoidCallback, static_cast<void*>(mRunnable.get()), -1,
       BLUEZ_DBUS_BASE_IFC,
       objectPath.get(),
       DBUS_CTL_IFACE, "UpdateMetaData",
       DBUS_TYPE_STRING, &title,
       DBUS_TYPE_STRING, &artist,
       DBUS_TYPE_STRING, &album,
       DBUS_TYPE_STRING, &mediaNumber,
       DBUS_TYPE_STRING, &totalMediaCount,
       DBUS_TYPE_STRING, &duration,
       DBUS_TYPE_STRING, &genre,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << mRunnable.forget(); // picked up by callback handler
   }
 private:
   const nsString mDeviceAddress;
   const nsCString mTitle;
   const nsCString mArtist;
   const nsCString mAlbum;
   int64_t mMediaNumber;
   int64_t mTotalMediaCount;
   int64_t mDuration;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 void
 BluetoothDBusService::SendMetaData(const nsAString& aTitle,
                                    const nsAString& aArtist,
                                    const nsAString& aAlbum,
                                    int64_t aMediaNumber,
                                    int64_t aTotalMediaCount,
                                    int64_t aDuration,
                                    BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return;
   }
   BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
   NS_ENSURE_TRUE_VOID(a2dp);
   if (!a2dp->IsConnected()) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING(ERR_A2DP_IS_DISCONNECTED));
     return;
   } else if (!a2dp->IsAvrcpConnected()) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING(ERR_AVRCP_IS_DISCONNECTED));
     return;
   }
   nsAutoString prevTitle, prevAlbum;
   a2dp->GetTitle(prevTitle);
   a2dp->GetAlbum(prevAlbum);
   if (aMediaNumber != a2dp->GetMediaNumber() ||
       !aTitle.Equals(prevTitle) ||
       !aAlbum.Equals(prevAlbum)) {
     UpdateNotification(ControlEventId::EVENT_TRACK_CHANGED, aMediaNumber);
   }
   nsAutoString deviceAddress;
   a2dp->GetAddress(deviceAddress);
   Task* task = new SendMetadataTask(
     deviceAddress,
     NS_ConvertUTF16toUTF8(aTitle),
     NS_ConvertUTF16toUTF8(aArtist),
     NS_ConvertUTF16toUTF8(aAlbum),
     aMediaNumber,
     aTotalMediaCount,
     aDuration,
     aRunnable);
   DispatchToDBusThread(task);
   a2dp->UpdateMetaData(aTitle, aArtist, aAlbum,
                        aMediaNumber, aTotalMediaCount, aDuration);
 }
 static ControlPlayStatus
 PlayStatusStringToControlPlayStatus(const nsAString& aPlayStatus)
 {
   ControlPlayStatus playStatus = ControlPlayStatus::PLAYSTATUS_UNKNOWN;
   if (aPlayStatus.EqualsLiteral("STOPPED")) {
     playStatus = ControlPlayStatus::PLAYSTATUS_STOPPED;
   } else if (aPlayStatus.EqualsLiteral("PLAYING")) {
     playStatus = ControlPlayStatus::PLAYSTATUS_PLAYING;
   } else if (aPlayStatus.EqualsLiteral("PAUSED")) {
     playStatus = ControlPlayStatus::PLAYSTATUS_PAUSED;
   } else if (aPlayStatus.EqualsLiteral("FWD_SEEK")) {
     playStatus = ControlPlayStatus::PLAYSTATUS_FWD_SEEK;
   } else if (aPlayStatus.EqualsLiteral("REV_SEEK")) {
     playStatus = ControlPlayStatus::PLAYSTATUS_REV_SEEK;
   } else if (aPlayStatus.EqualsLiteral("ERROR")) {
     playStatus = ControlPlayStatus::PLAYSTATUS_ERROR;
   }
   return playStatus;
 }
 class SendPlayStatusTask : public Task
 {
 public:
   SendPlayStatusTask(const nsAString& aDeviceAddress,
                      int64_t aDuration,
                      int64_t aPosition,
                      ControlPlayStatus aPlayStatus,
                      BluetoothReplyRunnable* aRunnable)
     : mDeviceAddress(aDeviceAddress)
     , mDuration(aDuration)
     , mPosition(aPosition)
     , mPlayStatus(aPlayStatus)
     , mRunnable(aRunnable)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
     MOZ_ASSERT(mRunnable);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     const nsCString objectPath = NS_ConvertUTF16toUTF8(
       GetObjectPathFromAddress(sAdapterPath, mDeviceAddress));
     uint32_t tempPlayStatus = mPlayStatus;
     bool success = sDBusConnection->SendWithReply(
       GetVoidCallback, static_cast<void*>(mRunnable.get()), -1,
       BLUEZ_DBUS_BASE_IFC,
       objectPath.get(),
       DBUS_CTL_IFACE, "UpdatePlayStatus",
       DBUS_TYPE_UINT32, &mDuration,
       DBUS_TYPE_UINT32, &mPosition,
       DBUS_TYPE_UINT32, &tempPlayStatus,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
     unused << mRunnable.forget(); // picked up by callback handler
   }
 private:
   const nsString mDeviceAddress;
   int64_t mDuration;
   int64_t mPosition;
   ControlPlayStatus mPlayStatus;
   nsRefPtr<BluetoothReplyRunnable> mRunnable;
 };
 void
 BluetoothDBusService::SendPlayStatus(int64_t aDuration,
                                      int64_t aPosition,
                                      const nsAString& aPlayStatus,
                                      BluetoothReplyRunnable* aRunnable)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!IsReady()) {
     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");
     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);
     return;
   }
   ControlPlayStatus playStatus =
     PlayStatusStringToControlPlayStatus(aPlayStatus);
   if (playStatus == ControlPlayStatus::PLAYSTATUS_UNKNOWN) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING("Invalid play status"));
     return;
   } else if (aDuration < 0) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING("Invalid duration"));
     return;
   } else if (aPosition < 0) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING("Invalid position"));
     return;
   }
   BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
   NS_ENSURE_TRUE_VOID(a2dp);
   if (!a2dp->IsConnected()) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING(ERR_A2DP_IS_DISCONNECTED));
     return;
   } else if (!a2dp->IsAvrcpConnected()) {
     DispatchBluetoothReply(aRunnable, BluetoothValue(),
                            NS_LITERAL_STRING(ERR_AVRCP_IS_DISCONNECTED));
     return;
   }
   if (playStatus != a2dp->GetPlayStatus()) {
     UpdateNotification(ControlEventId::EVENT_PLAYBACK_STATUS_CHANGED,
                        playStatus);
   } else if (aPosition != a2dp->GetPosition()) {
     UpdateNotification(ControlEventId::EVENT_PLAYBACK_POS_CHANGED, aPosition);
   }
   nsAutoString deviceAddress;
   a2dp->GetAddress(deviceAddress);
   Task* task = new SendPlayStatusTask(deviceAddress,
                                       aDuration,
                                       aPosition,
                                       playStatus,
                                       aRunnable);
   DispatchToDBusThread(task);
   a2dp->UpdatePlayStatus(aDuration, aPosition, playStatus);
 }
 static void
 ControlCallback(DBusMessage* aMsg, void* aParam)
 {
   NS_ENSURE_TRUE_VOID(aMsg);
   BluetoothValue v;
   nsAutoString replyError;
   UnpackVoidMessage(aMsg, nullptr, v, replyError);
   if (!v.get_bool()) {
     BT_WARNING(NS_ConvertUTF16toUTF8(replyError).get());
   }
 }
 class UpdatePlayStatusTask : public Task
 {
 public:
   UpdatePlayStatusTask(const nsAString& aDeviceAddress,
                        int32_t aDuration,
                        int32_t aPosition,
                        ControlPlayStatus aPlayStatus)
     : mDeviceAddress(aDeviceAddress)
     , mDuration(aDuration)
     , mPosition(aPosition)
     , mPlayStatus(aPlayStatus)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     const nsCString objectPath = NS_ConvertUTF16toUTF8(
       GetObjectPathFromAddress(sAdapterPath, mDeviceAddress));
     uint32_t tempPlayStatus = mPlayStatus;
     bool success = sDBusConnection->SendWithReply(
       ControlCallback, nullptr, -1,
       BLUEZ_DBUS_BASE_IFC,
       objectPath.get(),
       DBUS_CTL_IFACE, "UpdatePlayStatus",
       DBUS_TYPE_UINT32, &mDuration,
       DBUS_TYPE_UINT32, &mPosition,
       DBUS_TYPE_UINT32, &tempPlayStatus,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
   }
 private:
   const nsString mDeviceAddress;
   int32_t mDuration;
   int32_t mPosition;
   ControlPlayStatus mPlayStatus;
 };
 void
 BluetoothDBusService::UpdatePlayStatus(uint32_t aDuration,
                                        uint32_t aPosition,
                                        ControlPlayStatus aPlayStatus)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NS_ENSURE_TRUE_VOID(this->IsReady());
   BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
   NS_ENSURE_TRUE_VOID(a2dp);
   MOZ_ASSERT(a2dp->IsConnected());
   MOZ_ASSERT(a2dp->IsAvrcpConnected());
   MOZ_ASSERT(!sAdapterPath.IsEmpty());
   nsAutoString deviceAddress;
   a2dp->GetAddress(deviceAddress);
   Task* task = new UpdatePlayStatusTask(deviceAddress,
                                         aDuration,
                                         aPosition,
                                         aPlayStatus);
   DispatchToDBusThread(task);
 }
 class UpdateNotificationTask : public Task
 {
 public:
   UpdateNotificationTask(const nsAString& aDeviceAddress,
                          BluetoothDBusService::ControlEventId aEventId,
                          uint64_t aData)
     : mDeviceAddress(aDeviceAddress)
     , mEventId(aEventId)
     , mData(aData)
   {
     MOZ_ASSERT(!mDeviceAddress.IsEmpty());
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
     MOZ_ASSERT(sDBusConnection);
     MOZ_ASSERT(!sAdapterPath.IsEmpty());
     const nsCString objectPath = NS_ConvertUTF16toUTF8(
       GetObjectPathFromAddress(sAdapterPath, mDeviceAddress));
     uint16_t eventId = mEventId;
     bool success = sDBusConnection->SendWithReply(
       ControlCallback, nullptr, -1,
       BLUEZ_DBUS_BASE_IFC,
       objectPath.get(),
       DBUS_CTL_IFACE, "UpdateNotification",
       DBUS_TYPE_UINT16, &eventId,
       DBUS_TYPE_UINT64, &mData,
       DBUS_TYPE_INVALID);
     NS_ENSURE_TRUE_VOID(success);
   }
 private:
   const nsString mDeviceAddress;
   int16_t mEventId;
   int32_t mData;
 };
 void
 BluetoothDBusService::UpdateNotification(ControlEventId aEventId,
                                          uint64_t aData)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NS_ENSURE_TRUE_VOID(this->IsReady());
   BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();
   NS_ENSURE_TRUE_VOID(a2dp);
   MOZ_ASSERT(a2dp->IsConnected());
   MOZ_ASSERT(a2dp->IsAvrcpConnected());
   MOZ_ASSERT(!sAdapterPath.IsEmpty());
   nsAutoString deviceAddress;
   a2dp->GetAddress(deviceAddress);
   Task* task = new UpdateNotificationTask(deviceAddress, aEventId, aData);
   DispatchToDBusThread(task);
 }

The Tor Browser / annotate

dom/bluetooth/bluez/BluetoothDBusService.cpp@b8a032363ba2 (annotated)

dom/bluetooth/bluez/BluetoothDBusService.cpp