Bug 1205635: Don't define methods of Bluetooth backend interfaces in header, r=btian
authorThomas Zimmermann <tdz@users.sourceforge.net>
Mon, 21 Sep 2015 11:18:11 +0200
changeset 263521 1d43875e85221e16fc91e10d617bf2840cd3da13
parent 263520 00f49336cb8cd06cc65bc2f1e44774f6796997df
child 263522 cea992dbc0312078a5e57a922ba3310c8291551f
push id29411
push userkwierso@gmail.com
push dateMon, 21 Sep 2015 16:44:53 +0000
treeherdermozilla-central@197af2fb7e29 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbtian
bugs1205635
milestone43.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1205635: Don't define methods of Bluetooth backend interfaces in header, r=btian Except the d'tors, we usually don't call any interfaces of the Bluetooth backend interfaces. All methods are overriden in child classes. This patch move the methods from the interface's header file to the source file. Only the result handlers' d'tors are located in the header, as they can be inlined.
dom/bluetooth/common/BluetoothInterface.cpp
dom/bluetooth/common/BluetoothInterface.h
--- a/dom/bluetooth/common/BluetoothInterface.cpp
+++ b/dom/bluetooth/common/BluetoothInterface.cpp
@@ -13,18 +13,18 @@
 #endif
 
 BEGIN_BLUETOOTH_NAMESPACE
 
 //
 // Setup Interface
 //
 
-BluetoothSetupResultHandler::~BluetoothSetupResultHandler()
-{ }
+// Result handling
+//
 
 void
 BluetoothSetupResultHandler::OnError(BluetoothStatus aStatus)
 {
   BT_WARNING("Received error code %d", (int)aStatus);
 }
 
 void
@@ -38,28 +38,220 @@ BluetoothSetupResultHandler::UnregisterM
 void
 BluetoothSetupResultHandler::Configuration()
 { }
 
 //
 // Socket Interface
 //
 
+// Result handling
+//
+
+void
+BluetoothSocketResultHandler::OnError(BluetoothStatus aStatus)
+{
+  BT_WARNING("Received error code %d", (int)aStatus);
+}
+
+void
+BluetoothSocketResultHandler::Listen(int aSockFd)
+{ }
+
+void
+BluetoothSocketResultHandler::Connect(int aSockFd,
+                                      const nsAString& aBdAddress,
+                                      int aConnectionState)
+{ }
+
+void
+BluetoothSocketResultHandler::Accept(int aSockFd,
+                                     const nsAString& aBdAddress,
+                                     int aConnectionState)
+{ }
+
+// Interface
+//
+
 BluetoothSocketInterface::~BluetoothSocketInterface()
 { }
 
 //
 // Handsfree Interface
 //
 
 // Notification handling
 //
 
