ref: remove double "l" from SignallingLayer

modules/RTC/RTC.js

 
     /**
      * Creates new <tt>TraceablePeerConnection</tt>
-     * @param {SignallingLayer} signalling the signalling layer that will
+     * @param {SignalingLayer} signaling the signaling layer that will
      * provide information about the media or participants which is not carried
      * over SDP.
      * @param {Object} iceConfig an object describing the ICE config like
      * preferred over other video codecs.
      * @return {TraceablePeerConnection}
      */
-    createPeerConnection (signalling, iceConfig, options) {
+    createPeerConnection (signaling, iceConfig, options) {
         const newConnection
             = new TraceablePeerConnection(
                 this,
                 this.peerConnectionIdCounter,
-                signalling, iceConfig, RTC.getPCConstraints(), options);
+                signaling, iceConfig, RTC.getPCConstraints(), options);
 
         this.peerConnections.set(newConnection.id, newConnection);
         this.peerConnectionIdCounter += 1;
 
     /**
      * Initializes a new JitsiRemoteTrack instance with the data provided by
-     * the signalling layer and SDP.
+     * the signaling layer and SDP.
      *
      * @param {string} ownerEndpointId
      * @param {MediaStream} stream

modules/RTC/TraceablePeerConnection.js

  *
  * @param {RTC} rtc the instance of <tt>RTC</tt> service
  * @param {number} id the peer connection id assigned by the parent RTC module.
- * @param {SignallingLayer} signallingLayer the signalling layer instance
+ * @param {SignalingLayer} signalingLayer the signaling layer instance
  * @param {object} ice_config WebRTC 'PeerConnection' ICE config
  * @param {object} constraints WebRTC 'PeerConnection' constraints
  * @param {object} options <tt>TracablePeerConnection</tt> config options.
  *
  * @constructor
  */
-function TraceablePeerConnection(rtc, id, signallingLayer, ice_config,
+function TraceablePeerConnection(rtc, id, signalingLayer, ice_config,
                                  constraints, options) {
     var self = this;
     /**
      */
     this.id = id;
     /**
-     * The signalling layer which operates this peer connection.
-     * @type {SignallingLayer}
+     * The signaling layer which operates this peer connection.
+     * @type {SignalingLayer}
      */
-    this.signallingLayer = signallingLayer;
+    this.signalingLayer = signalingLayer;
     this.options = options;
     var RTCPeerConnectionType = null;
     if (RTCBrowserType.isFirefox()) {
     // FIXME the length of ssrcLines[0] not verified, but it will fail
     // with global error handler anyway
     let trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
-    const ownerEndpointId = this.signallingLayer.getSSRCOwner(trackSsrc);
+    const ownerEndpointId = this.signalingLayer.getSSRCOwner(trackSsrc);
 
     if (!ownerEndpointId) {
         GlobalOnErrorHandler.callErrorHandler(
     logger.log('associated ssrc', ownerEndpointId, trackSsrc);
 
     const peerMediaInfo
-        = this.signallingLayer.getPeerMediaInfo(ownerEndpointId, mediaType);
+        = this.signalingLayer.getPeerMediaInfo(ownerEndpointId, mediaType);
 
     if (!peerMediaInfo) {
         GlobalOnErrorHandler.callErrorHandler(

modules/xmpp/JingleSessionPC.js

  *
  * @constructor
  *
- * @implements {SignallingLayer}
+ * @implements {SignalingLayer}
  */
 function JingleSessionPC(me, sid, peerjid, connection,
                          media_constraints, ice_config, options) {

service/RTC/SignallingLayer.js → service/RTC/SignalingLayer.js

  * Interface used to expose the information carried over the signalling channel
  * which is not available to the RTC module in the media SDP.
  *
- * @interface SignallingLayer
+ * @interface SignalingLayer
  */
-export default class SignallingLayer {
+export default class SignalingLayer {
 
     /**
      * Obtains the endpoint ID for given SSRC.