Back out ed63ede44a82:db85ebf7b0dc (bug 864485) for debug build bustage

b2g/installer/package-manifest.in

@@ -164,6 +164,7 @@
 @BINPATH@/components/dom_base.xpt
 @BINPATH@/components/dom_system.xpt
 #ifdef MOZ_B2G_RIL
+@BINPATH@/components/dom_telephony.xpt
 @BINPATH@/components/dom_voicemail.xpt
 @BINPATH@/components/dom_wifi.xpt
 @BINPATH@/components/dom_system_gonk.xpt
@@ -202,7 +203,6 @@
 @BINPATH@/components/dom_mobilemessage.xpt
 @BINPATH@/components/dom_storage.xpt
 @BINPATH@/components/dom_stylesheets.xpt
-@BINPATH@/components/dom_telephony.xpt
 @BINPATH@/components/dom_threads.xpt
 @BINPATH@/components/dom_traversal.xpt
 @BINPATH@/components/dom_views.xpt
@@ -471,8 +471,6 @@
 @BINPATH@/components/NetworkStatsManager.manifest
 @BINPATH@/components/NetworkInterfaceListService.manifest
 @BINPATH@/components/NetworkInterfaceListService.js
-@BINPATH@/components/TelephonyProvider.manifest
-@BINPATH@/components/TelephonyProvider.js
 #endif
 #ifdef MOZ_ENABLE_DBUS
 @BINPATH@/components/@DLL_PREFIX@dbusservice@DLL_SUFFIX@

browser/installer/package-manifest.in

@@ -176,6 +176,7 @@
 @BINPATH@/components/dom_base.xpt
 @BINPATH@/components/dom_system.xpt
 #ifdef MOZ_B2G_RIL
+@BINPATH@/components/dom_telephony.xpt
 @BINPATH@/components/dom_voicemail.xpt
 @BINPATH@/components/dom_wifi.xpt
 @BINPATH@/components/dom_system_gonk.xpt
@@ -211,7 +212,6 @@
 @BINPATH@/components/dom_mobilemessage.xpt
 @BINPATH@/components/dom_storage.xpt
 @BINPATH@/components/dom_stylesheets.xpt
-@BINPATH@/components/dom_telephony.xpt
 @BINPATH@/components/dom_traversal.xpt
 #ifdef MOZ_WEBSPEECH
 @BINPATH@/components/dom_webspeechrecognition.xpt

dom/base/Navigator.cpp

@@ -54,7 +54,7 @@
 #include "MediaManager.h"
 #endif
 #ifdef MOZ_B2G_RIL
-#include "mozilla/dom/telephony/Telephony.h"
+#include "Telephony.h"
 #endif
 #ifdef MOZ_B2G_BT
 #include "BluetoothManager.h"

dom/bindings/Bindings.conf

@@ -168,12 +168,12 @@ DOMInterfaces = {
 
 'CallEvent': {
     'nativeType': 'mozilla::dom::telephony::CallEvent',
-    'headerFile': 'mozilla/dom/telephony/CallEvent.h',
+    'headerFile': 'CallEvent.h',
 },
 
 'CallsList': {
     'nativeType': 'mozilla::dom::telephony::CallsList',
-    'headerFile': 'mozilla/dom/telephony/CallsList.h',
+    'headerFile': 'CallsList.h',
 },
 
 'CameraControl': {
@@ -1162,17 +1162,17 @@ DOMInterfaces = {
 
 'Telephony' : {
     'nativeType': 'mozilla::dom::telephony::Telephony',
-    'headerFile': 'mozilla/dom/telephony/Telephony.h',
+    'headerFile': 'Telephony.h',
 },
 
 'TelephonyCall' : {
     'nativeType': 'mozilla::dom::telephony::TelephonyCall',
-    'headerFile': 'mozilla/dom/telephony/TelephonyCall.h',
+    'headerFile': 'TelephonyCall.h',
 },
 
 'TelephonyCallGroup' : {
     'nativeType': 'mozilla::dom::telephony::TelephonyCallGroup',
-    'headerFile': 'mozilla/dom/telephony/TelephonyCallGroup.h',
+    'headerFile': 'TelephonyCallGroup.h',
 },
 
 'Text': {

dom/bluetooth/BluetoothHfpManager.cpp

@@ -1479,7 +1479,7 @@ BluetoothHfpManager::OnConnectSuccess(BluetoothSocket* aSocket)
   }
 
   nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
+    do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
   NS_ENSURE_TRUE_VOID(provider);
   provider->EnumerateCalls(mListener->GetListener());
 

dom/bluetooth/BluetoothTelephonyListener.cpp

@@ -61,11 +61,13 @@ TelephonyListener::EnumerateCallState(uint32_t aCallIndex,
                                       bool aIsActive,
                                       bool aIsOutgoing,
                                       bool aIsEmergency,
-                                      bool aIsConference)
+                                      bool aIsConference,
+                                      bool* aResult)
 {
   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
   hfp->HandleCallStateChanged(aCallIndex, aCallState, EmptyString(), aNumber,
                               aIsOutgoing, false);
+  *aResult = true;
   return NS_OK;
 }
 
@@ -115,10 +117,10 @@ bool
 BluetoothTelephonyListener::StartListening()
 {
   nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
+    do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
   NS_ENSURE_TRUE(provider, false);
 
-  nsresult rv = provider->RegisterListener(mTelephonyListener);
+  nsresult rv = provider->RegisterTelephonyMsg(mTelephonyListener);
   NS_ENSURE_SUCCESS(rv, false);
 
   return true;
@@ -128,10 +130,10 @@ bool
 BluetoothTelephonyListener::StopListening()
 {
   nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
+    do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
   NS_ENSURE_TRUE(provider, false);
 
-  nsresult rv = provider->UnregisterListener(mTelephonyListener);
+  nsresult rv = provider->UnregisterTelephonyMsg(mTelephonyListener);
 
   return NS_FAILED(rv) ? false : true;
 }

dom/dom-config.mk

@@ -40,6 +40,7 @@ DOM_SRCDIRS = \
 ifdef MOZ_B2G_RIL
 DOM_SRCDIRS += \
   dom/system/gonk \
+  dom/telephony \
   dom/wifi \
   dom/icc/src \
   $(NULL)

dom/ipc/ContentChild.cpp

@@ -96,7 +96,6 @@
 
 #include "mozilla/dom/indexedDB/PIndexedDBChild.h"
 #include "mozilla/dom/mobilemessage/SmsChild.h"
-#include "mozilla/dom/telephony/TelephonyChild.h"
 #include "mozilla/dom/devicestorage/DeviceStorageRequestChild.h"
 #include "mozilla/dom/bluetooth/PBluetoothChild.h"
 #include "mozilla/dom/PFMRadioChild.h"
@@ -127,7 +126,6 @@ using namespace mozilla::dom::devicestorage;
 using namespace mozilla::dom::ipc;
 using namespace mozilla::dom::mobilemessage;
 using namespace mozilla::dom::indexedDB;
-using namespace mozilla::dom::telephony;
 using namespace mozilla::hal_sandbox;
 using namespace mozilla::ipc;
 using namespace mozilla::layers;
@@ -921,19 +919,6 @@ ContentChild::DeallocPSmsChild(PSmsChild* aSms)
     return true;
 }
 
-PTelephonyChild*
-ContentChild::AllocPTelephonyChild()
-{
-    MOZ_CRASH("No one should be allocating PTelephonyChild actors");
-}
-
-bool
-ContentChild::DeallocPTelephonyChild(PTelephonyChild* aActor)
-{
-    delete aActor;
-    return true;
-}
-
 PStorageChild*
 ContentChild::AllocPStorageChild()
 {

dom/ipc/ContentChild.h

@@ -152,9 +152,6 @@ public:
     virtual PSmsChild* AllocPSmsChild();
     virtual bool DeallocPSmsChild(PSmsChild*);
 
-    virtual PTelephonyChild* AllocPTelephonyChild();
-    virtual bool DeallocPTelephonyChild(PTelephonyChild*);
-
     virtual PStorageChild* AllocPStorageChild();
     virtual bool DeallocPStorageChild(PStorageChild* aActor);
 

dom/ipc/ContentParent.cpp

@@ -34,7 +34,6 @@
 #include "mozilla/dom/bluetooth/PBluetoothParent.h"
 #include "mozilla/dom/PFMRadioParent.h"
 #include "mozilla/dom/devicestorage/DeviceStorageRequestParent.h"
-#include "mozilla/dom/telephony/TelephonyParent.h"
 #include "SmsParent.h"
 #include "mozilla/Hal.h"
 #include "mozilla/hal_sandbox/PHalParent.h"
@@ -148,7 +147,6 @@ using namespace mozilla::dom::devicestorage;
 using namespace mozilla::dom::indexedDB;
 using namespace mozilla::dom::power;
 using namespace mozilla::dom::mobilemessage;
-using namespace mozilla::dom::telephony;
 using namespace mozilla::hal;
 using namespace mozilla::idl;
 using namespace mozilla::ipc;
@@ -2248,25 +2246,6 @@ ContentParent::DeallocPSmsParent(PSmsParent* aSms)
     return true;
 }
 
-PTelephonyParent*
-ContentParent::AllocPTelephonyParent()
-{
-    if (!AssertAppProcessPermission(this, "telephony")) {
-        return nullptr;
-    }
-
-    TelephonyParent* actor = new TelephonyParent();
-    NS_ADDREF(actor);
-    return actor;
-}
-
-bool
-ContentParent::DeallocPTelephonyParent(PTelephonyParent* aActor)
-{
-    static_cast<TelephonyParent*>(aActor)->Release();
-    return true;
-}
-
 PStorageParent*
 ContentParent::AllocPStorageParent()
 {

dom/ipc/ContentParent.h

@@ -321,9 +321,6 @@ private:
     virtual PSmsParent* AllocPSmsParent();
     virtual bool DeallocPSmsParent(PSmsParent*);
 
-    virtual PTelephonyParent* AllocPTelephonyParent();
-    virtual bool DeallocPTelephonyParent(PTelephonyParent*);
-
     virtual PStorageParent* AllocPStorageParent();
     virtual bool DeallocPStorageParent(PStorageParent* aActor);
 

dom/ipc/PContent.ipdl

@@ -20,7 +20,6 @@ include protocol PNecko;
 include protocol PSms;
 include protocol PSpeechSynthesis;
 include protocol PStorage;
-include protocol PTelephony;
 include protocol PTestShell;
 include protocol PJavaScript;
 include DOMTypes;
@@ -198,7 +197,6 @@ rpc protocol PContent
     manages PSms;
     manages PSpeechSynthesis;
     manages PStorage;
-    manages PTelephony;
     manages PTestShell;
     manages PJavaScript;
 
@@ -355,8 +353,6 @@ parent:
 
     PStorage();
 
-    PTelephony();
-
     PBluetooth();
 
     PFMRadio();

dom/mobilemessage/src/Makefile.in

@@ -33,6 +33,7 @@ LOCAL_INCLUDES += $(VPATH:%=-I%)
 
 ifdef MOZ_B2G_RIL
 LOCAL_INCLUDES += \
+  -I$(topsrcdir)/dom/telephony \
   -I$(topsrcdir)/dom/system/gonk \
   $(NULL)
 endif

dom/moz.build

@@ -72,8 +72,7 @@ PARALLEL_DIRS += [
     'camera',
     'audiochannel',
     'promise',
-    'wappush',
+    'wappush'
-    'telephony',
 ]
 
 if CONFIG['OS_ARCH'] == 'WINNT':
@@ -81,6 +80,7 @@ if CONFIG['OS_ARCH'] == 'WINNT':
 
 if CONFIG['MOZ_B2G_RIL']:
     PARALLEL_DIRS += [
+        'telephony',
         'wifi',
         'icc',
         'cellbroadcast',

dom/system/gonk/Makefile.in

@@ -26,6 +26,7 @@ include $(topsrcdir)/dom/dom-config.mk
 LOCAL_INCLUDES = \
   -I$(topsrcdir)/dom/base \
   -I$(topsrcdir)/dom/src/geolocation \
+  -I$(topsrcdir)/dom/telephony \
   -I$(topsrcdir)/dom/wifi \
   -I$(topsrcdir)/dom/bluetooth \
   -I$(topsrcdir)/content/events/src \

dom/system/gonk/RILContentHelper.js

@@ -69,13 +69,17 @@ const RIL_IPC_MSG_NAMES = [
   "RIL:IccInfoChanged",
   "RIL:VoiceInfoChanged",
   "RIL:DataInfoChanged",
+  "RIL:EnumerateCalls",
   "RIL:GetAvailableNetworks",
   "RIL:NetworkSelectionModeChanged",
   "RIL:SelectNetwork",
   "RIL:SelectNetworkAuto",
+  "RIL:CallStateChanged",
   "RIL:EmergencyCbModeChanged",
   "RIL:VoicemailNotification",
   "RIL:VoicemailInfoChanged",
+  "RIL:CallError",
+  "RIL:SuppSvcNotification",
   "RIL:CardLockResult",
   "RIL:CardLockRetryCount",
   "RIL:USSDReceived",
@@ -102,9 +106,11 @@ const RIL_IPC_MSG_NAMES = [
   "RIL:UpdateIccContact",
   "RIL:SetRoamingPreference",
   "RIL:GetRoamingPreference",
+  "RIL:CdmaCallWaiting",
   "RIL:ExitEmergencyCbMode",
   "RIL:SetVoicePrivacyMode",
   "RIL:GetVoicePrivacyMode",
+  "RIL:ConferenceCallStateChanged",
   "RIL:OtaStatusChanged"
 ];
 
@@ -112,6 +118,10 @@ XPCOMUtils.defineLazyServiceGetter(this, "cpmm",
                                    "@mozilla.org/childprocessmessagemanager;1",
                                    "nsISyncMessageSender");
 
+XPCOMUtils.defineLazyServiceGetter(this, "gUUIDGenerator",
+                                   "@mozilla.org/uuid-generator;1",
+                                   "nsIUUIDGenerator");
+
 function MobileIccCardLockResult(options) {
   this.lockType = options.lockType;
   this.enabled = options.enabled;
@@ -411,6 +421,7 @@ RILContentHelper.prototype = {
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIMobileConnectionProvider,
                                          Ci.nsICellBroadcastProvider,
                                          Ci.nsIVoicemailProvider,
+                                         Ci.nsITelephonyProvider,
                                          Ci.nsIIccProvider,
                                          Ci.nsIObserver,
                                          Ci.nsISupportsWeakReference]),
@@ -420,6 +431,7 @@ RILContentHelper.prototype = {
                                     interfaces: [Ci.nsIMobileConnectionProvider,
                                                  Ci.nsICellBroadcastProvider,
                                                  Ci.nsIVoicemailProvider,
+                                                 Ci.nsITelephonyProvider,
                                                  Ci.nsIIccProvider]}),
 
   // An utility function to copy objects.
@@ -1212,9 +1224,11 @@ RILContentHelper.prototype = {
   },
 
   _mobileConnectionListeners: null,
+  _telephonyListeners: null,
   _cellBroadcastListeners: null,
   _voicemailListeners: null,
   _iccListeners: null,
+  _enumerateTelephonyCallbacks: null,
 
   voicemailStatus: null,
 
@@ -1276,6 +1290,24 @@ RILContentHelper.prototype = {
     this.unregisterListener("_mobileConnectionListeners", listener);
   },
 
+  registerTelephonyMsg: function registerTelephonyMsg(listener) {
+    debug("Registering for telephony-related messages");
+    this.registerListener("_telephonyListeners", listener);
+    cpmm.sendAsyncMessage("RIL:RegisterTelephonyMsg");
+  },
+
+  unregisterTelephonyMsg: function unregisteTelephonyMsg(listener) {
+    this.unregisterListener("_telephonyListeners", listener);
+
+    // We also need to make sure the listener is removed from
+    // _enumerateTelephonyCallbacks.
+    let index = this._enumerateTelephonyCallbacks.indexOf(listener);
+    if (index != -1) {
+      this._enumerateTelephonyCallbacks.splice(index, 1);
+      if (DEBUG) debug("Unregistered enumerateTelephony callback: " + listener);
+    }
+  },
+
   registerVoicemailMsg: function registerVoicemailMsg(listener) {
     debug("Registering for voicemail-related messages");
     this.registerListener("_voicemailListeners", listener);
@@ -1306,6 +1338,135 @@ RILContentHelper.prototype = {
     this.unregisterListener("_iccListeners", listener);
   },
 
+  enumerateCalls: function enumerateCalls(callback) {
+    debug("Requesting enumeration of calls for callback: " + callback);
+    // We need 'requestId' to meet the 'RILContentHelper <--> RadioInterfaceLayer'
+    // protocol.
+    let requestId = this._getRandomId();
+    cpmm.sendAsyncMessage("RIL:EnumerateCalls", {
+      clientId: 0,
+      data: {
+        requestId: requestId
+      }
+    });
+    if (!this._enumerateTelephonyCallbacks) {
+      this._enumerateTelephonyCallbacks = [];
+    }
+    this._enumerateTelephonyCallbacks.push(callback);
+  },
+
+  startTone: function startTone(dtmfChar) {
+    debug("Sending Tone for " + dtmfChar);
+    cpmm.sendAsyncMessage("RIL:StartTone", {
+      clientId: 0,
+      data: dtmfChar
+    });
+  },
+
+  stopTone: function stopTone() {
+    debug("Stopping Tone");
+    cpmm.sendAsyncMessage("RIL:StopTone", {clientId: 0});
+  },
+
+  dial: function dial(number) {
+    debug("Dialing " + number);
+    cpmm.sendAsyncMessage("RIL:Dial", {
+      clientId: 0,
+      data: number
+    });
+  },
+
+  dialEmergency: function dialEmergency(number) {
+    debug("Dialing emergency " + number);
+    cpmm.sendAsyncMessage("RIL:DialEmergency", {
+      clientId: 0,
+      data: number
+    });
+  },
+
+  hangUp: function hangUp(callIndex) {
+    debug("Hanging up call no. " + callIndex);
+    cpmm.sendAsyncMessage("RIL:HangUp", {
+      clientId: 0,
+      data: callIndex
+    });
+  },
+
+  answerCall: function answerCall(callIndex) {
+    cpmm.sendAsyncMessage("RIL:AnswerCall", {
+      clientId: 0,
+      data: callIndex
+    });
+  },
+
+  rejectCall: function rejectCall(callIndex) {
+    cpmm.sendAsyncMessage("RIL:RejectCall", {
+      clientId: 0,
+      data: callIndex
+    });
+  },
+
+  holdCall: function holdCall(callIndex) {
+    cpmm.sendAsyncMessage("RIL:HoldCall", {
+      clientId: 0,
+      data: callIndex
+    });
+  },
+
+  resumeCall: function resumeCall(callIndex) {
+    cpmm.sendAsyncMessage("RIL:ResumeCall", {
+      clientId: 0,
+      data: callIndex
+    });
+  },
+
+  conferenceCall: function conferenceCall() {
+    cpmm.sendAsyncMessage("RIL:ConferenceCall", {
+      clientId: 0
+    });
+  },
+
+  separateCall: function separateCall(callIndex) {
+    cpmm.sendAsyncMessage("RIL:SeparateCall", {
+      clientId: 0,
+      data: callIndex
+    });
+  },
+
+  holdConference: function holdConference() {
+    cpmm.sendAsyncMessage("RIL:HoldConference", {
+      clientId: 0
+    });
+  },
+
+  resumeConference: function resumeConference() {
+    cpmm.sendAsyncMessage("RIL:ResumeConference", {
+      clientId: 0
+    });
+  },
+
+  get microphoneMuted() {
+    return cpmm.sendSyncMessage("RIL:GetMicrophoneMuted", {clientId: 0})[0];
+  },
+
+  set microphoneMuted(value) {
+    cpmm.sendAsyncMessage("RIL:SetMicrophoneMuted", {
+      clientId: 0,
+      data: value
+    });
+  },
+
+  get speakerEnabled() {
+    return cpmm.sendSyncMessage("RIL:GetSpeakerEnabled", {clientId: 0})[0];
+  },
+
+  set speakerEnabled(value) {
+    cpmm.sendAsyncMessage("RIL:SetSpeakerEnabled", {
+      clientId: 0,
+      data: value
+    });
+  },
+
   // nsIObserver
 
   observe: function observe(subject, topic, data) {
@@ -1402,6 +1563,9 @@ RILContentHelper.prototype = {
                            "notifyOtaStatusChanged",
                            [msg.json.data]);
         break;
+      case "RIL:EnumerateCalls":
+        this.handleEnumerateCalls(msg.json.calls);
+        break;
       case "RIL:GetAvailableNetworks":
         this.handleGetAvailableNetworks(msg.json);
         break;
@@ -1416,6 +1580,35 @@ RILContentHelper.prototype = {
         this.handleSelectNetwork(msg.json,
                                  RIL.GECKO_NETWORK_SELECTION_AUTOMATIC);
         break;
+      case "RIL:CallStateChanged": {
+        let data = msg.json.data;
+        this._deliverEvent("_telephonyListeners",
+                           "callStateChanged",
+                           [data.callIndex, data.state,
+                            data.number, data.isActive,
+                            data.isOutgoing, data.isEmergency,
+                            data.isConference]);
+        break;
+      }
+      case "RIL:ConferenceCallStateChanged": {
+        let data = msg.json.data;
+        this._deliverEvent("_telephonyListeners",
+                           "conferenceCallStateChanged",
+                           [data]);
+        break;
+      }
+      case "RIL:CallError": {
+        let data = msg.json.data;
+        this._deliverEvent("_telephonyListeners",
+                           "notifyError",
+                           [data.callIndex, data.errorMsg]);
+        break;
+      }
+      case "RIL:SuppSvcNotification":
+        this._deliverEvent("_telephonyListeners",
+                           "supplementaryServiceNotification",
+                           [msg.json.callIndex, msg.json.notification]);
+        break;
       case "RIL:VoicemailNotification":
         this.handleVoicemailNotification(msg.json.data);
         break;
@@ -1536,6 +1729,11 @@ RILContentHelper.prototype = {
         this.handleSimpleRequest(msg.json.requestId, msg.json.errorMsg,
                                  msg.json.mode);
         break;
+      case "RIL:CdmaCallWaiting":
+        this._deliverEvent("_telephonyListeners",
+                           "notifyCdmaCallWaiting",
+                           [msg.json.data]);
+        break;
       case "RIL:ExitEmergencyCbMode":
         this.handleExitEmergencyCbMode(msg.json);
         break;
@@ -1555,6 +1753,35 @@ RILContentHelper.prototype = {
     }
   },
 
+  handleEnumerateCalls: function handleEnumerateCalls(calls) {
+    debug("handleEnumerateCalls: " + JSON.stringify(calls));
+    let callback = this._enumerateTelephonyCallbacks.shift();
+    if (!calls.length) {
+      callback.enumerateCallStateComplete();
+      return;
+    }
+
+    for (let i in calls) {
+      let call = calls[i];
+      let keepGoing;
+      try {
+        keepGoing =
+          callback.enumerateCallState(call.callIndex, call.state, call.number,
+                                      call.isActive, call.isOutgoing,
+                                      call.isEmergency, call.isConference);
+      } catch (e) {
+        debug("callback handler for 'enumerateCallState' threw an " +
+              " exception: " + e);
+        keepGoing = true;
+      }
+      if (!keepGoing) {
+        break;
+      }
+    }
+
+    callback.enumerateCallStateComplete();
+  },
+
   handleSimpleRequest: function handleSimpleRequest(requestId, errorMsg, result) {
     if (errorMsg) {
       this.fireRequestError(requestId, errorMsg);
@@ -1767,6 +1994,10 @@ RILContentHelper.prototype = {
     }
   },
 
+  _getRandomId: function _getRandomId() {
+    return gUUIDGenerator.generateUUID().toString();
+  },
+
   _deliverEvent: function _deliverEvent(listenerType, name, args) {
     let thisListeners = this[listenerType];
     if (!thisListeners) {

dom/system/gonk/RadioInterfaceLayer.js

@@ -46,6 +46,9 @@ const RADIOINTERFACE_CID =
 const RILNETWORKINTERFACE_CID =
   Components.ID("{3bdd52a9-3965-4130-b569-0ac5afed045e}");
 
+const nsIAudioManager = Ci.nsIAudioManager;
+const nsITelephonyProvider = Ci.nsITelephonyProvider;
+
 const kNetworkInterfaceStateChangedTopic = "network-interface-state-changed";
 const kSmsReceivedObserverTopic          = "sms-received";
 const kSilentSmsReceivedObserverTopic    = "silent-sms-received";
@@ -70,7 +73,30 @@ const DOM_MOBILE_MESSAGE_DELIVERY_SENDING  = "sending";
 const DOM_MOBILE_MESSAGE_DELIVERY_SENT     = "sent";
 const DOM_MOBILE_MESSAGE_DELIVERY_ERROR    = "error";
 
-const RADIO_POWER_OFF_TIMEOUT = 30000;
+const CALL_WAKELOCK_TIMEOUT              = 5000;
+const RADIO_POWER_OFF_TIMEOUT            = 30000;
+
+const RIL_IPC_TELEPHONY_MSG_NAMES = [
+  "RIL:EnumerateCalls",
+  "RIL:GetMicrophoneMuted",
+  "RIL:SetMicrophoneMuted",
+  "RIL:GetSpeakerEnabled",
+  "RIL:SetSpeakerEnabled",
+  "RIL:StartTone",
+  "RIL:StopTone",
+  "RIL:Dial",
+  "RIL:DialEmergency",
+  "RIL:HangUp",
+  "RIL:AnswerCall",
+  "RIL:RejectCall",
+  "RIL:HoldCall",
+  "RIL:ResumeCall",
+  "RIL:RegisterTelephonyMsg",
+  "RIL:ConferenceCall",
+  "RIL:SeparateCall",
+  "RIL:HoldConference",
+  "RIL:ResumeConference"
+];
 
 const RIL_IPC_MOBILECONNECTION_MSG_NAMES = [
   "RIL:GetRilContext",
@@ -162,10 +188,6 @@ XPCOMUtils.defineLazyServiceGetter(this, "gSystemWorkerManager",
                                    "@mozilla.org/telephony/system-worker-manager;1",
                                    "nsISystemWorkerManager");
 
-XPCOMUtils.defineLazyServiceGetter(this, "gTelephonyProvider",
-                                   "@mozilla.org/telephony/telephonyprovider;1",
-                                   "nsIGonkTelephonyProvider");
-
 XPCOMUtils.defineLazyGetter(this, "WAP", function () {
   let wap = {};
   Cu.import("resource://gre/modules/WapPushManager.js", wap);
@@ -178,6 +200,64 @@ XPCOMUtils.defineLazyGetter(this, "PhoneNumberUtils", function () {
   return ns.PhoneNumberUtils;
 });
 
+function convertRILCallState(state) {
+  switch (state) {
+    case RIL.CALL_STATE_ACTIVE:
+      return nsITelephonyProvider.CALL_STATE_CONNECTED;
+    case RIL.CALL_STATE_HOLDING:
+      return nsITelephonyProvider.CALL_STATE_HELD;
+    case RIL.CALL_STATE_DIALING:
+      return nsITelephonyProvider.CALL_STATE_DIALING;
+    case RIL.CALL_STATE_ALERTING:
+      return nsITelephonyProvider.CALL_STATE_ALERTING;
+    case RIL.CALL_STATE_INCOMING:
+    case RIL.CALL_STATE_WAITING:
+      return nsITelephonyProvider.CALL_STATE_INCOMING;
+    default:
+      throw new Error("Unknown rilCallState: " + state);
+  }
+}
+
+function convertRILSuppSvcNotification(notification) {
+  switch (notification) {
+    case RIL.GECKO_SUPP_SVC_NOTIFICATION_REMOTE_HELD:
+      return nsITelephonyProvider.NOTIFICATION_REMOTE_HELD;
+    case RIL.GECKO_SUPP_SVC_NOTIFICATION_REMOTE_RESUMED:
+      return nsITelephonyProvider.NOTIFICATION_REMOTE_RESUMED;
+    default:
+      throw new Error("Unknown rilSuppSvcNotification: " + notification);
+  }
+}
+
+/**
+ * Fake nsIAudioManager implementation so that we can run the telephony
+ * code in a non-Gonk build.
+ */
+let FakeAudioManager = {
+  microphoneMuted: false,
+  masterVolume: 1.0,
+  masterMuted: false,
+  phoneState: nsIAudioManager.PHONE_STATE_CURRENT,
+  _forceForUse: {},
+  setForceForUse: function setForceForUse(usage, force) {
+    this._forceForUse[usage] = force;
+  },
+  getForceForUse: function setForceForUse(usage) {
+    return this._forceForUse[usage] || nsIAudioManager.FORCE_NONE;
+  }
+};
+
+XPCOMUtils.defineLazyGetter(this, "gAudioManager", function getAudioManager() {
+  try {
+    return Cc["@mozilla.org/telephony/audiomanager;1"]
+             .getService(nsIAudioManager);
+  } catch (ex) {
+    //TODO on the phone this should not fall back as silently.
+    if (DEBUG) debug("Using fake audio manager.");
+    return FakeAudioManager;
+  }
+});
+
 XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
   return {
     QueryInterface: XPCOMUtils.generateQI([Ci.nsIMessageListener,
@@ -210,6 +290,9 @@ XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
 
     _registerMessageListeners: function _registerMessageListeners() {
       ppmm.addMessageListener("child-process-shutdown", this);
+      for (let msgname of RIL_IPC_TELEPHONY_MSG_NAMES) {
+        ppmm.addMessageListener(msgname, this);
+      }
       for (let msgname of RIL_IPC_MOBILECONNECTION_MSG_NAMES) {
         ppmm.addMessageListener(msgname, this);
       }
@@ -226,6 +309,9 @@ XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
 
     _unregisterMessageListeners: function _unregisterMessageListeners() {
       ppmm.removeMessageListener("child-process-shutdown", this);
+      for (let msgname of RIL_IPC_TELEPHONY_MSG_NAMES) {
+        ppmm.removeMessageListener(msgname, this);
+      }
       for (let msgname of RIL_IPC_MOBILECONNECTION_MSG_NAMES) {
         ppmm.removeMessageListener(msgname, this);
       }
@@ -344,7 +430,15 @@ XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
         return;
       }
 
-      if (RIL_IPC_MOBILECONNECTION_MSG_NAMES.indexOf(msg.name) != -1) {
+      if (RIL_IPC_TELEPHONY_MSG_NAMES.indexOf(msg.name) != -1) {
+        if (!msg.target.assertPermission("telephony")) {
+          if (DEBUG) {
+            debug("Telephony message " + msg.name +
+                  " from a content process with no 'telephony' privileges.");
+          }
+          return null;
+        }
+      } else if (RIL_IPC_MOBILECONNECTION_MSG_NAMES.indexOf(msg.name) != -1) {
         if (!msg.target.assertPermission("mobileconnection")) {
           if (DEBUG) {
             debug("MobileConnection message " + msg.name +
@@ -382,6 +476,9 @@ XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
       }
 
       switch (msg.name) {
+        case "RIL:RegisterTelephonyMsg":
+          this._registerMessageTarget("telephony", msg.target);
+          return;
         case "RIL:RegisterMobileConnectionMsg":
           this._registerMessageTarget("mobileconnection", msg.target);
           return;
@@ -422,6 +519,13 @@ XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
       }
     },
 
+    sendTelephonyMessage: function sendTelephonyMessage(message, clientId, data) {
+      this._sendTargetMessage("telephony", message, {
+        clientId: clientId,
+        data: data
+      });
+    },
+
     sendMobileConnectionMessage: function sendMobileConnectionMessage(message, clientId, data) {
       this._sendTargetMessage("mobileconnection", message, {
         clientId: clientId,
@@ -790,6 +894,61 @@ RadioInterface.prototype = {
       case "RIL:GetRilContext":
         // This message is sync.
         return this.rilContext;
+      case "RIL:EnumerateCalls":
+        this.enumerateCalls(msg.target, msg.json.data);
+        break;
+      case "RIL:GetMicrophoneMuted":
+        // This message is sync.
+        return this.microphoneMuted;
+      case "RIL:SetMicrophoneMuted":
+        this.microphoneMuted = msg.json.data;
+        break;
+      case "RIL:GetSpeakerEnabled":
+        // This message is sync.
+        return this.speakerEnabled;
+      case "RIL:SetSpeakerEnabled":
+        this.speakerEnabled = msg.json.data;
+        break;
+      case "RIL:StartTone":
+        this.workerMessenger.send("startTone", { dtmfChar: msg.json.data });
+        break;
+      case "RIL:StopTone":
+        this.workerMessenger.send("stopTone");
+        break;
+      case "RIL:Dial":
+        this.dial(msg.json.data);
+        break;
+      case "RIL:DialEmergency":
+        this.dialEmergency(msg.json.data);
+        break;
+      case "RIL:HangUp":
+        this.workerMessenger.send("hangUp", { callIndex: msg.json.data });
+        break;
+      case "RIL:AnswerCall":
+        this.workerMessenger.send("answerCall", { callIndex: msg.json.data });
+        break;
+      case "RIL:RejectCall":
+        this.workerMessenger.send("rejectCall", { callIndex: msg.json.data });
+        break;
+      case "RIL:HoldCall":
+        this.workerMessenger.send("holdCall", { callIndex: msg.json.data });
+        break;
+      case "RIL:ResumeCall":
+        this.workerMessenger.send("resumeCall", { callIndex: msg.json.data });
+        break;
+      case "RIL:ConferenceCall":
+        this.workerMessenger.send("conferenceCall");
+        break;
+      case "RIL:SeparateCall":
+        this.workerMessenger.send("separateCall",
+                                  { callIndex: msg.json.data });
+        break;
+      case "RIL:HoldConference":
+        this.workerMessenger.send("holdConference");
+        break;
+      case "RIL:ResumeConference":
+        this.workerMessenger.send("resumeConference");
+        break;
       case "RIL:GetAvailableNetworks":
         this.workerMessenger.sendWithIPCMessage(msg, "getAvailableNetworks");
         break;
@@ -899,26 +1058,28 @@ RadioInterface.prototype = {
   handleUnsolicitedWorkerMessage: function handleUnsolicitedWorkerMessage(message) {
     switch (message.rilMessageType) {
       case "callRing":
-        gTelephonyProvider.notifyCallRing();
+        this.handleCallRing();
         break;
       case "callStateChange":
-        gTelephonyProvider.notifyCallStateChanged(message.call);
+        // This one will handle its own notifications.
+        this.handleCallStateChange(message.call);
         break;
       case "callDisconnected":
-        gTelephonyProvider.notifyCallDisconnected(message.call);
+        // This one will handle its own notifications.
+        this.handleCallDisconnected(message.call);
         break;
       case "conferenceCallStateChanged":
-        gTelephonyProvider.notifyConferenceCallStateChanged(message.state);
+        this.handleConferenceCallStateChanged(message.state);
         break;
       case "cdmaCallWaiting":
-        gTelephonyProvider.notifyCdmaCallWaiting(message.number);
+        gMessageManager.sendTelephonyMessage("RIL:CdmaCallWaiting",
+                                             this.clientId, message.number);
         break;
       case "callError":
-        gTelephonyProvider.notifyCallError(message.callIndex, message.errorMsg);
+        this.handleCallError(message);
         break;
       case "suppSvcNotification":
-        gTelephonyProvider.notifySupplementaryService(message.callIndex,
+        this.handleSuppSvcNotification(message);
-                                                      message.notification);
         break;
       case "emergencyCbModeChange":
         this.handleEmergencyCbModeChange(message);
@@ -1566,6 +1727,165 @@ RadioInterface.prototype = {
     this.setupDataCallByType("default");
   },
 
+  /**
+   * Track the active call and update the audio system as its state changes.
+   */
+  _activeCall: null,
+  updateCallAudioState: function updateCallAudioState(options) {
+    if (options.conferenceState === nsITelephonyProvider.CALL_STATE_CONNECTED) {
+      gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_IN_CALL;
+      if (this.speakerEnabled) {
+        gAudioManager.setForceForUse(nsIAudioManager.USE_COMMUNICATION,
+                                     nsIAudioManager.FORCE_SPEAKER);
+      }
+      return;
+    }
+    if (options.conferenceState === nsITelephonyProvider.CALL_STATE_UNKNOWN ||
+        options.conferenceState === nsITelephonyProvider.CALL_STATE_HELD) {
+      if (!this._activeCall) {
+        gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
+      }
+      return;
+    }
+
+    if (!options.call) {
+      return;
+    }
+
+    if (options.call.isConference) {
+      if (this._activeCall && this._activeCall.callIndex == options.call.callIndex) {
+        this._activeCall = null;
+      }
+      return;
+    }
+
+    let call = options.call;
+    switch (call.state) {
+      case nsITelephonyProvider.CALL_STATE_DIALING: // Fall through...
+      case nsITelephonyProvider.CALL_STATE_ALERTING:
+      case nsITelephonyProvider.CALL_STATE_CONNECTED:
+        call.isActive = true;
+        this._activeCall = call;
+        gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_IN_CALL;
+        if (this.speakerEnabled) {
+          gAudioManager.setForceForUse(nsIAudioManager.USE_COMMUNICATION,
+                                       nsIAudioManager.FORCE_SPEAKER);
+        }
+        if (DEBUG) {
+          this.debug("Active call, put audio system into PHONE_STATE_IN_CALL: "
+                     + gAudioManager.phoneState);
+        }
+        break;
+      case nsITelephonyProvider.CALL_STATE_INCOMING:
+        call.isActive = false;
+        if (!this._activeCall) {
+          // We can change the phone state into RINGTONE only when there's
+          // no active call.
+          gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_RINGTONE;
+          if (DEBUG) {
+            this.debug("Incoming call, put audio system into " +
+                       "PHONE_STATE_RINGTONE: " + gAudioManager.phoneState);
+          }
+        }
+        break;
+      case nsITelephonyProvider.CALL_STATE_HELD: // Fall through...
+      case nsITelephonyProvider.CALL_STATE_DISCONNECTED:
+        call.isActive = false;
+        if (this._activeCall &&
+            this._activeCall.callIndex == call.callIndex) {
+          // Previously active call is not active now.
+          this._activeCall = null;
+        }
+
+        if (!this._activeCall) {
+          // No active call. Disable the audio.
+          gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
+          if (DEBUG) {
+            this.debug("No active call, put audio system into " +
+                       "PHONE_STATE_NORMAL: " + gAudioManager.phoneState);
+          }
+        }
+        break;
+    }
+  },
+
+  _callRingWakeLock: null,
+  _callRingWakeLockTimer: null,
+  _cancelCallRingWakeLockTimer: function _cancelCallRingWakeLockTimer() {
+    if (this._callRingWakeLockTimer) {
+      this._callRingWakeLockTimer.cancel();
+    }
+    if (this._callRingWakeLock) {
+      this._callRingWakeLock.unlock();
+      this._callRingWakeLock = null;
+    }
+  },
+
+  /**
+   * Handle an incoming call.
+   *
+   * Not much is known about this call at this point, but it's enough
+   * to start bringing up the Phone app already.
+   */
+  handleCallRing: function handleCallRing() {
+    if (!this._callRingWakeLock) {
+      this._callRingWakeLock = gPowerManagerService.newWakeLock("cpu");
+    }
+    if (!this._callRingWakeLockTimer) {
+      this._callRingWakeLockTimer =
+        Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    }
+    this._callRingWakeLockTimer
+        .initWithCallback(this._cancelCallRingWakeLockTimer.bind(this),
+                          CALL_WAKELOCK_TIMEOUT, Ci.nsITimer.TYPE_ONE_SHOT);
+
+    gSystemMessenger.broadcastMessage("telephony-new-call", {});
+  },
+
+  /**
+   * Handle call state changes by updating our current state and the audio
+   * system.
+   */
+  handleCallStateChange: function handleCallStateChange(call) {
+    if (DEBUG) this.debug("handleCallStateChange: " + JSON.stringify(call));
+    call.state = convertRILCallState(call.state);
+
+    if (call.state == nsITelephonyProvider.CALL_STATE_DIALING) {
+      gSystemMessenger.broadcastMessage("telephony-new-call", {});
+    }
+    this.updateCallAudioState({call: call});
+    gMessageManager.sendTelephonyMessage("RIL:CallStateChanged",
+                                         this.clientId, call);
+  },
+
+  /**
+   * Handle call disconnects by updating our current state and the audio system.
+   */
+  handleCallDisconnected: function handleCallDisconnected(call) {
+    if (DEBUG) this.debug("handleCallDisconnected: " + JSON.stringify(call));
+    call.state = nsITelephonyProvider.CALL_STATE_DISCONNECTED;
+    let duration = ("started" in call && typeof call.started == "number") ?
+      new Date().getTime() - call.started : 0;
+    let data = {
+      number: call.number,
+      duration: duration,
+      direction: call.isOutgoing ? "outgoing" : "incoming"
+    };
+    gSystemMessenger.broadcastMessage("telephony-call-ended", data);
+    this.updateCallAudioState({call: call});
+    gMessageManager.sendTelephonyMessage("RIL:CallStateChanged",
+                                         this.clientId, call);
+  },
+
+  handleConferenceCallStateChanged: function handleConferenceCallStateChanged(state) {
+    debug("handleConferenceCallStateChanged: " + state);
+    state = state != null ? convertRILCallState(state) :
+                            nsITelephonyProvider.CALL_STATE_UNKNOWN;
+    this.updateCallAudioState({conferenceState: state});
+    gMessageManager.sendTelephonyMessage("RIL:ConferenceCallStateChanged",
+                                         this.clientId, state);
+  },
+
   /**
    * Update network selection mode
    */
@@ -1585,6 +1905,23 @@ RadioInterface.prototype = {
                                                 this.clientId, message);
   },
 
+  /**
+   * Handle call error.
+   */
+  handleCallError: function handleCallError(message) {
+    gMessageManager.sendTelephonyMessage("RIL:CallError",
+                                         this.clientId, message);
+  },
+
+  /**
+   * Handle supplementary service notification.
+   */
+  handleSuppSvcNotification: function handleSuppSvcNotification(message) {
+    message.notification = convertRILSuppSvcNotification(message.notification);
+    gMessageManager.sendTelephonyMessage("RIL:SuppSvcNotification",
+                                         this.clientId, message);
+  },
+
   /**
    * Handle WDP port push PDU. Constructor WDP bearer information and deliver
    * to WapPushManager.
@@ -1979,6 +2316,8 @@ RadioInterface.prototype = {
         }
         break;
       case "xpcom-shutdown":
+        // Cancel the timer for the call-ring wake lock.
+        this._cancelCallRingWakeLockTimer();
         // Shutdown all RIL network interfaces
         for each (let apnSetting in this.apnSettings.byAPN) {
           if (apnSetting.iface) {
@@ -2128,6 +2467,56 @@ RadioInterface.prototype = {
 
   // Handle phone functions of nsIRILContentHelper
 
+  enumerateCalls: function enumerateCalls(target, message) {
+    if (DEBUG) this.debug("Requesting enumeration of calls for callback");
+    this.workerMessenger.send("enumerateCalls", message, (function(response) {
+      for (let call of response.calls) {
+        call.state = convertRILCallState(call.state);
+        call.isActive = this._activeCall ?
+          call.callIndex == this._activeCall.callIndex : false;
+      }
+      target.sendAsyncMessage("RIL:EnumerateCalls", response);
+      return false;
+    }).bind(this));
+  },
+
+  _validateNumber: function _validateNumber(number) {
+    // note: isPlainPhoneNumber also accepts USSD and SS numbers
+    if (PhoneNumberUtils.isPlainPhoneNumber(number)) {
+      return true;
+    }
+
+    this.handleCallError({
+      callIndex: -1,
+      errorMsg: RIL.RIL_CALL_FAILCAUSE_TO_GECKO_CALL_ERROR[RIL.CALL_FAIL_UNOBTAINABLE_NUMBER]
+    });
+    if (DEBUG) {
+      this.debug("Number '" + number + "' doesn't seem to be a viable number." +
+                 " Drop.");
+    }
+
+    return false;
+  },
+
+  dial: function dial(number) {
+    if (DEBUG) this.debug("Dialing " + number);
+    number = PhoneNumberUtils.normalize(number);
+    if (this._validateNumber(number)) {
+      this.workerMessenger.send("dial", { number: number,
+                                          isDialEmergency: false });
+    }
+  },
+
+  dialEmergency: function dialEmergency(number) {
+    if (DEBUG) this.debug("Dialing emergency " + number);
+    // we don't try to be too clever here, as the phone is probably in the
+    // locked state. Let's just check if it's a number without normalizing
+    if (this._validateNumber(number)) {
+      this.workerMessenger.send("dial", { number: number,
+                                          isDialEmergency: true });
+    }
+  },
+
   _sendCfStateChanged: function _sendCfStateChanged(message) {
     gMessageManager.sendMobileConnectionMessage("RIL:CfStateChanged",
                                                 this.clientId, message);
@@ -2182,6 +2571,37 @@ RadioInterface.prototype = {
     }).bind(this));
   },
 
+  get microphoneMuted() {
+    return gAudioManager.microphoneMuted;
+  },
+  set microphoneMuted(value) {
+    if (value == this.microphoneMuted) {
+      return;
+    }
+    gAudioManager.microphoneMuted = value;
+
+    if (!this._activeCall) {
+      gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
+    }
+  },
+
+  get speakerEnabled() {
+    return (gAudioManager.getForceForUse(nsIAudioManager.USE_COMMUNICATION) ==
+            nsIAudioManager.FORCE_SPEAKER);
+  },
+  set speakerEnabled(value) {
+    if (value == this.speakerEnabled) {
+      return;
+    }
+    let force = value ? nsIAudioManager.FORCE_SPEAKER :
+                        nsIAudioManager.FORCE_NONE;
+    gAudioManager.setForceForUse(nsIAudioManager.USE_COMMUNICATION, force);
+
+    if (!this._activeCall) {
+      gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
+    }
+  },
+
   /**
    * List of tuples of national language identifier pairs.
    *
@@ -2948,13 +3368,6 @@ RadioInterface.prototype = {
     this.workerMessenger.send("deactivateDataCall", { cid: cid,
                                                       reason: reason });
   },
-
-  sendWorkerMessage: function sendWorkerMessage(rilMessageType, message,
-                                                callback) {
-    this.workerMessenger.send(rilMessageType, message, function (response) {
-      return callback.handleResponse(response);
-    });
-  }
 };
 
 function RILNetworkInterface(radioInterface, apnSetting) {

dom/system/gonk/nsIRadioInterfaceLayer.idl

@@ -79,13 +79,7 @@ interface nsIRilContext : nsISupports
   readonly attribute nsIDOMMozMobileConnectionInfo data;
 };
 
-[scriptable, function, uuid(3bc96351-53b0-47a1-a888-c74c64b60f25)]
+[scriptable, uuid(5efcd358-080e-46d6-a7f7-4f36c204eec3)]
-interface nsIRilSendWorkerMessageCallback : nsISupports
-{
-  boolean handleResponse(in jsval response);
-};
-
-[scriptable, uuid(61a8ca67-6113-4cd0-b443-e045f09863ed)]
 interface nsIRadioInterface : nsISupports
 {
   readonly attribute nsIRilContext rilContext;
@@ -111,10 +105,6 @@ interface nsIRadioInterface : nsISupports
                in DOMString message,
                in boolean silent,
                in nsIMobileMessageCallback request);
-
-  void sendWorkerMessage(in DOMString type,
-              [optional] in jsval message,
-              [optional] in nsIRilSendWorkerMessageCallback callback);
 };
 
 [scriptable, uuid(44b03951-1444-4c03-bd37-0bcb3a01b56f)]

dom/telephony/CallEvent.cpp

@@ -11,7 +11,6 @@
 
 USING_TELEPHONY_NAMESPACE
 using namespace mozilla::dom;
-using mozilla::ErrorResult;
 
 /* static */
 already_AddRefed<CallEvent>

dom/telephony/Makefile.in

@@ -5,18 +5,11 @@
 DEPTH            = @DEPTH@
 topsrcdir        = @top_srcdir@
 srcdir           = @srcdir@
-VPATH            = \
+VPATH            = @srcdir@
-  $(srcdir) \
-  $(srcdir)/ipc \
-  $(NULL)
 
 include $(DEPTH)/config/autoconf.mk
 
 include $(topsrcdir)/dom/dom-config.mk
 
-# Add VPATH to LOCAL_INCLUDES so we are going to include the correct backend
-# subdirectory (and the ipc one).
-LOCAL_INCLUDES = $(VPATH:%=-I%)
-
 include $(topsrcdir)/config/rules.mk
-include $(topsrcdir)/ipc/chromium/chromium-config.mk
+

dom/telephony/Telephony.cpp

@@ -24,9 +24,10 @@
 #include "TelephonyCall.h"
 #include "TelephonyCallGroup.h"
 
+#define NS_RILCONTENTHELPER_CONTRACTID "@mozilla.org/ril/content-helper;1"
+
 USING_TELEPHONY_NAMESPACE
 using namespace mozilla::dom;
-using mozilla::ErrorResult;
 
 namespace {
 
@@ -50,8 +51,6 @@ public:
     MOZ_ASSERT(mTelephony);
   }
 
-  virtual ~Listener() {}
-
   void
   Disconnect()
   {
@@ -112,7 +111,7 @@ Telephony::Shutdown()
     mListener->Disconnect();
 
     if (mProvider) {
-      mProvider->UnregisterListener(mListener);
+      mProvider->UnregisterTelephonyMsg(mListener);
       mProvider = nullptr;
     }
 
@@ -133,7 +132,7 @@ Telephony::Create(nsPIDOMWindow* aOwner, ErrorResult& aRv)
   NS_ASSERTION(aOwner, "Null owner!");
 
   nsCOMPtr<nsITelephonyProvider> ril =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
+    do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
   if (!ril) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return nullptr;
@@ -166,7 +165,7 @@ Telephony::Create(nsPIDOMWindow* aOwner, ErrorResult& aRv)
     return nullptr;
   }
 
-  rv = ril->RegisterListener(telephony->mListener);
+  rv = ril->RegisterTelephonyMsg(telephony->mListener);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return nullptr;
@@ -223,7 +222,12 @@ Telephony::DialInternal(bool isEmergency,
     }
   }
 
-  nsresult rv = mProvider->Dial(aNumber, isEmergency);
+  nsresult rv;
+  if (isEmergency) {
+    rv = mProvider->DialEmergency(aNumber);
+  } else {
+    rv = mProvider->Dial(aNumber);
+  }
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return nullptr;
@@ -587,7 +591,7 @@ NS_IMETHODIMP
 Telephony::EnumerateCallState(uint32_t aCallIndex, uint16_t aCallState,
                               const nsAString& aNumber, bool aIsActive,
                               bool aIsOutgoing, bool aIsEmergency,
-                              bool aIsConference)
+                              bool aIsConference, bool* aContinue)
 {
   nsRefPtr<TelephonyCall> call;
 
@@ -599,10 +603,12 @@ Telephony::EnumerateCallState(uint32_t aCallIndex, uint16_t aCallState,
   call = aIsConference ? mGroup->GetCall(aCallIndex) : GetCall(aCallIndex);
   if (call) {
     // We have the call either in mCalls or in mGroup. Skip it.
+    *aContinue = true;
     return NS_OK;
   }
 
   if (MoveCall(aCallIndex, aIsConference)) {
+    *aContinue = true;
     return NS_OK;
   }
 
@@ -616,6 +622,7 @@ Telephony::EnumerateCallState(uint32_t aCallIndex, uint16_t aCallState,
                                mCalls.Contains(call),
                "Should have auto-added new call!");
 
+  *aContinue = true;
   return NS_OK;
 }
 

dom/telephony/TelephonyCall.cpp

@@ -15,7 +15,6 @@
 
 USING_TELEPHONY_NAMESPACE
 using namespace mozilla::dom;
-using mozilla::ErrorResult;
 
 // static
 already_AddRefed<TelephonyCall>

dom/telephony/TelephonyCallGroup.cpp

@@ -13,7 +13,6 @@
 
 USING_TELEPHONY_NAMESPACE
 using namespace mozilla::dom;
-using mozilla::ErrorResult;
 
 TelephonyCallGroup::TelephonyCallGroup()
 : mCallState(nsITelephonyProvider::CALL_STATE_UNKNOWN)

dom/telephony/TelephonyFactory.cpp

@@ -1,30 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "mozilla/dom/telephony/TelephonyFactory.h"
-#ifdef MOZ_WIDGET_GONK
-#include "nsIGonkTelephonyProvider.h"
-#endif
-#include "nsServiceManagerUtils.h"
-#include "nsXULAppAPI.h"
-#include "TelephonyIPCProvider.h"
-
-USING_TELEPHONY_NAMESPACE
-
-/* static */ already_AddRefed<nsITelephonyProvider>
-TelephonyFactory::CreateTelephonyProvider()
-{
-  nsCOMPtr<nsITelephonyProvider> provider;
-
-  if (XRE_GetProcessType() == GeckoProcessType_Content) {
-    provider = new TelephonyIPCProvider();
-#ifdef MOZ_WIDGET_GONK
-  } else {
-    provider = do_CreateInstance(GONK_TELEPHONY_PROVIDER_CONTRACTID);
-#endif
-  }
-
-  return provider.forget();
-}

dom/telephony/TelephonyFactory.h

@@ -1,24 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_dom_telephony_TelephonyFactory_h
-#define mozilla_dom_telephony_TelephonyFactory_h
-
-#include "nsCOMPtr.h"
-#include "mozilla/dom/telephony/TelephonyCommon.h"
-
-class nsITelephonyProvider;
-
-BEGIN_TELEPHONY_NAMESPACE
-
-class TelephonyFactory
-{
-public:
-  static already_AddRefed<nsITelephonyProvider> CreateTelephonyProvider();
-};
-
-END_TELEPHONY_NAMESPACE
-
-#endif // mozilla_dom_telephony_TelephonyFactory_h

dom/telephony/gonk/TelephonyProvider.js

@@ -1,525 +0,0 @@
-/* -*- Mode: js; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-"use strict";
-
-const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
-
-Cu.import("resource://gre/modules/XPCOMUtils.jsm");
-Cu.import("resource://gre/modules/Services.jsm");
-
-var RIL = {};
-Cu.import("resource://gre/modules/ril_consts.js", RIL);
-
-const GONK_TELEPHONYPROVIDER_CONTRACTID =
-  "@mozilla.org/telephony/gonktelephonyprovider;1";
-const GONK_TELEPHONYPROVIDER_CID =
-  Components.ID("{67d26434-d063-4d28-9f48-5b3189788155}");
-
-const kPrefenceChangedObserverTopic = "nsPref:changed";
-const kXpcomShutdownObserverTopic   = "xpcom-shutdown";
-
-const nsIAudioManager = Ci.nsIAudioManager;
-const nsITelephonyProvider = Ci.nsITelephonyProvider;
-
-const CALL_WAKELOCK_TIMEOUT = 5000;
-
-let DEBUG;
-function debug(s) {
-  dump("TelephonyProvider: " + s + "\n");
-}
-
-XPCOMUtils.defineLazyGetter(this, "gAudioManager", function getAudioManager() {
-  try {
-    return Cc["@mozilla.org/telephony/audiomanager;1"]
-             .getService(nsIAudioManager);
-  } catch (ex) {
-    //TODO on the phone this should not fall back as silently.
-
-    // Fake nsIAudioManager implementation so that we can run the telephony
-    // code in a non-Gonk build.
-    if (DEBUG) debug("Using fake audio manager.");
-    return {
-      microphoneMuted: false,
-      masterVolume: 1.0,
-      masterMuted: false,
-      phoneState: nsIAudioManager.PHONE_STATE_CURRENT,
-      _forceForUse: {},
-
-      setForceForUse: function setForceForUse(usage, force) {
-        this._forceForUse[usage] = force;
-      },
-
-      getForceForUse: function setForceForUse(usage) {
-        return this._forceForUse[usage] || nsIAudioManager.FORCE_NONE;
-      }
-    };
-  }
-});
-
-XPCOMUtils.defineLazyServiceGetter(this, "gPowerManagerService",
-                                   "@mozilla.org/power/powermanagerservice;1",
-                                   "nsIPowerManagerService");
-
-XPCOMUtils.defineLazyServiceGetter(this, "gSystemMessenger",
-                                   "@mozilla.org/system-message-internal;1",
-                                   "nsISystemMessagesInternal");
-
-XPCOMUtils.defineLazyGetter(this, "gRadioInterface", function () {
-  let ril = Cc["@mozilla.org/ril;1"].getService(Ci["nsIRadioInterfaceLayer"]);
-  // TODO: Bug 854326 - B2G Multi-SIM: support multiple SIM cards for SMS/MMS
-  return ril.getRadioInterface(0);
-});
-
-XPCOMUtils.defineLazyGetter(this, "gPhoneNumberUtils", function () {
-  let ns = {};
-  Cu.import("resource://gre/modules/PhoneNumberUtils.jsm", ns);
-  return ns.PhoneNumberUtils;
-});
-
-function TelephonyProvider() {
-  this._listeners = [];
-
-  this._updateDebugFlag();
-
-  Services.obs.addObserver(this, kPrefenceChangedObserverTopic, false);
-  Services.obs.addObserver(this, kXpcomShutdownObserverTopic, false);
-}
-TelephonyProvider.prototype = {
-  classID: GONK_TELEPHONYPROVIDER_CID,
-  classInfo: XPCOMUtils.generateCI({classID: GONK_TELEPHONYPROVIDER_CID,
-                                    contractID: GONK_TELEPHONYPROVIDER_CONTRACTID,
-                                    classDescription: "TelephonyProvider",
-                                    interfaces: [Ci.nsITelephonyProvider,
-                                                 Ci.nsIGonkTelephonyProvider],
-                                    flags: Ci.nsIClassInfo.SINGLETON}),
-  QueryInterface: XPCOMUtils.generateQI([Ci.nsITelephonyProvider,
-                                         Ci.nsIGonkTelephonyProvider,
-                                         Ci.nsIObserver]),
-
-  _callRingWakeLock: null,
-  _callRingWakeLockTimer: null,
-  _cancelCallRingWakeLockTimer: function _cancelCallRingWakeLockTimer() {
-    if (this._callRingWakeLockTimer) {
-      this._callRingWakeLockTimer.cancel();
-    }
-    if (this._callRingWakeLock) {
-      this._callRingWakeLock.unlock();
-      this._callRingWakeLock = null;
-    }
-  },
-
-  // An array of nsITelephonyListener instances.
-  _listeners: null,
-  _notifyAllListeners: function _notifyAllListeners(aMethodName, aArgs) {
-    let listeners = this._listeners.slice();
-    for (let listener of listeners) {
-      if (this._listeners.indexOf(listener) == -1) {
-        // Listener has been unregistered in previous run.
-        continue;
-      }
-
-      let handler = listener[aMethodName];
-      try {
-        handler.apply(listener, aArgs);
-      } catch (e) {
-        debug("listener for " + aMethodName + " threw an exception: " + e);
-      }
-    }
-  },
-
-  /**
-   * Track the active call and update the audio system as its state changes.
-   */
-  _activeCall: null,
-  _updateCallAudioState: function _updateCallAudioState(aCall,
-                                                        aConferenceState) {
-    if (aConferenceState === nsITelephonyProvider.CALL_STATE_CONNECTED) {
-      gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_IN_CALL;
-      if (this.speakerEnabled) {
-        gAudioManager.setForceForUse(nsIAudioManager.USE_COMMUNICATION,
-                                     nsIAudioManager.FORCE_SPEAKER);
-      }
-      return;
-    }
-    if (aConferenceState === nsITelephonyProvider.CALL_STATE_UNKNOWN ||
-        aConferenceState === nsITelephonyProvider.CALL_STATE_HELD) {
-      if (!this._activeCall) {
-        gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
-      }
-      return;
-    }
-
-    if (!aCall) {
-      return;
-    }
-
-    if (aCall.isConference) {
-      if (this._activeCall && this._activeCall.callIndex == aCall.callIndex) {
-        this._activeCall = null;
-      }
-      return;
-    }
-
-    switch (aCall.state) {
-      case nsITelephonyProvider.CALL_STATE_DIALING: // Fall through...
-      case nsITelephonyProvider.CALL_STATE_ALERTING:
-      case nsITelephonyProvider.CALL_STATE_CONNECTED:
-        aCall.isActive = true;
-        this._activeCall = aCall;
-        gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_IN_CALL;
-        if (this.speakerEnabled) {
-          gAudioManager.setForceForUse(nsIAudioManager.USE_COMMUNICATION,
-                                       nsIAudioManager.FORCE_SPEAKER);
-        }
-        if (DEBUG) {
-          debug("Active call, put audio system into PHONE_STATE_IN_CALL: " +
-                gAudioManager.phoneState);
-        }
-        break;
-
-      case nsITelephonyProvider.CALL_STATE_INCOMING:
-        aCall.isActive = false;
-        if (!this._activeCall) {
-          // We can change the phone state into RINGTONE only when there's
-          // no active call.
-          gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_RINGTONE;
-          if (DEBUG) {
-            debug("Incoming call, put audio system into PHONE_STATE_RINGTONE: " +
-                  gAudioManager.phoneState);
-          }
-        }
-        break;
-
-      case nsITelephonyProvider.CALL_STATE_HELD: // Fall through...
-      case nsITelephonyProvider.CALL_STATE_DISCONNECTED:
-        aCall.isActive = false;
-        if (this._activeCall &&
-            this._activeCall.callIndex == aCall.callIndex) {
-          // Previously active call is not active now.
-          this._activeCall = null;
-        }
-
-        if (!this._activeCall) {
-          // No active call. Disable the audio.
-          gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
-          if (DEBUG) {
-            debug("No active call, put audio system into PHONE_STATE_NORMAL: " +
-                  gAudioManager.phoneState);
-          }
-        }
-        break;
-    }
-  },
-
-  _convertRILCallState: function _convertRILCallState(aState) {
-    switch (aState) {
-      case RIL.CALL_STATE_ACTIVE:
-        return nsITelephonyProvider.CALL_STATE_CONNECTED;
-      case RIL.CALL_STATE_HOLDING:
-        return nsITelephonyProvider.CALL_STATE_HELD;
-      case RIL.CALL_STATE_DIALING:
-        return nsITelephonyProvider.CALL_STATE_DIALING;
-      case RIL.CALL_STATE_ALERTING:
-        return nsITelephonyProvider.CALL_STATE_ALERTING;
-      case RIL.CALL_STATE_INCOMING:
-      case RIL.CALL_STATE_WAITING:
-        return nsITelephonyProvider.CALL_STATE_INCOMING;
-      default:
-        throw new Error("Unknown rilCallState: " + aState);
-    }
-  },
-
-  _convertRILSuppSvcNotification: function _convertRILSuppSvcNotification(aNotification) {
-    switch (aNotification) {
-      case RIL.GECKO_SUPP_SVC_NOTIFICATION_REMOTE_HELD:
-        return nsITelephonyProvider.NOTIFICATION_REMOTE_HELD;
-      case RIL.GECKO_SUPP_SVC_NOTIFICATION_REMOTE_RESUMED:
-        return nsITelephonyProvider.NOTIFICATION_REMOTE_RESUMED;
-      default:
-        throw new Error("Unknown rilSuppSvcNotification: " + aNotification);
-    }
-  },
-
-  _validateNumber: function _validateNumber(aNumber) {
-    // note: isPlainPhoneNumber also accepts USSD and SS numbers
-    if (gPhoneNumberUtils.isPlainPhoneNumber(aNumber)) {
-      return true;
-    }
-
-    let errorMsg = RIL.RIL_CALL_FAILCAUSE_TO_GECKO_CALL_ERROR[RIL.CALL_FAIL_UNOBTAINABLE_NUMBER];
-    let currentThread = Services.tm.currentThread;
-    currentThread.dispatch(this.notifyCallError.bind(this, -1, errorMsg),
-                           Ci.nsIThread.DISPATCH_NORMAL);
-    if (DEBUG) {
-      debug("Number '" + aNumber + "' doesn't seem to be a viable number. Drop.");
-    }
-
-    return false;
-  },
-
-  _updateDebugFlag: function _updateDebugFlag() {
-    try {
-      DEBUG = RIL.DEBUG_RIL ||
-              Services.prefs.getBoolPref("ril.debugging.enabled");
-    } catch (e) {}
-  },
-
-  /**
-   * nsITelephonyProvider interface.
-   */
-
-  registerListener: function(aListener) {
-    if (this._listeners.indexOf(aListener) >= 0) {
-      throw Cr.NS_ERROR_UNEXPECTED;
-    }
-
-    this._listeners.push(aListener);
-  },
-
-  unregisterListener: function(aListener) {
-    let index = this._listeners.indexOf(aListener);
-    if (index < 0) {
-      throw Cr.NS_ERROR_UNEXPECTED;
-    }
-
-    this._listeners.splice(index, 1);
-  },
-
-  enumerateCalls: function(aListener) {
-    if (DEBUG) debug("Requesting enumeration of calls for callback");
-    gRadioInterface.sendWorkerMessage("enumerateCalls", null,
-                                      (function(response) {
-      for (let call of response.calls) {
-        call.state = this._convertRILCallState(call.state);
-        call.isActive = this._activeCall ?
-          (call.callIndex == this._activeCall.callIndex) : false;
-
-        aListener.enumerateCallState(call.callIndex, call.state, call.number,
-                                     call.isActive, call.isOutgoing,
-                                     call.isEmergency, call.isConference);
-      }
-      aListener.enumerateCallStateComplete();
-
-      return false;
-    }).bind(this));
-  },
-
-  dial: function(aNumber, aIsEmergency) {
-    if (DEBUG) debug("Dialing " + (aIsEmergency ? "emergency " : "") + aNumber);
-    // we don't try to be too clever here, as the phone is probably in the
-    // locked state. Let's just check if it's a number without normalizing
-    if (!aIsEmergency) {
-      aNumber = gPhoneNumberUtils.normalize(aNumber);
-    }
-    if (this._validateNumber(aNumber)) {
-      gRadioInterface.sendWorkerMessage("dial", { number: aNumber,
-                                                  isDialEmergency: aIsEmergency });
-    }
-  },
-
-  hangUp: function(aCallIndex) {
-    gRadioInterface.sendWorkerMessage("hangUp", { callIndex: aCallIndex });
-  },
-
-  startTone: function(aDtmfChar) {
-    gRadioInterface.sendWorkerMessage("startTone", { dtmfChar: aDtmfChar });
-  },
-
-  stopTone: function() {
-    gRadioInterface.sendWorkerMessage("stopTone");
-  },
-
-  answerCall: function(aCallIndex) {
-    gRadioInterface.sendWorkerMessage("answerCall", { callIndex: aCallIndex });
-  },
-
-  rejectCall: function(aCallIndex) {
-    gRadioInterface.sendWorkerMessage("rejectCall", { callIndex: aCallIndex });
-  },
-
-  holdCall: function(aCallIndex) {
-    gRadioInterface.sendWorkerMessage("holdCall", { callIndex: aCallIndex });
-  },
-
-  resumeCall: function(aCallIndex) {
-    gRadioInterface.sendWorkerMessage("resumeCall", { callIndex: aCallIndex });
-  },
-
-  conferenceCall: function conferenceCall() {
-    gRadioInterface.sendWorkerMessage("conferenceCall");
-  },
-
-  separateCall: function separateCall(aCallIndex) {
-    gRadioInterface.sendWorkerMessage("separateCall", { callIndex: aCallIndex });
-  },
-
-  holdConference: function holdConference() {
-    gRadioInterface.sendWorkerMessage("holdConference");
-  },
-
-  resumeConference: function resumeConference() {
-    gRadioInterface.sendWorkerMessage("resumeConference");
-  },
-
-  get microphoneMuted() {
-    return gAudioManager.microphoneMuted;
-  },
-
-  set microphoneMuted(aMuted) {
-    if (aMuted == this.microphoneMuted) {
-      return;
-    }
-    gAudioManager.microphoneMuted = aMuted;
-
-    if (!this._activeCall) {
-      gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
-    }
-  },
-
-  get speakerEnabled() {
-    let force = gAudioManager.getForceForUse(nsIAudioManager.USE_COMMUNICATION);
-    return (force == nsIAudioManager.FORCE_SPEAKER);
-  },
-
-  set speakerEnabled(aEnabled) {
-    if (aEnabled == this.speakerEnabled) {
-      return;
-    }
-    let force = aEnabled ? nsIAudioManager.FORCE_SPEAKER :
-                           nsIAudioManager.FORCE_NONE;
-    gAudioManager.setForceForUse(nsIAudioManager.USE_COMMUNICATION, force);
-
-    if (!this._activeCall) {
-      gAudioManager.phoneState = nsIAudioManager.PHONE_STATE_NORMAL;
-    }
-  },
-
-  /**
-   * nsIGonkTelephonyProvider interface.
-   */
-
-  /**
-   * Handle call disconnects by updating our current state and the audio system.
-   */
-  notifyCallDisconnected: function notifyCallDisconnected(aCall) {
-    if (DEBUG) debug("handleCallDisconnected: " + JSON.stringify(aCall));
-
-    aCall.state = nsITelephonyProvider.CALL_STATE_DISCONNECTED;
-    let duration = ("started" in aCall && typeof aCall.started == "number") ?
-      new Date().getTime() - aCall.started : 0;
-    let data = {
-      number: aCall.number,
-      duration: duration,
-      direction: aCall.isOutgoing ? "outgoing" : "incoming"
-    };
-    gSystemMessenger.broadcastMessage("telephony-call-ended", data);
-
-    this._updateCallAudioState(aCall, null);
-
-    this._notifyAllListeners("callStateChanged", [aCall.callIndex,
-                                                  aCall.state,
-                                                  aCall.number,
-                                                  aCall.isActive,
-                                                  aCall.isOutgoing,
-                                                  aCall.isEmergency,
-                                                  aCall.isConference]);
-  },
-
-  /**
-   * Handle call error.
-   */
-  notifyCallError: function notifyCallError(aCallIndex, aErrorMsg) {
-    this._notifyAllListeners("notifyError", [aCallIndex, aErrorMsg]);
-  },
-
-  /**
-   * Handle an incoming call.
-   *
-   * Not much is known about this call at this point, but it's enough
-   * to start bringing up the Phone app already.
-   */
-  notifyCallRing: function notifyCallRing() {
-    if (!this._callRingWakeLock) {
-      this._callRingWakeLock = gPowerManagerService.newWakeLock("cpu");
-    }
-    if (!this._callRingWakeLockTimer) {
-      this._callRingWakeLockTimer =
-        Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
-    }
-    this._callRingWakeLockTimer
-        .initWithCallback(this._cancelCallRingWakeLockTimer.bind(this),
-                          CALL_WAKELOCK_TIMEOUT, Ci.nsITimer.TYPE_ONE_SHOT);
-
-    gSystemMessenger.broadcastMessage("telephony-new-call", {});
-  },
-
-  /**
-   * Handle call state changes by updating our current state and the audio
-   * system.
-   */
-  notifyCallStateChanged: function notifyCallStateChanged(aCall) {
-    if (DEBUG) debug("handleCallStateChange: " + JSON.stringify(aCall));
-
-    aCall.state = this._convertRILCallState(aCall.state);
-    if (aCall.state == nsITelephonyProvider.CALL_STATE_DIALING) {
-      gSystemMessenger.broadcastMessage("telephony-new-call", {});
-    }
-
-    this._updateCallAudioState(aCall, null);
-
-    this._notifyAllListeners("callStateChanged", [aCall.callIndex,
-                                                  aCall.state,
-                                                  aCall.number,
-                                                  aCall.isActive,
-                                                  aCall.isOutgoing,
-                                                  aCall.isEmergency,
-                                                  aCall.isConference]);
-  },
-
-  notifyCdmaCallWaiting: function notifyCdmaCallWaiting(aNumber) {
-    this._notifyAllListeners("notifyCdmaCallWaiting", [aNumber]);
-  },
-
-  notifySupplementaryService: function notifySupplementaryService(aCallIndex,
-                                                                  aNotification) {
-    let notification = this._convertRILSuppSvcNotification(aNotification);
-    this._notifyAllListeners("supplementaryServiceNotification",
-                             [aCallIndex, notification]);
-  },
-
-  notifyConferenceCallStateChanged: function notifyConferenceCallStateChanged(aState) {
-    if (DEBUG) debug("handleConferenceCallStateChanged: " + aState);
-    aState = aState != null ? convertRILCallState(aState) :
-                              nsITelephonyProvider.CALL_STATE_UNKNOWN;
-    this._updateCallAudioState(null, aState);
-
-    this._notifyAllListeners("conferenceCallStateChanged", [aState]);
-  },
-
-  /**
-   * nsIObserver interface.
-   */
-
-  observe: function observe(aSubject, aTopic, aData) {
-    switch (aTopic) {
-      case kPrefenceChangedObserverTopic:
-        if (aData === "ril.debugging.enabled") {
-          this._updateDebugFlag();
-        }
-        break;
-
-      case kXpcomShutdownObserverTopic:
-        // Cancel the timer for the call-ring wake lock.
-        this._cancelCallRingWakeLockTimer();
-
-        Services.obs.removeObserver(this, kPrefenceChangedObserverTopic);
-        Services.obs.removeObserver(this, kXpcomShutdownObserverTopic);
-        break;
-    }
-  }
-};
-
-this.NSGetFactory = XPCOMUtils.generateNSGetFactory([TelephonyProvider]);

dom/telephony/gonk/TelephonyProvider.manifest

@@ -1,2 +0,0 @@
-component {67d26434-d063-4d28-9f48-5b3189788155} TelephonyProvider.js
-contract @mozilla.org/telephony/gonktelephonyprovider;1 {67d26434-d063-4d28-9f48-5b3189788155}

dom/telephony/ipc/PTelephony.ipdl

@@ -1,83 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=8 et ft=cpp : */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-include protocol PContent;
-include protocol PTelephonyRequest;
-include TelephonyTypes;
-
-namespace mozilla {
-namespace dom {
-namespace telephony {
-
-sync protocol PTelephony {
-  manager PContent;
-  manages PTelephonyRequest;
-
-child:
-  NotifyCallError(int32_t aCallIndex, nsString aError);
-
-  NotifyCallStateChanged(IPCCallStateData aData);
-
-  NotifyCdmaCallWaiting(nsString aNumber);
-
-  NotifyConferenceCallStateChanged(uint16_t aCallState);
-
-  NotifySupplementaryService(int32_t aCallIndex, uint16_t aNotification);
-
-parent:
-  /**
-   * Sent when the child no longer needs to use PTelephony.
-   */
-  __delete__();
-
-  /**
-   * Sent when the child makes an asynchronous request to the parent.  It's
-   * currently only for request call enumeration.
-   */
-  PTelephonyRequest();
-
-  RegisterListener();
-
-  UnregisterListener();
-
-  DialCall(nsString aNumber, bool aIsEmergency);
-
-  HangUpCall(uint32_t aCallIndex);
-
-  AnswerCall(uint32_t aCallIndex);
-
-  RejectCall(uint32_t aCallIndex);
-
-  HoldCall(uint32_t aCallIndex);
-
-  ResumeCall(uint32_t aCallIndex);
-
-  ConferenceCall();
-
-  SeparateCall(uint32_t aCallIndex);
-
-  HoldConference();
-
-  ResumeConference();
-
-  StartTone(nsString aTone);
-
-  StopTone();
-
-  sync GetMicrophoneMuted()
-    returns (bool aMuted);
-
-  SetMicrophoneMuted(bool aMuted);
-
-  sync GetSpeakerEnabled()
-    returns (bool aEnabled);
-
-  SetSpeakerEnabled(bool aEnabled);
-};
-
-} /* namespace telephony */
-} /* namespace dom */
-} /* namespace mozilla */

dom/telephony/ipc/PTelephonyRequest.ipdl

@@ -1,30 +0,0 @@
-/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
-/* vim: set ts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-include protocol PTelephony;
-include TelephonyTypes;
-
-namespace mozilla {
-namespace dom {
-namespace telephony {
-
-protocol PTelephonyRequest
-{
-  manager PTelephony;
-
-child:
-  NotifyEnumerateCallState(IPCCallStateData aData);
-
-  /**
-   * Sent when the asynchronous request has completed. It's currently only for
-   * request call enumeration.
-   */
-  __delete__();
-};
-
-} /* namespace telephony */
-} /* namespace dom */
-} /* namespace mozilla */

dom/telephony/ipc/TelephonyChild.cpp

@@ -1,131 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "TelephonyChild.h"
-#include "nsITelephonyProvider.h"
-
-USING_TELEPHONY_NAMESPACE
-
-/*******************************************************************************
- * TelephonyChild
- ******************************************************************************/
-
-TelephonyChild::TelephonyChild(nsITelephonyListener* aListener)
-  : mListener(aListener)
-{
-  MOZ_ASSERT(aListener);
-}
-
-void
-TelephonyChild::ActorDestroy(ActorDestroyReason aWhy)
-{
-  mListener = nullptr;
-}
-
-PTelephonyRequestChild*
-TelephonyChild::AllocPTelephonyRequestChild()
-{
-  MOZ_CRASH("Caller is supposed to manually construct a request!");
-}
-
-bool
-TelephonyChild::DeallocPTelephonyRequestChild(PTelephonyRequestChild* aActor)
-{
-  delete aActor;
-  return true;
-}
-
-bool
-TelephonyChild::RecvNotifyCallError(const int32_t& aCallIndex,
-                                    const nsString& aError)
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->NotifyError(aCallIndex, aError);
-  return true;
-}
-
-bool
-TelephonyChild::RecvNotifyCallStateChanged(const IPCCallStateData& aData)
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->CallStateChanged(aData.callIndex(),
-                              aData.callState(),
-                              aData.number(),
-                              aData.isActive(),
-                              aData.isOutGoing(),
-                              aData.isEmergency(),
-                              aData.isConference());
-  return true;
-}
-
-bool
-TelephonyChild::RecvNotifyCdmaCallWaiting(const nsString& aNumber)
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->NotifyCdmaCallWaiting(aNumber);
-  return true;
-}
-
-bool
-TelephonyChild::RecvNotifyConferenceCallStateChanged(const uint16_t& aCallState)
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->ConferenceCallStateChanged(aCallState);
-  return true;
-}
-
-bool
-TelephonyChild::RecvNotifySupplementaryService(const int32_t& aCallIndex,
-                                               const uint16_t& aNotification)
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->SupplementaryServiceNotification(aCallIndex, aNotification);
-  return true;
-}
-
-/*******************************************************************************
- * TelephonyRequestChild
- ******************************************************************************/
-
-TelephonyRequestChild::TelephonyRequestChild(nsITelephonyListener* aListener)
-  : mListener(aListener)
-{
-  MOZ_ASSERT(aListener);
-}
-
-void
-TelephonyRequestChild::ActorDestroy(ActorDestroyReason aWhy)
-{
-  mListener = nullptr;
-}
-
-bool
-TelephonyRequestChild::Recv__delete__()
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->EnumerateCallStateComplete();
-  return true;
-}
-
-bool
-TelephonyRequestChild::RecvNotifyEnumerateCallState(const IPCCallStateData& aData)
-{
-  MOZ_ASSERT(mListener);
-
-  mListener->EnumerateCallState(aData.callIndex(),
-                                aData.callState(),
-                                aData.number(),
-                                aData.isActive(),
-                                aData.isOutGoing(),
-                                aData.isEmergency(),
-                                aData.isConference());
-  return true;
-}

dom/telephony/ipc/TelephonyChild.h

@@ -1,78 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_dom_telephony_TelephonyChild_h
-#define mozilla_dom_telephony_TelephonyChild_h
-
-#include "mozilla/dom/telephony/TelephonyCommon.h"
-#include "mozilla/dom/telephony/PTelephonyChild.h"
-#include "mozilla/dom/telephony/PTelephonyRequestChild.h"
-
-class nsITelephonyListener;
-
-BEGIN_TELEPHONY_NAMESPACE
-
-class TelephonyChild : public PTelephonyChild
-{
-public:
-  TelephonyChild(nsITelephonyListener* aListener);
-
-protected:
-  virtual ~TelephonyChild() {}
-
-  virtual void
-  ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
-
-  virtual PTelephonyRequestChild*
-  AllocPTelephonyRequestChild() MOZ_OVERRIDE;
-
-  virtual bool
-  DeallocPTelephonyRequestChild(PTelephonyRequestChild* aActor) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyCallError(const int32_t& aCallIndex,
-                      const nsString& aError) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyCallStateChanged(const IPCCallStateData& aData) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyCdmaCallWaiting(const nsString& aNumber) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyConferenceCallStateChanged(const uint16_t& aCallState) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifySupplementaryService(const int32_t& aCallIndex,
-                                 const uint16_t& aNotification) MOZ_OVERRIDE;
-
-private:
-  nsCOMPtr<nsITelephonyListener> mListener;
-};
-
-class TelephonyRequestChild : public PTelephonyRequestChild
-{
-public:
-  TelephonyRequestChild(nsITelephonyListener* aListener);
-
-protected:
-  virtual ~TelephonyRequestChild() {}
-
-  virtual void
-  ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
-
-  virtual bool
-  Recv__delete__() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvNotifyEnumerateCallState(const IPCCallStateData& aData) MOZ_OVERRIDE;
-
-private:
-  nsCOMPtr<nsITelephonyListener> mListener;
-};
-
-END_TELEPHONY_NAMESPACE
-
-#endif // mozilla_dom_telephony_TelephonyChild_h

dom/telephony/ipc/TelephonyIPCProvider.cpp

@@ -1,258 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "mozilla/dom/ContentChild.h"
-#include "TelephonyChild.h"
-#include "TelephonyIPCProvider.h"
-
-USING_TELEPHONY_NAMESPACE
-using namespace mozilla::dom;
-
-NS_IMPL_ISUPPORTS2(TelephonyIPCProvider,
-                   nsITelephonyProvider,
-                   nsITelephonyListener)
-
-TelephonyIPCProvider::TelephonyIPCProvider()
-{
-  // Deallocated in ContentChild::DeallocPTelephonyChild().
-  mPTelephonyChild = new TelephonyChild(this);
-  ContentChild::GetSingleton()->SendPTelephonyConstructor(mPTelephonyChild);
-}
-
-TelephonyIPCProvider::~TelephonyIPCProvider()
-{
-  mPTelephonyChild->Send__delete__(mPTelephonyChild);
-  mPTelephonyChild = nullptr;
-}
-
-/*
- * Implementation of nsITelephonyProvider.
- */
-
-NS_IMETHODIMP
-TelephonyIPCProvider::RegisterListener(nsITelephonyListener *aListener)
-{
-  MOZ_ASSERT(!mListeners.Contains(aListener));
-
-  // nsTArray doesn't fail.
-  mListeners.AppendElement(aListener);
-
-  if (mListeners.Length() == 1) {
-    mPTelephonyChild->SendRegisterListener();
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::UnregisterListener(nsITelephonyListener *aListener)
-{
-  MOZ_ASSERT(mListeners.Contains(aListener));
-
-  // We always have the element here, so it can't fail.
-  mListeners.RemoveElement(aListener);
-
-  if (!mListeners.Length()) {
-    mPTelephonyChild->SendUnregisterListener();
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::EnumerateCalls(nsITelephonyListener *aListener)
-{
-  // Life time of newly allocated TelephonyRequestChild instance is managed by
-  // IPDL itself.
-  TelephonyRequestChild* actor = new TelephonyRequestChild(aListener);
-  mPTelephonyChild->SendPTelephonyRequestConstructor(actor);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::Dial(const nsAString& aNumber,
-                          bool aIsEmergency)
-{
-  mPTelephonyChild->SendDialCall(nsString(aNumber), aIsEmergency);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::HangUp(uint32_t aCallIndex)
-{
-  mPTelephonyChild->SendHangUpCall(aCallIndex);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::AnswerCall(uint32_t aCallIndex)
-{
-  mPTelephonyChild->SendAnswerCall(aCallIndex);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::RejectCall(uint32_t aCallIndex)
-{
-  mPTelephonyChild->SendRejectCall(aCallIndex);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::HoldCall(uint32_t aCallIndex)
-{
-  mPTelephonyChild->SendHoldCall(aCallIndex);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::ResumeCall(uint32_t aCallIndex)
-{
-  mPTelephonyChild->SendResumeCall(aCallIndex);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::ConferenceCall()
-{
-  mPTelephonyChild->SendConferenceCall();
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::SeparateCall(uint32_t aCallIndex)
-{
-  mPTelephonyChild->SendSeparateCall(aCallIndex);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::HoldConference()
-{
-  mPTelephonyChild->SendHoldConference();
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::ResumeConference()
-{
-  mPTelephonyChild->SendResumeConference();
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::StartTone(const nsAString& aDtmfChar)
-{
-  mPTelephonyChild->SendStartTone(nsString(aDtmfChar));
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::StopTone()
-{
-  mPTelephonyChild->SendStopTone();
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::GetMicrophoneMuted(bool* aMuted)
-{
-  mPTelephonyChild->SendGetMicrophoneMuted(aMuted);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::SetMicrophoneMuted(bool aMuted)
-{
-  mPTelephonyChild->SendSetMicrophoneMuted(aMuted);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::GetSpeakerEnabled(bool* aEnabled)
-{
-  mPTelephonyChild->SendGetSpeakerEnabled(aEnabled);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::SetSpeakerEnabled(bool aEnabled)
-{
-  mPTelephonyChild->SendSetSpeakerEnabled(aEnabled);
-  return NS_OK;
-}
-
-// nsITelephonyListener
-
-NS_IMETHODIMP
-TelephonyIPCProvider::CallStateChanged(uint32_t aCallIndex,
-                                      uint16_t aCallState,
-                                      const nsAString& aNumber,
-                                      bool aIsActive,
-                                      bool aIsOutgoing,
-                                      bool aIsEmergency,
-                                      bool aIsConference)
-{
-  for (uint32_t i = 0; i < mListeners.Length(); i++) {
-    mListeners[i]->CallStateChanged(aCallIndex, aCallState, aNumber,
-                                    aIsActive, aIsOutgoing, aIsEmergency,
-                                    aIsConference);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::ConferenceCallStateChanged(uint16_t aCallState)
-{
-  for (uint32_t i = 0; i < mListeners.Length(); i++) {
-    mListeners[i]->ConferenceCallStateChanged(aCallState);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::EnumerateCallStateComplete()
-{
-  MOZ_CRASH("Not a EnumerateCalls request!");
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::EnumerateCallState(uint32_t aCallIndex,
-                                        uint16_t aCallState,
-                                        const nsAString& aNumber,
-                                        bool aIsActive,
-                                        bool aIsOutgoing,
-                                        bool aIsEmergency,
-                                        bool aIsConference)
-{
-  MOZ_CRASH("Not a EnumerateCalls request!");
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::NotifyCdmaCallWaiting(const nsAString& aNumber)
-{
-  for (uint32_t i = 0; i < mListeners.Length(); i++) {
-    mListeners[i]->NotifyCdmaCallWaiting(aNumber);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::NotifyError(int32_t aCallIndex,
-                                 const nsAString& aError)
-{
-  for (uint32_t i = 0; i < mListeners.Length(); i++) {
-    mListeners[i]->NotifyError(aCallIndex, aError);
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-TelephonyIPCProvider::SupplementaryServiceNotification(int32_t aCallIndex,
-                                                      uint16_t aNotification)
-{
-  for (uint32_t i = 0; i < mListeners.Length(); i++) {
-    mListeners[i]->SupplementaryServiceNotification(aCallIndex, aNotification);
-  }
-  return NS_OK;
-}

dom/telephony/ipc/TelephonyIPCProvider.h

@@ -1,37 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_dom_telephony_TelephonyIPCProvider_h
-#define mozilla_dom_telephony_TelephonyIPCProvider_h
-
-#include "mozilla/dom/telephony/TelephonyCommon.h"
-#include "mozilla/Attributes.h"
-#include "nsITelephonyProvider.h"
-
-BEGIN_TELEPHONY_NAMESPACE
-
-class PTelephonyChild;
-
-class TelephonyIPCProvider MOZ_FINAL : public nsITelephonyProvider
-                                     , public nsITelephonyListener
-{
-public:
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSITELEPHONYPROVIDER
-  NS_DECL_NSITELEPHONYLISTENER
-
-  TelephonyIPCProvider();
-
-protected:
-  virtual ~TelephonyIPCProvider();
-
-private:
-  nsTArray<nsCOMPtr<nsITelephonyListener> > mListeners;
-  PTelephonyChild* mPTelephonyChild;
-};
-
-END_TELEPHONY_NAMESPACE
-
-#endif // mozilla_dom_telephony_TelephonyIPCProvider_h

dom/telephony/ipc/TelephonyParent.cpp

@@ -1,448 +0,0 @@
-/* -*- Mode: C++ tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "TelephonyParent.h"
-
-USING_TELEPHONY_NAMESPACE
-
-/*******************************************************************************
- * TelephonyParent
- ******************************************************************************/
-
-NS_IMPL_ISUPPORTS1(TelephonyParent, nsITelephonyListener)
-
-TelephonyParent::TelephonyParent()
-  : mActorDestroyed(false)
-  , mRegistered(false)
-{
-}
-
-void
-TelephonyParent::ActorDestroy(ActorDestroyReason why)
-{
-  // The child process could die before this asynchronous notification, in which
-  // case ActorDestroy() was called and mActorDestroyed is set to true. Return
-  // an error here to avoid sending a message to the dead process.
-  mActorDestroyed = true;
-
-  // Try to unregister listener if we're still registered.
-  RecvUnregisterListener();
-}
-
-bool
-TelephonyParent::RecvPTelephonyRequestConstructor(PTelephonyRequestParent* aActor)
-{
-  TelephonyRequestParent* actor = static_cast<TelephonyRequestParent*>(aActor);
-
-  return actor->DoRequest();
-}
-
-PTelephonyRequestParent*
-TelephonyParent::AllocPTelephonyRequestParent()
-{
-  TelephonyRequestParent* actor = new TelephonyRequestParent();
-  // Add an extra ref for IPDL. Will be released in
-  // TelephonyParent::DeallocPTelephonyRequestParent().
-  NS_ADDREF(actor);
-
-  return actor;
-}
-
-bool
-TelephonyParent::DeallocPTelephonyRequestParent(PTelephonyRequestParent* aActor)
-{
-  // TelephonyRequestParent is refcounted, must not be freed manually.
-  static_cast<TelephonyRequestParent*>(aActor)->Release();
-  return true;
-}
-
-bool
-TelephonyParent::Recv__delete__()
-{
-  return true; // Unregister listener in TelephonyParent::ActorDestroy().
-}
-
-bool
-TelephonyParent::RecvRegisterListener()
-{
-  NS_ENSURE_TRUE(!mRegistered, true);
-
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  mRegistered = NS_SUCCEEDED(provider->RegisterListener(this));
-  return true;
-}
-
-bool
-TelephonyParent::RecvUnregisterListener()
-{
-  NS_ENSURE_TRUE(mRegistered, true);
-
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  mRegistered = !NS_SUCCEEDED(provider->UnregisterListener(this));
-  return true;
-}
-
-bool
-TelephonyParent::RecvDialCall(const nsString& aNumber,
-                              const bool& aIsEmergency)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->Dial(aNumber, aIsEmergency);
-  return true;
-}
-
-bool
-TelephonyParent::RecvHangUpCall(const uint32_t& aCallIndex)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->HangUp(aCallIndex);
-  return true;
-}
-
-bool
-TelephonyParent::RecvAnswerCall(const uint32_t& aCallIndex)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->AnswerCall(aCallIndex);
-  return true;
-}
-
-bool
-TelephonyParent::RecvRejectCall(const uint32_t& aCallIndex)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->RejectCall(aCallIndex);
-  return true;
-}
-
-bool
-TelephonyParent::RecvHoldCall(const uint32_t& aCallIndex)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->HoldCall(aCallIndex);
-  return true;
-}
-
-bool
-TelephonyParent::RecvResumeCall(const uint32_t& aCallIndex)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->ResumeCall(aCallIndex);
-  return true;
-}
-
-bool
-TelephonyParent::RecvConferenceCall()
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->ConferenceCall();
-  return true;
-}
-
-bool
-TelephonyParent::RecvSeparateCall(const uint32_t& aCallState)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->SeparateCall(aCallState);
-  return true;
-}
-
-bool
-TelephonyParent::RecvHoldConference()
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->HoldConference();
-  return true;
-}
-
-bool
-TelephonyParent::RecvResumeConference()
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->ResumeConference();
-  return true;
-}
-
-bool
-TelephonyParent::RecvStartTone(const nsString& aTone)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->StartTone(aTone);
-  return true;
-}
-
-bool
-TelephonyParent::RecvStopTone()
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->StopTone();
-  return true;
-}
-
-bool
-TelephonyParent::RecvGetMicrophoneMuted(bool* aMuted)
-{
-  *aMuted = false;
-
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->GetMicrophoneMuted(aMuted);
-  return true;
-}
-
-bool
-TelephonyParent::RecvSetMicrophoneMuted(const bool& aMuted)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->SetMicrophoneMuted(aMuted);
-  return true;
-}
-
-bool
-TelephonyParent::RecvGetSpeakerEnabled(bool* aEnabled)
-{
-  *aEnabled = false;
-
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->GetSpeakerEnabled(aEnabled);
-  return true;
-}
-
-bool
-TelephonyParent::RecvSetSpeakerEnabled(const bool& aEnabled)
-{
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  NS_ENSURE_TRUE(provider, true);
-
-  provider->SetSpeakerEnabled(aEnabled);
-  return true;
-}
-
-// nsITelephonyListener
-
-NS_IMETHODIMP
-TelephonyParent::CallStateChanged(uint32_t aCallIndex,
-                                  uint16_t aCallState,
-                                  const nsAString& aNumber,
-                                  bool aIsActive,
-                                  bool aIsOutgoing,
-                                  bool aIsEmergency,
-                                  bool aIsConference)
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  IPCCallStateData data(aCallIndex, aCallState, nsString(aNumber), aIsActive,
-                        aIsOutgoing, aIsEmergency, aIsConference);
-  return SendNotifyCallStateChanged(data) ? NS_OK : NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
-TelephonyParent::ConferenceCallStateChanged(uint16_t aCallState)
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  return SendNotifyConferenceCallStateChanged(aCallState) ? NS_OK
-                                                          : NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
-TelephonyParent::EnumerateCallStateComplete()
-{
-  MOZ_CRASH("Not a EnumerateCalls request!");
-}
-
-NS_IMETHODIMP
-TelephonyParent::EnumerateCallState(uint32_t aCallIndex,
-                                    uint16_t aCallState,
-                                    const nsAString& aNumber,
-                                    bool aIsActive,
-                                    bool aIsOutgoing,
-                                    bool aIsEmergency,
-                                    bool aIsConference)
-{
-  MOZ_CRASH("Not a EnumerateCalls request!");
-}
-
-NS_IMETHODIMP
-TelephonyParent::NotifyCdmaCallWaiting(const nsAString& aNumber)
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  return SendNotifyCdmaCallWaiting(nsString(aNumber)) ? NS_OK
-                                                      : NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
-TelephonyParent::NotifyError(int32_t aCallIndex,
-                             const nsAString& aError)
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  return SendNotifyCallError(aCallIndex, nsString(aError)) ? NS_OK
-                                                           : NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
-TelephonyParent::SupplementaryServiceNotification(int32_t aCallIndex,
-                                                  uint16_t aNotification)
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  return SendNotifySupplementaryService(aCallIndex, aNotification)
-    ? NS_OK : NS_ERROR_FAILURE;
-}
-
-/*******************************************************************************
- * TelephonyRequestParent
- ******************************************************************************/
-
-NS_IMPL_ISUPPORTS1(TelephonyRequestParent, nsITelephonyListener)
-
-TelephonyRequestParent::TelephonyRequestParent()
-  : mActorDestroyed(false)
-{
-}
-
-void
-TelephonyRequestParent::ActorDestroy(ActorDestroyReason why)
-{
-  // The child process could die before this asynchronous notification, in which
-  // case ActorDestroy() was called and mActorDestroyed is set to true. Return
-  // an error here to avoid sending a message to the dead process.
-  mActorDestroyed = true;
-}
-
-bool
-TelephonyRequestParent::DoRequest()
-{
-  nsresult rv = NS_ERROR_FAILURE;
-
-  nsCOMPtr<nsITelephonyProvider> provider =
-    do_GetService(TELEPHONY_PROVIDER_CONTRACTID);
-  if (provider) {
-    rv = provider->EnumerateCalls(this);
-  }
-
-  if (NS_FAILED(rv)) {
-    return NS_SUCCEEDED(EnumerateCallStateComplete());
-  }
-
-  return true;
-}
-
-// nsITelephonyListener
-
-NS_IMETHODIMP
-TelephonyRequestParent::CallStateChanged(uint32_t aCallIndex,
-                                         uint16_t aCallState,
-                                         const nsAString& aNumber,
-                                         bool aIsActive,
-                                         bool aIsOutgoing,
-                                         bool aIsEmergency,
-                                         bool aIsConference)
-{
-  MOZ_CRASH("Not a TelephonyParent!");
-}
-
-NS_IMETHODIMP
-TelephonyRequestParent::ConferenceCallStateChanged(uint16_t aCallState)
-{
-  MOZ_CRASH("Not a TelephonyParent!");
-}
-
-NS_IMETHODIMP
-TelephonyRequestParent::EnumerateCallStateComplete()
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  return Send__delete__(this) ? NS_OK : NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
-TelephonyRequestParent::EnumerateCallState(uint32_t aCallIndex,
-                                           uint16_t aCallState,
-                                           const nsAString& aNumber,
-                                           bool aIsActive,
-                                           bool aIsOutgoing,
-                                           bool aIsEmergency,
-                                           bool aIsConference)
-{
-  NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
-
-  IPCCallStateData data(aCallIndex, aCallState, nsString(aNumber), aIsActive,
-                        aIsOutgoing, aIsEmergency, aIsConference);
-  return SendNotifyEnumerateCallState(data) ? NS_OK : NS_ERROR_FAILURE;
-}
-
-NS_IMETHODIMP
-TelephonyRequestParent::NotifyCdmaCallWaiting(const nsAString& aNumber)
-{
-  MOZ_CRASH("Not a TelephonyParent!");
-}
-
-NS_IMETHODIMP
-TelephonyRequestParent::NotifyError(int32_t aCallIndex,
-                                    const nsAString& aError)
-{
-  MOZ_CRASH("Not a TelephonyParent!");
-}
-
-NS_IMETHODIMP
-TelephonyRequestParent::SupplementaryServiceNotification(int32_t aCallIndex,
-                                                         uint16_t aNotification)
-{
-  MOZ_CRASH("Not a TelephonyParent!");
-}

dom/telephony/ipc/TelephonyParent.h

@@ -1,128 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_dom_telephony_TelephonyParent_h
-#define mozilla_dom_telephony_TelephonyParent_h
-
-#include "mozilla/dom/telephony/TelephonyCommon.h"
-#include "mozilla/dom/telephony/PTelephonyParent.h"
-#include "mozilla/dom/telephony/PTelephonyRequestParent.h"
-#include "nsITelephonyProvider.h"
-
-BEGIN_TELEPHONY_NAMESPACE
-
-class TelephonyParent : public PTelephonyParent
-                      , public nsITelephonyListener
-{
-public:
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSITELEPHONYLISTENER
-
-  TelephonyParent();
-
-protected:
-  virtual ~TelephonyParent() {}
-
-  virtual void
-  ActorDestroy(ActorDestroyReason why);
-
-  virtual bool
-  RecvPTelephonyRequestConstructor(PTelephonyRequestParent* aActor) MOZ_OVERRIDE;
-
-  virtual PTelephonyRequestParent*
-  AllocPTelephonyRequestParent() MOZ_OVERRIDE;
-
-  virtual bool
-  DeallocPTelephonyRequestParent(PTelephonyRequestParent* aActor) MOZ_OVERRIDE;
-
-  virtual bool
-  Recv__delete__() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvRegisterListener() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvUnregisterListener() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvDialCall(const nsString& aNumber,
-               const bool& aIsEmergency) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvHangUpCall(const uint32_t& aCallIndex) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvAnswerCall(const uint32_t& aCallIndex) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvRejectCall(const uint32_t& aCallIndex) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvHoldCall(const uint32_t& aCallIndex) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvResumeCall(const uint32_t& aCallIndex) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvConferenceCall() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvSeparateCall(const uint32_t& callIndex) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvHoldConference() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvResumeConference() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvStartTone(const nsString& aTone) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvStopTone() MOZ_OVERRIDE;
-
-  virtual bool
-  RecvGetMicrophoneMuted(bool* aMuted) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvSetMicrophoneMuted(const bool& aMuted) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvGetSpeakerEnabled(bool* aEnabled) MOZ_OVERRIDE;
-
-  virtual bool
-  RecvSetSpeakerEnabled(const bool& aEnabled) MOZ_OVERRIDE;
-
-private:
-  bool mActorDestroyed;
-  bool mRegistered;
-};
-
-class TelephonyRequestParent : public PTelephonyRequestParent
-                             , public nsITelephonyListener
-{
-  friend class TelephonyParent;
-
-public:
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSITELEPHONYLISTENER
-
-protected:
-  TelephonyRequestParent();
-  virtual ~TelephonyRequestParent() {}
-
-  virtual void
-  ActorDestroy(ActorDestroyReason why);
-
-private:
-  bool mActorDestroyed;
-
-  bool
-  DoRequest();
-};
-
-END_TELEPHONY_NAMESPACE
-
-#endif /* mozilla_dom_telephony_TelephonyParent_h */

dom/telephony/ipc/TelephonyTypes.ipdlh

@@ -1,24 +0,0 @@
-/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
-/* vim: set ts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-namespace mozilla {
-namespace dom {
-namespace telephony {
-
-struct IPCCallStateData
-{
-  uint32_t callIndex;
-  uint16_t callState;
-  nsString number;
-  bool     isActive;
-  bool     isOutGoing;
-  bool     isEmergency;
-  bool     isConference;
-};
-
-} /* namespace telephony */
-} /* namespace dom */
-} /* namespace mozilla */

dom/telephony/moz.build

@@ -12,47 +12,17 @@ XPIDL_MODULE = 'dom_telephony'
 
 MODULE = 'dom'
 
-EXPORTS.mozilla.dom.telephony += [
-    'CallEvent.h',
-    'CallsList.h',
-    'Telephony.h',
-    'TelephonyCall.h',
-    'TelephonyCallGroup.h',
-    'TelephonyCommon.h',
-    'TelephonyFactory.h',
-    'ipc/TelephonyChild.h',
-    'ipc/TelephonyParent.h',
-]
-
 CPP_SOURCES += [
     'CallEvent.cpp',
     'CallsList.cpp',
     'Telephony.cpp',
     'TelephonyCall.cpp',
     'TelephonyCallGroup.cpp',
-    'TelephonyChild.cpp',
-    'TelephonyFactory.cpp',
-    'TelephonyIPCProvider.cpp',
-    'TelephonyParent.cpp',
 ]
 
-IPDL_SOURCES += [
-    'ipc/PTelephony.ipdl',
-    'ipc/PTelephonyRequest.ipdl',
-    'ipc/TelephonyTypes.ipdlh'
-]
-
-if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk':
-    XPIDL_SOURCES += [
-        'nsIGonkTelephonyProvider.idl',
-    ]
-    EXTRA_COMPONENTS += [
-        'gonk/TelephonyProvider.js',
-        'gonk/TelephonyProvider.manifest',
-    ]
-
 FAIL_ON_WARNINGS = True
 
 LIBXUL_LIBRARY = True
 
 LIBRARY_NAME = 'domtelephony_s'
+

dom/telephony/nsIGonkTelephonyProvider.idl

@@ -1,31 +0,0 @@
-/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "nsITelephonyProvider.idl"
-
-%{C++
-#define GONK_TELEPHONY_PROVIDER_CONTRACTID \
-        "@mozilla.org/telephony/gonktelephonyprovider;1"
-%}
-
-[scriptable, uuid(0d106c7e-ba47-48ee-ba48-c92002d401b6)]
-interface nsIGonkTelephonyProvider : nsITelephonyProvider
-{
-  void notifyCallDisconnected(in jsval call);
-
-  void notifyCallError(in long callIndex,
-                       in AString error);
-
-  void notifyCallRing();
-
-  void notifyCallStateChanged(in jsval call);
-
-  void notifyCdmaCallWaiting(in AString number);
-
-  void notifySupplementaryService(in long callIndex,
-                                  in AString notification);
-
-  void notifyConferenceCallStateChanged(in unsigned short state);
-};

dom/telephony/nsITelephonyProvider.idl

@@ -4,7 +4,7 @@
 
 #include "nsISupports.idl"
 
-[scriptable, uuid(3aa42e77-7c2b-43a1-b105-7be094b0817a)]
+[scriptable, uuid(a5818719-e1b6-4fdc-8551-006055fa9996)]
 interface nsITelephonyListener : nsISupports
 {
   /**
@@ -67,14 +67,15 @@ interface nsITelephonyListener : nsISupports
    *        Indicates whether this call is outgoing or incoming.
    * @param isConference
    *        Indicates whether this call is a conference call.
+   * @return true to continue enumeration or false to cancel.
    */
-  void enumerateCallState(in unsigned long callIndex,
+  boolean enumerateCallState(in unsigned long callIndex,
-                          in unsigned short callState,
+                             in unsigned short callState,
-                          in AString number,
+                             in AString number,
-                          in boolean isActive,
+                             in boolean isActive,
-                          in boolean isOutgoing,
+                             in boolean isOutgoing,
-                          in boolean isEmergency,
+                             in boolean isEmergency,
-                          in boolean isConference);
+                             in boolean isConference);
 
   /**
    * Notify when RIL receives supplementary service notification.
@@ -107,18 +108,11 @@ interface nsITelephonyListener : nsISupports
   void notifyCdmaCallWaiting(in AString number);
 };
 
-%{C++
-#define TELEPHONY_PROVIDER_CID \
-  { 0x9cf8aa52, 0x7c1c, 0x4cde, { 0x97, 0x4e, 0xed, 0x2a, 0xa0, 0xe7, 0x35, 0xfa } }
-#define TELEPHONY_PROVIDER_CONTRACTID \
-  "@mozilla.org/telephony/telephonyprovider;1"
-%}
-
 /**
  * XPCOM component (in the content process) that provides the telephony
  * information.
  */
-[scriptable, uuid(effca006-1ca8-47f7-9bab-1323f90a14ec)]
+[scriptable, uuid(45a2f856-4e07-499a-94c6-624f90c3345b)]
 interface nsITelephonyProvider : nsISupports
 {
   const unsigned short CALL_STATE_UNKNOWN = 0;
@@ -141,8 +135,8 @@ interface nsITelephonyProvider : nsISupports
    * RadioInterfaceLayer in the chrome process. Only a content process that has
    * the 'telephony' permission is allowed to register.
    */
-  void registerListener(in nsITelephonyListener listener);
+  void registerTelephonyMsg(in nsITelephonyListener listener);
-  void unregisterListener(in nsITelephonyListener listener);
+  void unregisterTelephonyMsg(in nsITelephonyListener listener);
 
   /**
    * Will continue calling listener.enumerateCallState until the listener
@@ -153,8 +147,8 @@ interface nsITelephonyProvider : nsISupports
   /**
    * Functionality for making and managing phone calls.
    */
-  void dial(in DOMString number,
+  void dial(in DOMString number);
-            in boolean isEmergency);
+  void dialEmergency(in DOMString number);
   void hangUp(in unsigned long callIndex);
 
   void startTone(in DOMString dtmfChar);

dom/webidl/WebIDL.mk

@@ -34,8 +34,6 @@ webidl_files = \
   BiquadFilterNode.webidl \
   Blob.webidl \
   BrowserElementDictionaries.webidl \
-  CallEvent.webidl \
-  CallsList.webidl \
   CameraControl.webidl \
   CameraManager.webidl \
   CanvasRenderingContext2D.webidl \
@@ -361,9 +359,6 @@ webidl_files = \
   SVGViewElement.webidl \
   SVGZoomAndPan.webidl \
   SVGZoomEvent.webidl \
-  Telephony.webidl \
-  TelephonyCall.webidl \
-  TelephonyCallGroup.webidl \
   Text.webidl \
   TextDecoder.webidl \
   TextEncoder.webidl \
@@ -450,8 +445,12 @@ endif
 
 ifdef MOZ_B2G_RIL
 webidl_files += \
+  CallsList.webidl \
   MozStkCommandEvent.webidl \
   MozVoicemail.webidl \
+  Telephony.webidl \
+  TelephonyCall.webidl \
+  TelephonyCallGroup.webidl \
   $(NULL)
 endif
 
@@ -496,6 +495,7 @@ endif
 
 ifdef MOZ_B2G_RIL
 webidl_files += \
+  CallEvent.webidl \
   CFStateChangeEvent.webidl \
   DataErrorEvent.webidl \
   IccCardLockErrorEvent.webidl \

layout/build/Makefile.in

@@ -66,7 +66,6 @@ SHARED_LIBRARY_LIBS = \
 	$(DEPTH)/dom/promise/$(LIB_PREFIX)dompromise_s.$(LIB_SUFFIX) \
 	$(DEPTH)/dom/src/notification/$(LIB_PREFIX)jsdomnotification_s.$(LIB_SUFFIX) \
 	$(DEPTH)/dom/system/$(LIB_PREFIX)domsystem_s.$(LIB_SUFFIX) \
-	$(DEPTH)/dom/telephony/$(LIB_PREFIX)domtelephony_s.$(LIB_SUFFIX) \
 	$(DEPTH)/dom/workers/$(LIB_PREFIX)domworkers_s.$(LIB_SUFFIX) \
 	$(DEPTH)/dom/indexedDB/$(LIB_PREFIX)dom_indexeddb_s.$(LIB_SUFFIX) \
 	$(DEPTH)/dom/indexedDB/ipc/$(LIB_PREFIX)dom_indexeddb_ipc_s.$(LIB_SUFFIX) \
@@ -137,6 +136,7 @@ SHARED_LIBRARY_LIBS	+= $(DEPTH)/dom/camera/$(LIB_PREFIX)domcamera_s.$(LIB_SUFFIX
 ifdef MOZ_B2G_RIL #{
 SHARED_LIBRARY_LIBS	+= \
   $(DEPTH)/dom/system/gonk/$(LIB_PREFIX)domsystemgonk_s.$(LIB_SUFFIX) \
+  $(DEPTH)/dom/telephony/$(LIB_PREFIX)domtelephony_s.$(LIB_SUFFIX) \
   $(DEPTH)/dom/icc/src/$(LIB_PREFIX)dom_icc_s.$(LIB_SUFFIX) \
   $(DEPTH)/dom/cellbroadcast/src/$(LIB_PREFIX)dom_cellbroadcast_s.$(LIB_SUFFIX) \
   $(DEPTH)/dom/voicemail/$(LIB_PREFIX)domvoicemail_s.$(LIB_SUFFIX) \

layout/build/nsLayoutModule.cpp

@@ -230,9 +230,6 @@ static void Shutdown();
 #include "mozilla/dom/alarm/AlarmHalService.h"
 #include "mozilla/dom/time/TimeService.h"
 
-#include "mozilla/dom/telephony/TelephonyFactory.h"
-#include "nsITelephonyProvider.h"
-
 #ifdef MOZ_WIDGET_GONK
 #include "GonkGPSGeolocationProvider.h"
 #endif
@@ -241,7 +238,6 @@ static void Shutdown();
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::dom::mobilemessage;
-using namespace mozilla::dom::telephony;
 using mozilla::dom::alarm::AlarmHalService;
 using mozilla::dom::indexedDB::IndexedDatabaseManager;
 using mozilla::dom::power::PowerManagerService;
@@ -342,8 +338,6 @@ NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsVolumeService,
 #endif
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIMediaManagerService,
                                          MediaManager::GetInstance)
-NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsITelephonyProvider,
-                                         TelephonyFactory::CreateTelephonyProvider)
 
 //-----------------------------------------------------------------------------
 
@@ -817,7 +811,6 @@ NS_DEFINE_NAMED_CID(NS_SYNTHVOICEREGISTRY_CID);
 #ifdef ACCESSIBILITY
 NS_DEFINE_NAMED_CID(NS_ACCESSIBILITY_SERVICE_CID);
 #endif
-NS_DEFINE_NAMED_CID(TELEPHONY_PROVIDER_CID);
 
 static nsresult
 CreateWindowCommandTableConstructor(nsISupports *aOuter,
@@ -1100,7 +1093,6 @@ static const mozilla::Module::CIDEntry kLayoutCIDs[] = {
 #ifdef ACCESSIBILITY
   { &kNS_ACCESSIBILITY_SERVICE_CID, false, NULL, CreateA11yService },
 #endif
-  { &kTELEPHONY_PROVIDER_CID, false, NULL, nsITelephonyProviderConstructor },
   { NULL }
 };
 
@@ -1256,7 +1248,6 @@ static const mozilla::Module::ContractIDEntry kLayoutContracts[] = {
   { "@mozilla.org/accessibilityService;1", &kNS_ACCESSIBILITY_SERVICE_CID },
   { "@mozilla.org/accessibleRetrieval;1", &kNS_ACCESSIBILITY_SERVICE_CID },
 #endif
-  { TELEPHONY_PROVIDER_CONTRACTID, &kTELEPHONY_PROVIDER_CID },
   { NULL }
 };