-BluetoothHandsfreeNotificationHandler::
-  ~BluetoothHandsfreeNotificationHandler()
+BluetoothHandsfreeNotificationHandler::BluetoothHandsfreeNotificationHandler()
+{ }
+
+BluetoothHandsfreeNotificationHandler::~BluetoothHandsfreeNotificationHandler()
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::ConnectionStateNotification(
+  BluetoothHandsfreeConnectionState aState, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::AudioStateNotification(
+  BluetoothHandsfreeAudioState aState, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::VoiceRecognitionNotification(
+  BluetoothHandsfreeVoiceRecognitionState aState, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::AnswerCallNotification(
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::HangupCallNotification(
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::VolumeNotification(
+  BluetoothHandsfreeVolumeType aType, int aVolume, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::DialCallNotification(
+  const nsAString& aNumber, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::DtmfNotification(
+  char aDtmf, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::NRECNotification(
+  BluetoothHandsfreeNRECState aNrec, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::WbsNotification(
+  BluetoothHandsfreeWbsConfig aWbs, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::CallHoldNotification(
+  BluetoothHandsfreeCallHoldType aChld, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::CnumNotification(
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::CindNotification(
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::CopsNotification(
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::ClccNotification(
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::UnknownAtNotification(
+  const nsACString& aAtString, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothHandsfreeNotificationHandler::KeyPressedNotification(
+  const nsAString& aBdAddr)
+{ }
+
+// Result handling
+//
+
+void
+BluetoothHandsfreeResultHandler::OnError(BluetoothStatus aStatus)
+{
+  BT_WARNING("Received error code %d", (int)aStatus);
+}
+
+void
+BluetoothHandsfreeResultHandler::Init()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::Cleanup()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::Connect()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::Disconnect()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::ConnectAudio()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::DisconnectAudio()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::StartVoiceRecognition()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::StopVoiceRecognition()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::VolumeControl()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::DeviceStatusNotification()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::CopsResponse()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::CindResponse()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::FormattedAtResponse()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::AtResponse()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::ClccResponse()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::PhoneStateChange()
+{ }
+
+void
+BluetoothHandsfreeResultHandler::ConfigureWbs()
 { }
 
 // Interface
 //
 
 BluetoothHandsfreeInterface::BluetoothHandsfreeInterface()
 { }
 
@@ -68,76 +260,765 @@ BluetoothHandsfreeInterface::~BluetoothH
 
 //
 // Bluetooth Advanced Audio Interface
 //
 
 // Notification handling
 //
 
+BluetoothA2dpNotificationHandler::BluetoothA2dpNotificationHandler()
+{ }
+
 BluetoothA2dpNotificationHandler::~BluetoothA2dpNotificationHandler()
 { }
 
+void
+BluetoothA2dpNotificationHandler::ConnectionStateNotification(
+  BluetoothA2dpConnectionState aState, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothA2dpNotificationHandler::AudioStateNotification(
+  BluetoothA2dpAudioState aState, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothA2dpNotificationHandler::AudioConfigNotification(
+  const nsAString& aBdAddr, uint32_t aSampleRate, uint8_t aChannelCount)
+{ }
+
+// Result handling
+//
+
+void
+BluetoothA2dpResultHandler::OnError(BluetoothStatus aStatus)
+{
+  BT_WARNING("Received error code %d", (int)aStatus);
+}
+
+void
+BluetoothA2dpResultHandler::Init()
+{ }
+
+void
+BluetoothA2dpResultHandler::Cleanup()
+{ }
+
+void
+BluetoothA2dpResultHandler::Connect()
+{ }
+
+void
+BluetoothA2dpResultHandler::Disconnect()
+{ }
+
 // Interface
 //
 
 BluetoothA2dpInterface::BluetoothA2dpInterface()
 { }
 
 BluetoothA2dpInterface::~BluetoothA2dpInterface()
 { }
 
 //
 // Bluetooth AVRCP Interface
 //
 
 // Notification handling
 //
 
+BluetoothAvrcpNotificationHandler::BluetoothAvrcpNotificationHandler()
+{ }
+
 BluetoothAvrcpNotificationHandler::~BluetoothAvrcpNotificationHandler()
 { }
 
+void
+BluetoothAvrcpNotificationHandler::GetPlayStatusNotification()
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::ListPlayerAppAttrNotification()
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::ListPlayerAppValuesNotification(
+  BluetoothAvrcpPlayerAttribute aAttrId)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::GetPlayerAppValueNotification(
+  uint8_t aNumAttrs, const BluetoothAvrcpPlayerAttribute* aAttrs)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::GetPlayerAppAttrsTextNotification(
+  uint8_t aNumAttrs, const BluetoothAvrcpPlayerAttribute* aAttrs)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::GetPlayerAppValuesTextNotification(
+  uint8_t aAttrId, uint8_t aNumVals, const uint8_t* aValues)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::SetPlayerAppValueNotification(
+  const BluetoothAvrcpPlayerSettings& aSettings)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::GetElementAttrNotification(
+  uint8_t aNumAttrs, const BluetoothAvrcpMediaAttribute* aAttrs)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::RegisterNotificationNotification(
+  BluetoothAvrcpEvent aEvent, uint32_t aParam)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::RemoteFeatureNotification(
+  const nsAString& aBdAddr, unsigned long aFeatures)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::VolumeChangeNotification(
+  uint8_t aVolume, uint8_t aCType)
+{ }
+
+void
+BluetoothAvrcpNotificationHandler::PassthroughCmdNotification(
+  int aId, int aKeyState)
+{ }
+
+// Result handling
+//
+
+void
+BluetoothAvrcpResultHandler::OnError(BluetoothStatus aStatus)
+{
+  BT_WARNING("Received error code %d", (int)aStatus);
+}
+
+void
+BluetoothAvrcpResultHandler::Init()
+{ }
+
+void
+BluetoothAvrcpResultHandler::Cleanup()
+{ }
+
+void
+BluetoothAvrcpResultHandler::GetPlayStatusRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::ListPlayerAppAttrRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::ListPlayerAppValueRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::GetPlayerAppValueRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::GetPlayerAppAttrTextRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::GetPlayerAppValueTextRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::GetElementAttrRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::SetPlayerAppValueRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::RegisterNotificationRsp()
+{ }
+
+void
+BluetoothAvrcpResultHandler::SetVolume()
+{ }
+
 // Interface
 //
 
 BluetoothAvrcpInterface::BluetoothAvrcpInterface()
 { }
 
 BluetoothAvrcpInterface::~BluetoothAvrcpInterface()
 { }
 
 //
 // Bluetooth GATT Interface
 //
 
 // Notification handling
 //
 
+BluetoothGattNotificationHandler::BluetoothGattNotificationHandler()
+{ }
+
 BluetoothGattNotificationHandler::~BluetoothGattNotificationHandler()
 { }
 
+void
+BluetoothGattNotificationHandler::RegisterClientNotification(
+  BluetoothGattStatus aStatus, int aClientIf, const BluetoothUuid& aAppUuid)
+{ }
+
+void
+BluetoothGattNotificationHandler::ScanResultNotification(
+  const nsAString& aBdAddr, int aRssi, const BluetoothGattAdvData& aAdvData)
+{ }
+
+void
+BluetoothGattNotificationHandler::ConnectNotification(
+  int aConnId, BluetoothGattStatus aStatus, int aClientIf,
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothGattNotificationHandler::DisconnectNotification(
+  int aConnId, BluetoothGattStatus aStatus, int aClientIf,
+  const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothGattNotificationHandler::SearchCompleteNotification(
+  int aConnId, BluetoothGattStatus aStatus)
+{ }
+
+void
+BluetoothGattNotificationHandler::SearchResultNotification(
+  int aConnId, const BluetoothGattServiceId& aServiceId)
+{ }
+
+void
+BluetoothGattNotificationHandler::GetCharacteristicNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattServiceId& aServiceId,
+  const BluetoothGattId& aCharId,
+  const BluetoothGattCharProp& aCharProperty)
+{ }
+
+void
+BluetoothGattNotificationHandler::GetDescriptorNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattServiceId& aServiceId,
+  const BluetoothGattId& aCharId,
+  const BluetoothGattId& aDescriptorId)
+{ }
+
+void
+BluetoothGattNotificationHandler::GetIncludedServiceNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattServiceId& aServiceId,
+  const BluetoothGattServiceId& aIncludedServId)
+{ }
+
+void
+BluetoothGattNotificationHandler::RegisterNotificationNotification(
+  int aConnId, int aIsRegister, BluetoothGattStatus aStatus,
+  const BluetoothGattServiceId& aServiceId, const BluetoothGattId& aCharId)
+{ }
+
+void
+BluetoothGattNotificationHandler::NotifyNotification(
+  int aConnId, const BluetoothGattNotifyParam& aNotifyParam)
+{ }
+
+void
+BluetoothGattNotificationHandler::ReadCharacteristicNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattReadParam& aReadParam)
+{ }
+
+void
+BluetoothGattNotificationHandler::WriteCharacteristicNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattWriteParam& aWriteParam)
+{ }
+
+void
+BluetoothGattNotificationHandler::ReadDescriptorNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattReadParam& aReadParam)
+{ }
+
+void
+BluetoothGattNotificationHandler::WriteDescriptorNotification(
+  int aConnId, BluetoothGattStatus aStatus,
+  const BluetoothGattWriteParam& aWriteParam)
+{ }
+
+void
+BluetoothGattNotificationHandler::ExecuteWriteNotification(
+  int aConnId, BluetoothGattStatus aStatus)
+{ }
+
+void
+BluetoothGattNotificationHandler::ReadRemoteRssiNotification(
+  int aClientIf, const nsAString& aBdAddr, int aRssi,
+  BluetoothGattStatus aStatus)
+{ }
+
+void
+BluetoothGattNotificationHandler::ListenNotification(
+  BluetoothGattStatus aStatus, int aServerIf)
+{ }
+
+void
+BluetoothGattNotificationHandler::RegisterServerNotification(
+  BluetoothGattStatus aStatus, int aServerIf, const BluetoothUuid& aAppUuid)
+{ }
+
+void
+BluetoothGattNotificationHandler::ConnectionNotification(
+  int aConnId, int aServerIf, bool aConnected, const nsAString& aBdAddr)
+{ }
+
+void
+BluetoothGattNotificationHandler::ServiceAddedNotification(
+  BluetoothGattStatus aStatus, int aServerIf,
+  const BluetoothGattServiceId& aServiceId, int aServiceHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::IncludedServiceAddedNotification(
+  BluetoothGattStatus aStatus, int aServerIf, int aServiceHandle,
+  int aIncludedServiceHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::CharacteristicAddedNotification(
+  BluetoothGattStatus aStatus, int aServerIf, const BluetoothUuid& aCharId,
+  int aServiceHandle, int aCharacteristicHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::DescriptorAddedNotification(
+  BluetoothGattStatus aStatus, int aServerIf, const BluetoothUuid& aCharId,
+  int aServiceHandle, int aDescriptorHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::ServiceStartedNotification(
+  BluetoothGattStatus aStatus, int aServerIf, int aServiceHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::ServiceStoppedNotification(
+  BluetoothGattStatus aStatus, int aServerIf, int aServiceHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::ServiceDeletedNotification(
+  BluetoothGattStatus aStatus, int aServerIf, int aServiceHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::RequestReadNotification(
+  int aConnId, int aTransId, const nsAString& aBdAddr, int aAttributeHandle,
+  int aOffset, bool aIsLong)
+{ }
+
+void
+BluetoothGattNotificationHandler::RequestWriteNotification(
+  int aConnId, int aTransId, const nsAString& aBdAddr, int aAttributeHandle,
+  int aOffset, int aLength, const uint8_t* aValue, bool aNeedResponse,
+  bool aIsPrepareWrite)
+{ }
+
+void
+BluetoothGattNotificationHandler::RequestExecuteWriteNotification(
+  int aConnId, int aTransId, const nsAString& aBdAddr, bool aExecute)
+{ }
+
+void
+BluetoothGattNotificationHandler::ResponseConfirmationNotification(
+  BluetoothGattStatus aStatus, int aHandle)
+{ }
+
+void
+BluetoothGattNotificationHandler::IndicationSentNotification(
+  int aConnId, BluetoothGattStatus aStatus)
+{ }
+
+void
+BluetoothGattNotificationHandler::CongestionNotification(int aConnId,
+                                                         bool aCongested)
+{ }
+
+void
+BluetoothGattNotificationHandler::MtuChangedNotification(int aConnId,
+                                                         int aMtu)
+{ }
+
+// Result handling
+//
+
+void
+BluetoothGattResultHandler::OnError(BluetoothStatus aStatus)
+{
+  BT_WARNING("Received error code %d", (int)aStatus);
+}
+
+void
+BluetoothGattResultHandler::Init()
+{ }
+
+void
+BluetoothGattResultHandler::Cleanup()
+{ }
+
+void
+BluetoothGattResultHandler::RegisterClient()
+{ }
+
+void
+BluetoothGattResultHandler::UnregisterClient()
+{ }
+
+void
+BluetoothGattResultHandler::Scan()
+{ }
+
+void
+BluetoothGattResultHandler::Connect()
+{ }
+
+void
+BluetoothGattResultHandler::Disconnect()
+{ }
+
+void
+BluetoothGattResultHandler::Listen()
+{ }
+
+void
+BluetoothGattResultHandler::Refresh()
+{ }
+
+void
+BluetoothGattResultHandler::SearchService()
+{ }
+
+void
+BluetoothGattResultHandler::GetIncludedService()
+{ }
+
+void
+BluetoothGattResultHandler::GetCharacteristic()
+{ }
+
+void
+BluetoothGattResultHandler::GetDescriptor()
+{ }
+
+void
+BluetoothGattResultHandler::ReadCharacteristic()
+{ }
+
+void
+BluetoothGattResultHandler::WriteCharacteristic()
+{ }
+
+void
+BluetoothGattResultHandler::ReadDescriptor()
+{ }
+
+void
+BluetoothGattResultHandler::WriteDescriptor()
+{ }
+
+void
+BluetoothGattResultHandler::ExecuteWrite()
+{ }
+
+void
+BluetoothGattResultHandler::RegisterNotification()
+{ }
+
+void
+BluetoothGattResultHandler::DeregisterNotification()
+{ }
+
+void
+BluetoothGattResultHandler::ReadRemoteRssi()
+{ }
+
+void
+BluetoothGattResultHandler::GetDeviceType(BluetoothTypeOfDevice aType)
+{ }
+
+void
+BluetoothGattResultHandler::SetAdvData()
+{ }
+
+void
+BluetoothGattResultHandler::TestCommand()
+{ }
+
+void
+BluetoothGattResultHandler::RegisterServer()
+{ }
+
+void
+BluetoothGattResultHandler::UnregisterServer()
+{ }
+
+void
+BluetoothGattResultHandler::ConnectPeripheral()
+{ }
+
+void
+BluetoothGattResultHandler::DisconnectPeripheral()
+{ }
+
+void
+BluetoothGattResultHandler::AddService()
+{ }
+
+void
+BluetoothGattResultHandler::AddIncludedService()
+{ }
+
+void
+BluetoothGattResultHandler::AddCharacteristic()
+{ }
+
+void
+BluetoothGattResultHandler::AddDescriptor()
+{ }
+
+void
+BluetoothGattResultHandler::StartService()
+{ }
+
+void
+BluetoothGattResultHandler::StopService()
+{ }
+
+void
+BluetoothGattResultHandler::DeleteService()
+{ }
+
+void
+BluetoothGattResultHandler::SendIndication()
+{ }
+
+void
+BluetoothGattResultHandler::SendResponse()
+{ }
+
 // Interface
 //
 
 BluetoothGattInterface::BluetoothGattInterface()
 { }
 
 BluetoothGattInterface::~BluetoothGattInterface()
 { }
 
 //
 // Bluetooth Core Interface
 //
 
 // Notification handling
 //
 
+BluetoothNotificationHandler::BluetoothNotificationHandler()
+{ }
+
 BluetoothNotificationHandler::~BluetoothNotificationHandler()
 { }
 
+void
+BluetoothNotificationHandler::AdapterStateChangedNotification(bool aState)
+{ }
+
+void
+BluetoothNotificationHandler::AdapterPropertiesNotification(
+  BluetoothStatus aStatus,int aNumProperties,
+  const BluetoothProperty* aProperties)
+{ }
+
+void
+BluetoothNotificationHandler::RemoteDevicePropertiesNotification(
+  BluetoothStatus aStatus, const nsAString& aBdAddr, int aNumProperties,
+  const BluetoothProperty* aProperties)
+{ }
+
+void
+BluetoothNotificationHandler::DeviceFoundNotification(
+  int aNumProperties, const BluetoothProperty* aProperties)
+{ }
+
+void
+BluetoothNotificationHandler::DiscoveryStateChangedNotification(bool aState)
+{ }
+
+void
+BluetoothNotificationHandler::PinRequestNotification(
+  const nsAString& aRemoteBdAddr, const nsAString& aBdName, uint32_t aCod)
+{ }
+
+void
+BluetoothNotificationHandler::SspRequestNotification(
+  const nsAString& aRemoteBdAddr, const nsAString& aBdName, uint32_t aCod,
+  BluetoothSspVariant aPairingVariant, uint32_t aPassKey)
+{ }
+
+void
+BluetoothNotificationHandler::BondStateChangedNotification(
+  BluetoothStatus aStatus, const nsAString& aRemoteBdAddr,
+  BluetoothBondState aState)
+{ }
+
+void
+BluetoothNotificationHandler::AclStateChangedNotification(
+  BluetoothStatus aStatus, const nsAString& aRemoteBdAddr, bool aState)
+{ }
+
+void
+BluetoothNotificationHandler::DutModeRecvNotification(uint16_t aOpcode,
+                                                      const uint8_t* aBuf,
+                                                      uint8_t aLen)
+{ }
+
+void
+BluetoothNotificationHandler::LeTestModeNotification(BluetoothStatus aStatus,
+                                                     uint16_t aNumPackets)
+{ }
+
+void
+BluetoothNotificationHandler::EnergyInfoNotification(
+  const BluetoothActivityEnergyInfo& aInfo)
+{ }
+
+void
+BluetoothNotificationHandler::BackendErrorNotification(bool aCrashed)
+{ }
+
+// Result handling
+//
+
+void
+BluetoothResultHandler::OnError(BluetoothStatus aStatus)
+{
+  BT_LOGR("Received error code %d", aStatus);
+}
+
+void
+BluetoothResultHandler::Init()
+{ }
+
+void
+BluetoothResultHandler::Cleanup()
+{ }
+
+void
+BluetoothResultHandler::Enable()
+{ }
+
+void
+BluetoothResultHandler::Disable()
+{ }
+
+void
+BluetoothResultHandler::GetAdapterProperties()
+{ }
+
+void
+BluetoothResultHandler::GetAdapterProperty()
+{ }
+
+void
+BluetoothResultHandler::SetAdapterProperty()
+{ }
+
+void
+BluetoothResultHandler::GetRemoteDeviceProperties()
+{ }
+
+void
+BluetoothResultHandler::GetRemoteDeviceProperty()
+{ }
+
+void
+BluetoothResultHandler::SetRemoteDeviceProperty()
+{ }
+
+void
+BluetoothResultHandler::GetRemoteServiceRecord()
+{ }
+
+void
+BluetoothResultHandler::GetRemoteServices()
+{ }
+
+void
+BluetoothResultHandler::StartDiscovery()
+{ }
+
+void
+BluetoothResultHandler::CancelDiscovery()
+{ }
+
+void
+BluetoothResultHandler::CreateBond()
+{ }
+
+void
+BluetoothResultHandler::RemoveBond()
+{ }
+
+void
+BluetoothResultHandler::CancelBond()
+{ }
+
+void
+BluetoothResultHandler::GetConnectionState()
+{ }
+
+void
+BluetoothResultHandler::PinReply()
+{ }
+
+void
+BluetoothResultHandler::SspReply()
+{ }
+
+void
+BluetoothResultHandler::DutModeConfigure()
+{ }
+
+void
+BluetoothResultHandler::DutModeSend()
+{ }
+
+void
+BluetoothResultHandler::LeTestMode()
+{ }
+
+void
+BluetoothResultHandler::ReadEnergyInfo()
+{ }
+
 // Interface
 //
 
 BluetoothInterface*
 BluetoothInterface::GetInstance()
 {
 #if ANDROID_VERSION >= 17
   /* We pick a default backend from the available ones. The options are
--- a/dom/bluetooth/common/BluetoothInterface.h
+++ b/dom/bluetooth/common/BluetoothInterface.h
@@ -22,37 +22,34 @@ class BluetoothSetupResultHandler
 {
 public:
   virtual void OnError(BluetoothStatus aStatus);
   virtual void RegisterModule();
   virtual void UnregisterModule();
   virtual void Configuration();
 
 protected:
-  virtual ~BluetoothSetupResultHandler();
+  virtual ~BluetoothSetupResultHandler() { }
 };
 
 //
 // Socket Interface
 //
 
 class BluetoothSocketResultHandler
   : public mozilla::ipc::DaemonSocketResultHandler
 {
 public:
-  virtual void OnError(BluetoothStatus aStatus)
-  {
-    BT_WARNING("Received error code %d", (int)aStatus);
-  }
+  virtual void OnError(BluetoothStatus aStatus);
 
-  virtual void Listen(int aSockFd) { }
+  virtual void Listen(int aSockFd);
   virtual void Connect(int aSockFd, const nsAString& aBdAddress,
-                       int aConnectionState) { }
+                       int aConnectionState);
   virtual void Accept(int aSockFd, const nsAString& aBdAddress,
-                      int aConnectionState) { }
+                      int aConnectionState);
 
 protected:
   virtual ~BluetoothSocketResultHandler() { }
 };
 
 class BluetoothSocketInterface
 {
 public:
@@ -82,132 +79,110 @@ protected:
 // Handsfree Interface
 //
 
 class BluetoothHandsfreeNotificationHandler
 {
 public:
   virtual void
   ConnectionStateNotification(BluetoothHandsfreeConnectionState aState,
-                              const nsAString& aBdAddr)
-  { }
+                              const nsAString& aBdAddr);
 
   virtual void
   AudioStateNotification(BluetoothHandsfreeAudioState aState,
-                         const nsAString& aBdAddr)
-  { }
+                         const nsAString& aBdAddr);
 
   virtual void
   VoiceRecognitionNotification(BluetoothHandsfreeVoiceRecognitionState aState,
-                               const nsAString& aBdAddr)
-  { }
+                               const nsAString& aBdAddr);
 
   virtual void
-  AnswerCallNotification(const nsAString& aBdAddr)
-  { }
+  AnswerCallNotification(const nsAString& aBdAddr);
 
   virtual void
-  HangupCallNotification(const nsAString& aBdAddr)
-  { }
+  HangupCallNotification(const nsAString& aBdAddr);
 
   virtual void
   VolumeNotification(BluetoothHandsfreeVolumeType aType,
                      int aVolume,
-                     const nsAString& aBdAddr)
-  { }
+                     const nsAString& aBdAddr);
 
   virtual void
   DialCallNotification(const nsAString& aNumber,
-                       const nsAString& aBdAddr)
-  { }
+                       const nsAString& aBdAddr);
 
   virtual void
   DtmfNotification(char aDtmf,
-                   const nsAString& aBdAddr)
-  { }
+                   const nsAString& aBdAddr);
 
   virtual void
   NRECNotification(BluetoothHandsfreeNRECState aNrec,
-                   const nsAString& aBdAddr)
-  { }
+                   const nsAString& aBdAddr);
 
   virtual void
   WbsNotification(BluetoothHandsfreeWbsConfig aWbs,
-                  const nsAString& aBdAddr)
-  { }
+                  const nsAString& aBdAddr);
 
   virtual void
   CallHoldNotification(BluetoothHandsfreeCallHoldType aChld,
-                       const nsAString& aBdAddr)
-  { }
+                       const nsAString& aBdAddr);
 
   virtual void
-  CnumNotification(const nsAString& aBdAddr)
-  { }
+  CnumNotification(const nsAString& aBdAddr);
 
   virtual void
-  CindNotification(const nsAString& aBdAddr)
-  { }
+  CindNotification(const nsAString& aBdAddr);
 
   virtual void
-  CopsNotification(const nsAString& aBdAddr)
-  { }
+  CopsNotification(const nsAString& aBdAddr);
 
   virtual void
-  ClccNotification(const nsAString& aBdAddr)
-  { }
+  ClccNotification(const nsAString& aBdAddr);
 
   virtual void
   UnknownAtNotification(const nsACString& aAtString,
-                        const nsAString& aBdAddr)
-  { }
+                        const nsAString& aBdAddr);
 
   virtual void
-  KeyPressedNotification(const nsAString& aBdAddr)
-  { }
+  KeyPressedNotification(const nsAString& aBdAddr);
 
 protected:
-  BluetoothHandsfreeNotificationHandler()
-  { }
-
+  BluetoothHandsfreeNotificationHandler();
   virtual ~BluetoothHandsfreeNotificationHandler();
 };
 
 class BluetoothHandsfreeResultHandler
   : public mozilla::ipc::DaemonSocketResultHandler
 {
 public:
-  virtual void OnError(BluetoothStatus aStatus)
-  {
-    BT_WARNING("Received error code %d", (int)aStatus);
-  }
+  virtual void OnError(BluetoothStatus aStatus);
+
+  virtual void Init();
+  virtual void Cleanup();
 
-  virtual void Init() { }
-  virtual void Cleanup() { }
+  virtual void Connect();
+  virtual void Disconnect();
+  virtual void ConnectAudio();
+  virtual void DisconnectAudio();
 
-  virtual void Connect() { }
-  virtual void Disconnect() { }
-  virtual void ConnectAudio() { }
-  virtual void DisconnectAudio() { }
+  virtual void StartVoiceRecognition();
+  virtual void StopVoiceRecognition();
 
-  virtual void StartVoiceRecognition() { }
-  virtual void StopVoiceRecognition() { }
+  virtual void VolumeControl();
 
-  virtual void VolumeControl() { }
-
-  virtual void DeviceStatusNotification() { }
+  virtual void DeviceStatusNotification();
 
-  virtual void CopsResponse() { }
-  virtual void CindResponse() { }
-  virtual void FormattedAtResponse() { }
-  virtual void AtResponse() { }
-  virtual void ClccResponse() { }
-  virtual void PhoneStateChange() { }
+  virtual void CopsResponse();
+  virtual void CindResponse();
+  virtual void FormattedAtResponse();
+  virtual void AtResponse();
+  virtual void ClccResponse();
+  virtual void PhoneStateChange();
 
-  virtual void ConfigureWbs() { }
+  virtual void ConfigureWbs();
 
 protected:
   virtual ~BluetoothHandsfreeResultHandler() { }
 };
 
 class BluetoothHandsfreeInterface
 {
 public:
@@ -292,50 +267,42 @@ protected:
 // Bluetooth Advanced Audio Interface
 //
 
 class BluetoothA2dpNotificationHandler
 {
 public:
   virtual void
   ConnectionStateNotification(BluetoothA2dpConnectionState aState,
-                              const nsAString& aBdAddr)
-  { }
+                              const nsAString& aBdAddr);
 
   virtual void
   AudioStateNotification(BluetoothA2dpAudioState aState,
-                         const nsAString& aBdAddr)
-  { }
+                         const nsAString& aBdAddr);
 
   virtual void
   AudioConfigNotification(const nsAString& aBdAddr,
                           uint32_t aSampleRate,
-                          uint8_t aChannelCount)
-  { }
+                          uint8_t aChannelCount);
 
 protected:
-  BluetoothA2dpNotificationHandler()
-  { }
-
+  BluetoothA2dpNotificationHandler();
   virtual ~BluetoothA2dpNotificationHandler();
 };
 
 class BluetoothA2dpResultHandler
   : public mozilla::ipc::DaemonSocketResultHandler
 {
 public:
-  virtual void OnError(BluetoothStatus aStatus)
-  {
-    BT_WARNING("Received error code %d", (int)aStatus);
-  }
+  virtual void OnError(BluetoothStatus aStatus);
 
-  virtual void Init() { }
-  virtual void Cleanup() { }
-  virtual void Connect() { }
-  virtual void Disconnect() { }
+  virtual void Init();
+  virtual void Cleanup();
+  virtual void Connect();
+  virtual void Disconnect();
 
 protected:
   virtual ~BluetoothA2dpResultHandler() { }
 };
 
 class BluetoothA2dpInterface
 {
 public:
@@ -356,103 +323,88 @@ protected:
 //
 // Bluetooth AVRCP Interface
 //
 
 class BluetoothAvrcpNotificationHandler
 {
 public:
   virtual void
-  GetPlayStatusNotification()
-  { }
+  GetPlayStatusNotification();
 
   virtual void
-  ListPlayerAppAttrNotification()
-  { }
+  ListPlayerAppAttrNotification();
 
   virtual void
-  ListPlayerAppValuesNotification(BluetoothAvrcpPlayerAttribute aAttrId)
-  { }
+  ListPlayerAppValuesNotification(BluetoothAvrcpPlayerAttribute aAttrId);
 
   virtual void
   GetPlayerAppValueNotification(uint8_t aNumAttrs,
-                                const BluetoothAvrcpPlayerAttribute* aAttrs)
-  { }
+                                const BluetoothAvrcpPlayerAttribute* aAttrs);
 
   virtual void
-  GetPlayerAppAttrsTextNotification(uint8_t aNumAttrs,
-                                    const BluetoothAvrcpPlayerAttribute* aAttrs)
-  { }
+  GetPlayerAppAttrsTextNotification(
+    uint8_t aNumAttrs, const BluetoothAvrcpPlayerAttribute* aAttrs);
 
   virtual void
   GetPlayerAppValuesTextNotification(uint8_t aAttrId, uint8_t aNumVals,
-                                     const uint8_t* aValues)
-  { }
+                                     const uint8_t* aValues);
 
   virtual void
-  SetPlayerAppValueNotification(const BluetoothAvrcpPlayerSettings& aSettings)
-  { }
+  SetPlayerAppValueNotification(
+    const BluetoothAvrcpPlayerSettings& aSettings);
 
   virtual void
   GetElementAttrNotification(uint8_t aNumAttrs,
-                             const BluetoothAvrcpMediaAttribute* aAttrs)
-  { }
+                             const BluetoothAvrcpMediaAttribute* aAttrs);
 
   virtual void
   RegisterNotificationNotification(BluetoothAvrcpEvent aEvent,
-                                   uint32_t aParam)
-  { }
+                                   uint32_t aParam);
 
   virtual void
-  RemoteFeatureNotification(const nsAString& aBdAddr, unsigned long aFeatures)
-  { }
+  RemoteFeatureNotification(const nsAString& aBdAddr,
+                            unsigned long aFeatures);
 
   virtual void
-  VolumeChangeNotification(uint8_t aVolume, uint8_t aCType)
-  { }
+  VolumeChangeNotification(uint8_t aVolume, uint8_t aCType);
 
   virtual void
-  PassthroughCmdNotification(int aId, int aKeyState)
-  { }
+  PassthroughCmdNotification(int aId, int aKeyState);
 
 protected:
-  BluetoothAvrcpNotificationHandler()
-  { }
-
+  BluetoothAvrcpNotificationHandler();
   virtual ~BluetoothAvrcpNotificationHandler();
 };
 
 class BluetoothAvrcpResultHandler
   : public mozilla::ipc::DaemonSocketResultHandler
 {
 public:
-  virtual void OnError(BluetoothStatus aStatus)
-  {
-    BT_WARNING("Received error code %d", (int)aStatus);
-  }
+  virtual void OnError(BluetoothStatus aStatus);
+
+  virtual void Init();
+  virtual void Cleanup();
 
-  virtual void Init() { }
-  virtual void Cleanup() { }
+  virtual void GetPlayStatusRsp();
 
-  virtual void GetPlayStatusRsp() { }
+  virtual void ListPlayerAppAttrRsp();
+  virtual void ListPlayerAppValueRsp();
 
-  virtual void ListPlayerAppAttrRsp() { }
-  virtual void ListPlayerAppValueRsp() { }
+  virtual void GetPlayerAppValueRsp();
+  virtual void GetPlayerAppAttrTextRsp();
+  virtual void GetPlayerAppValueTextRsp();
 
-  virtual void GetPlayerAppValueRsp() { }
-  virtual void GetPlayerAppAttrTextRsp() { }
-  virtual void GetPlayerAppValueTextRsp() { }
+  virtual void GetElementAttrRsp();
 
-  virtual void GetElementAttrRsp() { }
-
-  virtual void SetPlayerAppValueRsp() { }
+  virtual void SetPlayerAppValueRsp();
 
-  virtual void RegisterNotificationRsp() { }
+  virtual void RegisterNotificationRsp();
 
-  virtual void SetVolume() { }
+  virtual void SetVolume();
 
 protected:
   virtual ~BluetoothAvrcpResultHandler() { }
 };
 
 class BluetoothAvrcpInterface
 {
 public:
@@ -508,297 +460,262 @@ protected:
 //
 
 class BluetoothGattNotificationHandler
 {
 public:
   virtual void
   RegisterClientNotification(BluetoothGattStatus aStatus,
                              int aClientIf,
-                             const BluetoothUuid& aAppUuid)
-  { }
+                             const BluetoothUuid& aAppUuid);
 
   virtual void
   ScanResultNotification(const nsAString& aBdAddr,
                          int aRssi,
-                         const BluetoothGattAdvData& aAdvData)
-  { }
+                         const BluetoothGattAdvData& aAdvData);
 
   virtual void
   ConnectNotification(int aConnId,
                       BluetoothGattStatus aStatus,
                       int aClientIf,
-                      const nsAString& aBdAddr)
-  { }
+                      const nsAString& aBdAddr);
 
   virtual void
   DisconnectNotification(int aConnId,
                          BluetoothGattStatus aStatus,
                          int aClientIf,
-                         const nsAString& aBdAddr)
-  { }
+                         const nsAString& aBdAddr);
 
   virtual void
-  SearchCompleteNotification(int aConnId, BluetoothGattStatus aStatus) { }
+  SearchCompleteNotification(int aConnId, BluetoothGattStatus aStatus);
 
   virtual void
   SearchResultNotification(int aConnId,
-                           const BluetoothGattServiceId& aServiceId)
-  { }
+                           const BluetoothGattServiceId& aServiceId);
 
   virtual void
   GetCharacteristicNotification(int aConnId,
                                 BluetoothGattStatus aStatus,
                                 const BluetoothGattServiceId& aServiceId,
                                 const BluetoothGattId& aCharId,
-                                const BluetoothGattCharProp& aCharProperty)
-  { }
+                                const BluetoothGattCharProp& aCharProperty);
 
   virtual void
   GetDescriptorNotification(int aConnId,
                             BluetoothGattStatus aStatus,
                             const BluetoothGattServiceId& aServiceId,
                             const BluetoothGattId& aCharId,
-                            const BluetoothGattId& aDescriptorId)
-  { }
+                            const BluetoothGattId& aDescriptorId);
 
   virtual void
   GetIncludedServiceNotification(int aConnId,
                                  BluetoothGattStatus aStatus,
                                  const BluetoothGattServiceId& aServiceId,
-                                 const BluetoothGattServiceId& aIncludedServId)
-  { }
+                                 const BluetoothGattServiceId& aIncludedServId);
 
   virtual void
   RegisterNotificationNotification(int aConnId,
                                    int aIsRegister,
                                    BluetoothGattStatus aStatus,
                                    const BluetoothGattServiceId& aServiceId,
-                                   const BluetoothGattId& aCharId)
-  { }
+                                   const BluetoothGattId& aCharId);
 
   virtual void
-  NotifyNotification(int aConnId, const BluetoothGattNotifyParam& aNotifyParam)
-  { }
+  NotifyNotification(int aConnId,
+                     const BluetoothGattNotifyParam& aNotifyParam);
 
   virtual void
   ReadCharacteristicNotification(int aConnId,
                                  BluetoothGattStatus aStatus,
-                                 const BluetoothGattReadParam& aReadParam)
-  { }
+                                 const BluetoothGattReadParam& aReadParam);
 
   virtual void
   WriteCharacteristicNotification(int aConnId,
                                   BluetoothGattStatus aStatus,
-                                  const BluetoothGattWriteParam& aWriteParam)
-  { }
+                                  const BluetoothGattWriteParam& aWriteParam);
 
   virtual void
   ReadDescriptorNotification(int aConnId,
                              BluetoothGattStatus aStatus,
-                             const BluetoothGattReadParam& aReadParam)
-  { }
+                             const BluetoothGattReadParam& aReadParam);
 
   virtual void
   WriteDescriptorNotification(int aConnId,
                               BluetoothGattStatus aStatus,
-                              const BluetoothGattWriteParam& aWriteParam)
-  { }
+                              const BluetoothGattWriteParam& aWriteParam);
 
   virtual void
-  ExecuteWriteNotification(int aConnId, BluetoothGattStatus aStatus) { }
+  ExecuteWriteNotification(int aConnId, BluetoothGattStatus aStatus);
 
   virtual void
   ReadRemoteRssiNotification(int aClientIf,
                              const nsAString& aBdAddr,
                              int aRssi,
-                             BluetoothGattStatus aStatus)
-  { }
+                             BluetoothGattStatus aStatus);
 
   virtual void
-  ListenNotification(BluetoothGattStatus aStatus, int aServerIf) { }
+  ListenNotification(BluetoothGattStatus aStatus, int aServerIf);
 
   virtual void
   RegisterServerNotification(BluetoothGattStatus aStatus,
                              int aServerIf,
-                             const BluetoothUuid& aAppUuid)
-  { }
+                             const BluetoothUuid& aAppUuid);
 
   virtual void
   ConnectionNotification(int aConnId,
                          int aServerIf,
                          bool aConnected,
-                         const nsAString& aBdAddr)
-  { }
+                         const nsAString& aBdAddr);
 
   virtual void
   ServiceAddedNotification(BluetoothGattStatus aStatus,
                            int aServerIf,
                            const BluetoothGattServiceId& aServiceId,
-                           int aServiceHandle)
-  { }
+                           int aServiceHandle);
 
   virtual void
   IncludedServiceAddedNotification(BluetoothGattStatus aStatus,
                                    int aServerIf,
                                    int aServiceHandle,
-                                   int aIncludedServiceHandle)
-  { }
+                                   int aIncludedServiceHandle);
 
   virtual void
   CharacteristicAddedNotification(BluetoothGattStatus aStatus,
                                   int aServerIf,
                                   const BluetoothUuid& aCharId,
                                   int aServiceHandle,
-                                  int aCharacteristicHandle)
-  { }
+                                  int aCharacteristicHandle);
 
   virtual void
   DescriptorAddedNotification(BluetoothGattStatus aStatus,
                               int aServerIf,
                               const BluetoothUuid& aCharId,
                               int aServiceHandle,
-                              int aDescriptorHandle)
-  { }
+                              int aDescriptorHandle);
 
   virtual void
   ServiceStartedNotification(BluetoothGattStatus aStatus,
                              int aServerIf,
-                             int aServiceHandle)
-  { }
+                             int aServiceHandle);
 
   virtual void
   ServiceStoppedNotification(BluetoothGattStatus aStatus,
                              int aServerIf,
-                             int aServiceHandle)
-  { }
+                             int aServiceHandle);
 
   virtual void
   ServiceDeletedNotification(BluetoothGattStatus aStatus,
                              int aServerIf,
-                             int aServiceHandle)
-  { }
+                             int aServiceHandle);
 
   virtual void
   RequestReadNotification(int aConnId,
                           int aTransId,
                           const nsAString& aBdAddr,
                           int aAttributeHandle,
                           int aOffset,
-                          bool aIsLong)
-  { }
+                          bool aIsLong);
 
   virtual void
   RequestWriteNotification(int aConnId,
                            int aTransId,
                            const nsAString& aBdAddr,
                            int aAttributeHandle,
                            int aOffset,
                            int aLength,
                            const uint8_t* aValue,
                            bool aNeedResponse,
-                           bool aIsPrepareWrite)
-  { }
+                           bool aIsPrepareWrite);
 
   virtual void
   RequestExecuteWriteNotification(int aConnId,
                                   int aTransId,
                                   const nsAString& aBdAddr,
-                                  bool aExecute) /* true: execute */
-                                                 /* false: cancel */
-  { }
+                                  bool aExecute); /* true: execute */
+                                                  /* false: cancel */
 
   virtual void
   ResponseConfirmationNotification(BluetoothGattStatus aStatus,
-                                   int aHandle)
-  { }
+                                   int aHandle);
 
   virtual void
   IndicationSentNotification(int aConnId,
-                             BluetoothGattStatus aStatus)
-  { }
+                             BluetoothGattStatus aStatus);
 
   virtual void
   CongestionNotification(int aConnId,
-                         bool aCongested)
-  { }
+                         bool aCongested);
 
   virtual void
   MtuChangedNotification(int aConnId,
-                         int aMtu)
-  { }
+                         int aMtu);
 
 protected:
-  BluetoothGattNotificationHandler()
-  { }
-
+  BluetoothGattNotificationHandler();
   virtual ~BluetoothGattNotificationHandler();
 };
 
 class BluetoothGattResultHandler
   : public mozilla::ipc::DaemonSocketResultHandler
 {
 public:
-  virtual void OnError(BluetoothStatus aStatus)
-  {
-    BT_WARNING("Received error code %d", (int)aStatus);
-  }
+  virtual void OnError(BluetoothStatus aStatus);
+
+  virtual void Init();
+  virtual void Cleanup();
 
-  virtual void Init() { }
-  virtual void Cleanup() { }
+  virtual void RegisterClient();
+  virtual void UnregisterClient();
 
-  virtual void RegisterClient() { }
-  virtual void UnregisterClient() { }
+  virtual void Scan();
 
-  virtual void Scan() { }
+  virtual void Connect();
+  virtual void Disconnect();
 
-  virtual void Connect() { }
-  virtual void Disconnect() { }
-
-  virtual void Listen() { }
-  virtual void Refresh() { }
+  virtual void Listen();
+  virtual void Refresh();
 
-  virtual void SearchService() { }
-  virtual void GetIncludedService() { }
-  virtual void GetCharacteristic() { }
-  virtual void GetDescriptor() { }
+  virtual void SearchService();
+  virtual void GetIncludedService();
+  virtual void GetCharacteristic();
+  virtual void GetDescriptor();
 
-  virtual void ReadCharacteristic() { }
-  virtual void WriteCharacteristic() { }
-  virtual void ReadDescriptor() { }
-  virtual void WriteDescriptor() { }
+  virtual void ReadCharacteristic();
+  virtual void WriteCharacteristic();
+  virtual void ReadDescriptor();
+  virtual void WriteDescriptor();
 
-  virtual void ExecuteWrite() { }
+  virtual void ExecuteWrite();
 
-  virtual void RegisterNotification() { }
-  virtual void DeregisterNotification() { }
+  virtual void RegisterNotification();
+  virtual void DeregisterNotification();
 
-  virtual void ReadRemoteRssi() { }
-  virtual void GetDeviceType(BluetoothTypeOfDevice type) { }
-  virtual void SetAdvData() { }
-  virtual void TestCommand() { }
+  virtual void ReadRemoteRssi();
+  virtual void GetDeviceType(BluetoothTypeOfDevice aType);
+  virtual void SetAdvData();
+  virtual void TestCommand();
 
-  virtual void RegisterServer() { }
-  virtual void UnregisterServer() { }
+  virtual void RegisterServer();
+  virtual void UnregisterServer();
 
-  virtual void ConnectPeripheral() { }
-  virtual void DisconnectPeripheral() { }
+  virtual void ConnectPeripheral();
+  virtual void DisconnectPeripheral();
 
-  virtual void AddService() { }
-  virtual void AddIncludedService() { }
-  virtual void AddCharacteristic() { }
-  virtual void AddDescriptor() { }
+  virtual void AddService();
+  virtual void AddIncludedService();
+  virtual void AddCharacteristic();
+  virtual void AddDescriptor();
 
-  virtual void StartService() { }
-  virtual void StopService() { }
-  virtual void DeleteService() { }
+  virtual void StartService();
+  virtual void StopService();
+  virtual void DeleteService();
 
-  virtual void SendIndication() { }
+  virtual void SendIndication();
 
-  virtual void SendResponse() { }
+  virtual void SendResponse();
 
 protected:
   virtual ~BluetoothGattResultHandler() { }
 };
 
 class BluetoothGattInterface
 {
 public:
@@ -1007,107 +924,100 @@ protected:
 
 //
 // Bluetooth Core Interface
 //
 
 class BluetoothNotificationHandler
 {
 public:
-  virtual void AdapterStateChangedNotification(bool aState) { }
+  virtual void AdapterStateChangedNotification(bool aState);
   virtual void AdapterPropertiesNotification(
     BluetoothStatus aStatus, int aNumProperties,
-    const BluetoothProperty* aProperties) { }
+    const BluetoothProperty* aProperties);
 
   virtual void RemoteDevicePropertiesNotification(
     BluetoothStatus aStatus, const nsAString& aBdAddr,
-    int aNumProperties, const BluetoothProperty* aProperties) { }
+    int aNumProperties, const BluetoothProperty* aProperties);
 
   virtual void DeviceFoundNotification(
-    int aNumProperties, const BluetoothProperty* aProperties) { }
+    int aNumProperties, const BluetoothProperty* aProperties);
 
-  virtual void DiscoveryStateChangedNotification(bool aState) { }
+  virtual void DiscoveryStateChangedNotification(bool aState);
 
   virtual void PinRequestNotification(const nsAString& aRemoteBdAddr,
                                       const nsAString& aBdName,
-                                      uint32_t aCod) { }
+                                      uint32_t aCod);
   virtual void SspRequestNotification(const nsAString& aRemoteBdAddr,
                                       const nsAString& aBdName,
                                       uint32_t aCod,
                                       BluetoothSspVariant aPairingVariant,
-                                      uint32_t aPassKey) { }
+                                      uint32_t aPassKey);
 
   virtual void BondStateChangedNotification(BluetoothStatus aStatus,
                                             const nsAString& aRemoteBdAddr,
-                                            BluetoothBondState aState) { }
+                                            BluetoothBondState aState);
   virtual void AclStateChangedNotification(BluetoothStatus aStatus,
                                            const nsAString& aRemoteBdAddr,
-                                           bool aState) { }
+                                           bool aState);
 
   virtual void DutModeRecvNotification(uint16_t aOpcode,
-                                       const uint8_t* aBuf, uint8_t aLen) { }
+                                       const uint8_t* aBuf, uint8_t aLen);
   virtual void LeTestModeNotification(BluetoothStatus aStatus,
-                                      uint16_t aNumPackets) { }
+                                      uint16_t aNumPackets);
 
-  virtual void EnergyInfoNotification(const BluetoothActivityEnergyInfo& aInfo)
-  { }
+  virtual void EnergyInfoNotification(const BluetoothActivityEnergyInfo& aInfo);
 
-  virtual void BackendErrorNotification(bool aCrashed)
-  { }
+  virtual void BackendErrorNotification(bool aCrashed);
 
 protected:
-  BluetoothNotificationHandler()
-  { }
-
+  BluetoothNotificationHandler();
   virtual ~BluetoothNotificationHandler();
 };
 
 class BluetoothResultHandler
   : public mozilla::ipc::DaemonSocketResultHandler
 {
 public:
-  virtual void OnError(BluetoothStatus aStatus)
-  {
-    BT_LOGR("Received error code %d", aStatus);
-  }
+  virtual void OnError(BluetoothStatus aStatus);
+
+  virtual void Init();
+  virtual void Cleanup();
+  virtual void Enable();
+  virtual void Disable();
 
-  virtual void Init() { }
-  virtual void Cleanup() { }
-  virtual void Enable() { }
-  virtual void Disable() { }
+  virtual void GetAdapterProperties();
+  virtual void GetAdapterProperty();
+  virtual void SetAdapterProperty();
 
-  virtual void GetAdapterProperties() { }
-  virtual void GetAdapterProperty() { }
-  virtual void SetAdapterProperty() { }
+  virtual void GetRemoteDeviceProperties();
+  virtual void GetRemoteDeviceProperty();
+  virtual void SetRemoteDeviceProperty();
 
-  virtual void GetRemoteDeviceProperties() { }
-  virtual void GetRemoteDeviceProperty() { }
-  virtual void SetRemoteDeviceProperty() { }
+  virtual void GetRemoteServiceRecord();
+  virtual void GetRemoteServices();
 
-  virtual void GetRemoteServiceRecord() { }
-  virtual void GetRemoteServices() { }
+  virtual void StartDiscovery();
+  virtual void CancelDiscovery();
 
-  virtual void StartDiscovery() { }
-  virtual void CancelDiscovery() { }
+  virtual void CreateBond();
+  virtual void RemoveBond();
+  virtual void CancelBond();
 
-  virtual void CreateBond() { }
-  virtual void RemoveBond() { }
-  virtual void CancelBond() { }
+  virtual void GetConnectionState();
 
-  virtual void GetConnectionState() { }
-
-  virtual void PinReply() { }
-  virtual void SspReply() { }
+  virtual void PinReply();
+  virtual void SspReply();
 
-  virtual void DutModeConfigure() { }
-  virtual void DutModeSend() { }
+  virtual void DutModeConfigure();
+  virtual void DutModeSend();
 
-  virtual void LeTestMode() { }
+  virtual void LeTestMode();
 
-  virtual void ReadEnergyInfo() { }
+  virtual void ReadEnergyInfo();
 
 protected:
   virtual ~BluetoothResultHandler() { }
 };
 
 class BluetoothInterface
 {
 public: