[eslint] max-params

.eslintrc.js

         'max-len': [ 'error', 80 ],
         'max-lines': 0,
         'max-nested-callbacks': 2,
+        'max-params': 2,
         'max-statements': 0,
         'max-statements-per-line': 2,
         'multiline-ternary': 0,

JitsiConference.js

     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, newTrack);
 };
 
+/* eslint-disable max-params */
+
 /**
  * Adds loca WebRTC stream to the conference.
  * @param {MediaStream} stream new stream that will be added.
  * called. The option is used for adding stream, before the Jingle call is
  * started. That is before the 'session-accept' is sent.
  */
-JitsiConference.prototype._addLocalStream
-    = function(stream, callback, errorCallback, ssrcInfo, dontModifySources) {
-        if (this.jingleSession) {
-            this.jingleSession.addStream(
-            stream, callback, errorCallback, ssrcInfo, dontModifySources);
-        } else {
+JitsiConference.prototype._addLocalStream = function(
+        stream,
+        callback,
+        errorCallback,
+        ssrcInfo,
+        dontModifySources) {
+    if (this.jingleSession) {
+        this.jingleSession.addStream(
+            stream,
+            callback,
+            errorCallback,
+            ssrcInfo,
+            dontModifySources);
+    } else {
         // We are done immediately
-            logger.warn('Add local MediaStream - no JingleSession started yet');
-            callback();
-        }
-    };
+        logger.warn('Add local MediaStream - no JingleSession started yet');
+        callback();
+    }
+};
 
 /**
  * Remove local WebRTC media stream.
  * @param {object} ssrcInfo object with information about the SSRCs associated
  * with the stream.
  */
-JitsiConference.prototype.removeLocalStream
-    = function(stream, callback, errorCallback, ssrcInfo) {
-        if (this.jingleSession) {
-            this.jingleSession.removeStream(
-            stream, callback, errorCallback, ssrcInfo);
-        } else {
-            // We are done immediately
-            logger.warn(
-                'Remove local MediaStream - no JingleSession started yet');
-            callback();
-        }
-    };
+JitsiConference.prototype.removeLocalStream = function(
+        stream,
+        callback,
+        errorCallback,
+        ssrcInfo) {
+    if (this.jingleSession) {
+        this.jingleSession.removeStream(
+            stream,
+            callback,
+            errorCallback,
+            ssrcInfo);
+    } else {
+        // We are done immediately
+        logger.warn('Remove local MediaStream - no JingleSession started yet');
+        callback();
+    }
+};
+
+/* eslint-enable max-params */
 
 /**
  * Generate ssrc info object for a stream with the following properties:
     this.room.muteParticipant(participant.getJid(), true);
 };
 
+/* eslint-disable max-params */
+
 /**
  * Notifies this JitsiConference that a new member has joined its chat room.
  *
  * @param isHidden indicates if this is a hidden participant (system
  * participant for example a recorder).
  */
-JitsiConference.prototype.onMemberJoined
-    = function(jid, nick, role, isHidden) {
-        const id = Strophe.getResourceFromJid(jid);
+JitsiConference.prototype.onMemberJoined = function(jid, nick, role, isHidden) {
+    const id = Strophe.getResourceFromJid(jid);
 
-        if (id === 'focus' || this.myUserId() === id) {
-            return;
-        }
-        const participant = new JitsiParticipant(jid, this, nick, isHidden);
+    if (id === 'focus' || this.myUserId() === id) {
+        return;
+    }
+    const participant = new JitsiParticipant(jid, this, nick, isHidden);
 
-        participant._role = role;
-        this.participants[id] = participant;
-        this.eventEmitter.emit(
-            JitsiConferenceEvents.USER_JOINED,
-            id,
-            participant);
-        this.xmpp.caps.getFeatures(jid).then(features => {
+    participant._role = role;
+    this.participants[id] = participant;
+    this.eventEmitter.emit(
+        JitsiConferenceEvents.USER_JOINED,
+        id,
+        participant);
+    this.xmpp.caps.getFeatures(jid)
+        .then(features => {
             participant._supportsDTMF = features.has('urn:xmpp:jingle:dtmf:0');
             this.updateDTMFSupport();
-        }, error => logger.error(error));
-    };
+        },
+        error => logger.error(error));
+};
+
+/* eslint-enable max-params */
 
 JitsiConference.prototype.onMemberLeft = function(jid) {
     const id = Strophe.getResourceFromJid(jid);

JitsiConferenceEventManager.js

                 authIdentity);
         });
 
-    chatRoom.addListener(XMPPEvents.MESSAGE_RECEIVED,
+    chatRoom.addListener(
+        XMPPEvents.MESSAGE_RECEIVED,
+
+        // eslint-disable-next-line max-params
         (jid, displayName, txt, myJid, ts) => {
             const id = Strophe.getResourceFromJid(jid);
 
-            conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED,
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.MESSAGE_RECEIVED,
                 id, txt, ts);
         });
 

JitsiMeetJS.js

         this.mediaDevices.enumerateDevices(callback);
     },
 
+    /* eslint-disable max-params */
+
     /**
      * @returns function that can be used to be attached to window.onerror and
      * if options.enableWindowOnErrorHandler is enabled returns
         Statistics.reportGlobalError(error);
     },
 
+    /* eslint-enable max-params */
+
     /**
      * Returns current machine id saved from the local storage.
      * @returns {string} the machine id

JitsiParticipant.js

  * Represents a participant in (i.e. a member of) a conference.
  */
 export default class JitsiParticipant {
+
+    /* eslint-disable max-params */
+
     /**
      * Initializes a new JitsiParticipant instance.
      *
         this._properties = {};
     }
 
+    /* eslint-enable max-params */
+
     /**
      * @returns {JitsiConference} The conference that this participant belongs
      * to.

modules/RTC/JitsiLocalTrack.js

 
 const logger = getLogger(__filename);
 
+/* eslint-disable max-params */
+
 /**
  * Represents a single media track(either audio or video).
  * One <tt>JitsiLocalTrack</tt> corresponds to one WebRTC MediaStreamTrack.
  * @param facingMode the camera facing mode used in getUserMedia call
  * @constructor
  */
-function JitsiLocalTrack(stream, track, mediaType, videoType, resolution,
-                         deviceId, facingMode) {
-    const self = this;
-
-    JitsiTrack.call(this,
-        null /* RTC */, stream, track,
+function JitsiLocalTrack(
+        stream,
+        track,
+        mediaType,
+        videoType,
+        resolution,
+        deviceId,
+        facingMode) {
+    JitsiTrack.call(
+        this,
+        null /* RTC */,
+        stream,
+        track,
         () => {
             if (!this.dontFireRemoveEvent) {
-                this.eventEmitter.emit(
-                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
+                this.eventEmitter.emit(JitsiTrackEvents.LOCAL_TRACK_STOPPED);
             }
             this.dontFireRemoveEvent = false;
         } /* inactiveHandler */,
-        mediaType, videoType, null /* ssrc */);
+        mediaType,
+        videoType,
+        null /* ssrc */);
     this.dontFireRemoveEvent = false;
     this.resolution = resolution;
 
      */
     this._noDataFromSourceTimeout = null;
 
-    this._onDeviceListChanged = function(devices) {
-        self._setRealDeviceIdFromDeviceList(devices);
+    this._onDeviceListChanged = devices => {
+        this._setRealDeviceIdFromDeviceList(devices);
 
         // Mark track as ended for those browsers that do not support
         // "readyState" property. We do not touch tracks created with default
         // device ID "".
-        if (typeof self.getTrack().readyState === 'undefined'
-            && typeof self._realDeviceId !== 'undefined'
-            && !devices.find(d => d.deviceId === self._realDeviceId)) {
-            self._trackEnded = true;
+        if (typeof this.getTrack().readyState === 'undefined'
+                && typeof this._realDeviceId !== 'undefined'
+                && !devices.find(d => d.deviceId === this._realDeviceId)) {
+            this._trackEnded = true;
         }
     };
 
     // because there might be local tracks not attached to a conference.
     if (this.isAudioTrack() && RTCUtils.isDeviceChangeAvailable('output')) {
         this._onAudioOutputDeviceChanged = this.setAudioOutput.bind(this);
-
-        RTCUtils.addListener(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
+        RTCUtils.addListener(
+            RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
             this._onAudioOutputDeviceChanged);
     }
 
-    RTCUtils.addListener(RTCEvents.DEVICE_LIST_CHANGED,
+    RTCUtils.addListener(
+        RTCEvents.DEVICE_LIST_CHANGED,
         this._onDeviceListChanged);
 
     this._initNoDataFromSourceHandlers();
 }
 
+/* eslint-enable max-params */
+
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);
 JitsiLocalTrack.prototype.constructor = JitsiLocalTrack;
 

modules/RTC/JitsiRemoteTrack.js

 let ttfmTrackerAudioAttached = false;
 let ttfmTrackerVideoAttached = false;
 
+/* eslint-disable max-params */
+
 /**
  * Represents a single media track (either audio or video).
  * @param {RTC} rtc the RTC service instance.
  * @param {boolean} muted the initial muted state
  * @constructor
  */
-function JitsiRemoteTrack(rtc, conference, ownerEndpointId, stream, track,
-                          mediaType, videoType, ssrc, muted) {
+function JitsiRemoteTrack(
+        rtc,
+        conference,
+        ownerEndpointId,
+        stream,
+        track,
+        mediaType,
+        videoType,
+        ssrc,
+        muted) {
     JitsiTrack.call(
         this,
         conference,
     }
 }
 
+/* eslint-enable max-params */
+
 JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);
 JitsiRemoteTrack.prototype.constructor = JitsiRemoteTrack;
 

modules/RTC/JitsiTrack.js

     }
 }
 
+/* eslint-disable max-params */
+
 /**
  * Represents a single media track (either audio or video).
  * @constructor
     this._setHandler('inactive', streamInactiveHandler);
 }
 
+/* eslint-enable max-params */
+
 /**
  * Sets handler to the WebRTC MediaStream or MediaStreamTrack object depending
  * on the passed type.

modules/RTC/RTC.js

         this.localTracks.splice(pos, 1);
     }
 
+    /* eslint-disable max-params */
+
     /**
      * Initializes a new JitsiRemoteTrack instance with the data provided by
      * the signaling layer and SDP.
      * @param {string} ssrc
      * @param {boolean} muted
      */
-    _createRemoteTrack(ownerEndpointId,
-                        stream, track, mediaType, videoType, ssrc, muted) {
+    _createRemoteTrack(
+            ownerEndpointId,
+            stream,
+            track,
+            mediaType,
+            videoType,
+            ssrc,
+            muted) {
         const remoteTrack
             = new JitsiRemoteTrack(
-                this, this.conference, ownerEndpointId, stream, track,
-                mediaType, videoType, ssrc, muted);
+                this,
+                this.conference,
+                ownerEndpointId,
+                stream,
+                track,
+                mediaType,
+                videoType,
+                ssrc,
+                muted);
         const remoteTracks
             = this.remoteTracks[ownerEndpointId]
                 || (this.remoteTracks[ownerEndpointId] = {});
 
         if (remoteTracks[mediaType]) {
             logger.error(
-                'Overwriting remote track!', ownerEndpointId, mediaType);
+                'Overwriting remote track!',
+                ownerEndpointId,
+                mediaType);
         }
         remoteTracks[mediaType] = remoteTrack;
 
         this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_ADDED, remoteTrack);
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Removes all JitsiRemoteTracks associated with given MUC nickname
      * (resource part of the JID). Returns array of removed tracks.

modules/RTC/RTCUtils.js

         });
     }
 
+    /* eslint-disable max-params */
+
     /**
     * @param {string[]} um required user media types
     * @param {function} successCallback
         }
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Creates the local MediaStreams.
      * @param {Object} [options] optional parameters

modules/RTC/ScreenObtainer.js

         }
     },
 
+    /* eslint-disable max-params */
+
     handleExtensionInstallationError(options, streamCallback, failCallback, e) {
         const webStoreInstallUrl = getWebStoreInstallUrl(this.options);
 
             msg));
     },
 
+    /* eslint-enable max-params */
+
     checkForChromeExtensionOnInterval(options, streamCallback, failCallback) {
         if (options.checkAgain() === false) {
             failCallback(new JitsiTrackError(

modules/RTC/TraceablePeerConnection.js

 const logger = getLogger(__filename);
 const SIMULCAST_LAYERS = 3;
 
+/* eslint-disable max-params */
+
 /**
  * Creates new instance of 'TraceablePeerConnection'.
  *
  *
  * @constructor
  */
-function TraceablePeerConnection(rtc, id, signalingLayer, iceConfig,
-                                 constraints, options) {
-    const self = this;
+function TraceablePeerConnection(
+        rtc,
+        id,
+        signalingLayer,
+        iceConfig,
+        constraints,
+        options) {
 
     /**
      * The parent instance of RTC service which created this
      * <tt>TracablePeerConnection</tt>.
      * @type {RTC}
      */
-
     this.rtc = rtc;
 
     /**
     this.rtxModifier = new RtxModifier();
 
     // override as desired
-    this.trace = function(what, info) {
+    this.trace = (what, info) => {
         /* logger.warn('WTRACE', what, info);
         if (info && RTCBrowserType.isIExplorer()) {
             if (info.length > 1024) {
                 logger.warn('WTRACE', what, info.substr(2048));
             }
         }*/
-        self.updateLog.push({
+        this.updateLog.push({
             time: new Date(),
             type: what,
             value: info || ''
         });
     };
     this.onicecandidate = null;
-    this.peerconnection.onicecandidate = function(event) {
+    this.peerconnection.onicecandidate = event => {
         // FIXME: this causes stack overflow with Temasys Plugin
         if (!RTCBrowserType.isTemasysPluginUsed()) {
-            self.trace(
+            this.trace(
                 'onicecandidate',
                 JSON.stringify(event.candidate, null, ' '));
         }
 
-        if (self.onicecandidate !== null) {
-            self.onicecandidate(event);
+        if (this.onicecandidate !== null) {
+            this.onicecandidate(event);
         }
     };
     this.onaddstream = null;
-    this.peerconnection.onaddstream = function(event) {
-        self.trace('onaddstream', event.stream.id);
-        if (self.onaddstream !== null) {
-            self.onaddstream(event);
+    this.peerconnection.onaddstream = event => {
+        this.trace('onaddstream', event.stream.id);
+        if (this.onaddstream !== null) {
+            this.onaddstream(event);
         }
     };
     this.onremovestream = null;
-    this.peerconnection.onremovestream = function(event) {
-        self.trace('onremovestream', event.stream.id);
-        if (self.onremovestream !== null) {
-            self.onremovestream(event);
+    this.peerconnection.onremovestream = event => {
+        this.trace('onremovestream', event.stream.id);
+        if (this.onremovestream !== null) {
+            this.onremovestream(event);
         }
     };
-    this.peerconnection.onaddstream = function(event) {
-        self._remoteStreamAdded(event.stream);
-    };
-    this.peerconnection.onremovestream = function(event) {
-        self._remoteStreamRemoved(event.stream);
-    };
+    this.peerconnection.onaddstream
+        = event => this._remoteStreamAdded(event.stream);
+    this.peerconnection.onremovestream
+        = event => this._remoteStreamRemoved(event.stream);
     this.onsignalingstatechange = null;
-    this.peerconnection.onsignalingstatechange = function(event) {
-        self.trace('onsignalingstatechange', self.signalingState);
-        if (self.onsignalingstatechange !== null) {
-            self.onsignalingstatechange(event);
+    this.peerconnection.onsignalingstatechange = event => {
+        this.trace('onsignalingstatechange', this.signalingState);
+        if (this.onsignalingstatechange !== null) {
+            this.onsignalingstatechange(event);
         }
     };
     this.oniceconnectionstatechange = null;
-    this.peerconnection.oniceconnectionstatechange = function(event) {
-        self.trace('oniceconnectionstatechange', self.iceConnectionState);
-        if (self.oniceconnectionstatechange !== null) {
-            self.oniceconnectionstatechange(event);
+    this.peerconnection.oniceconnectionstatechange = event => {
+        this.trace('oniceconnectionstatechange', this.iceConnectionState);
+        if (this.oniceconnectionstatechange !== null) {
+            this.oniceconnectionstatechange(event);
         }
     };
     this.onnegotiationneeded = null;
-    this.peerconnection.onnegotiationneeded = function(event) {
-        self.trace('onnegotiationneeded');
-        if (self.onnegotiationneeded !== null) {
-            self.onnegotiationneeded(event);
+    this.peerconnection.onnegotiationneeded = event => {
+        this.trace('onnegotiationneeded');
+        if (this.onnegotiationneeded !== null) {
+            this.onnegotiationneeded(event);
         }
     };
-    self.ondatachannel = null;
-    this.peerconnection.ondatachannel = function(event) {
-        self.trace('ondatachannel', event);
-        if (self.ondatachannel !== null) {
-            self.ondatachannel(event);
+    this.ondatachannel = null;
+    this.peerconnection.ondatachannel = event => {
+        this.trace('ondatachannel', event);
+        if (this.ondatachannel !== null) {
+            this.ondatachannel(event);
         }
     };
 
     // XXX: do all non-firefox browsers which we support also support this?
     if (!RTCBrowserType.isFirefox() && this.maxstats) {
         this.statsinterval = window.setInterval(() => {
-            self.peerconnection.getStats(stats => {
+            this.peerconnection.getStats(stats => {
                 const results = stats.result();
                 const now = new Date();
 
                     results[i].names().forEach(name => {
                         // eslint-disable-next-line no-shadow
                         const id = `${results[i].id}-${name}`;
-                        let s = self.stats[id];
+                        let s = this.stats[id];
 
                         if (!s) {
-                            self.stats[id] = s = {
+                            this.stats[id] = s = {
                                 startTime: now,
                                 endTime: now,
                                 values: [],
                         }
                         s.values.push(results[i].stat(name));
                         s.times.push(now.getTime());
-                        if (s.values.length > self.maxstats) {
+                        if (s.values.length > this.maxstats) {
                             s.values.shift();
                             s.times.shift();
                         }
                     });
                 }
             });
-
         }, 1000);
     }
 }
 
+/* eslint-enable max-params */
+
 /**
  * Returns a string representation of a SessionDescription object.
  */

modules/statistics/CallStats.js

     }
 });
 
+/* eslint-disable max-params */
+
 /**
  * Lets CallStats module know where is given SSRC rendered by providing renderer
  * tag ID.
  * @param containerId {string} the id of media 'audio' or 'video' tag which
  *        renders the stream.
  */
-CallStats.prototype.associateStreamWithVideoTag
-= function(ssrc, isLocal, usageLabel, containerId) {
+CallStats.prototype.associateStreamWithVideoTag = function(
+        ssrc,
+        isLocal,
+        usageLabel,
+        containerId) {
     if (!callStats) {
         return;
     }
     }).bind(this)();
 };
 
+/* eslint-enable max-params */
+
 /**
  * Notifies CallStats for mute events
  * @param mute {boolean} true for muted and false for not muted

modules/statistics/RTPStatsCollector.js

     this.transport = [];
 }
 
+/* eslint-disable max-params */
+
 /**
  * <tt>StatsCollector</tt> registers for stats updates of given
  * <tt>peerconnection</tt> in given <tt>interval</tt>. On each update particular
     this.ssrc2stats = {};
 }
 
+/* eslint-enable max-params */
+
 module.exports = StatsCollector;
 
 /**

modules/statistics/statistics.js

     }
 };
 
+/* eslint-disable max-params */
+
 /**
  * Lets the underlying statistics module know where is given SSRC rendered by
  * providing renderer tag ID.
  * @param containerId {string} the id of media 'audio' or 'video' tag which
  *        renders the stream.
  */
-Statistics.prototype.associateStreamWithVideoTag
-= function(ssrc, isLocal, usageLabel, containerId) {
-    if (this.callstats) {
-        this.callstats.associateStreamWithVideoTag(
-            ssrc, isLocal, usageLabel, containerId);
-    }
-};
+Statistics.prototype.associateStreamWithVideoTag = function(
+        ssrc,
+        isLocal,
+        usageLabel,
+        containerId) {
+    this.callstats && this.callstats.associateStreamWithVideoTag(
+        ssrc,
+        isLocal,
+        usageLabel,
+        containerId);
+};
+
+/* eslint-enable max-params */
 
 /**
  * Notifies CallStats that getUserMedia failed.

modules/transcription/recordingResult.js

+/* eslint-disable max-params */
+
 /**
  * This object stores variables needed around the recording of an audio stream
  * and passing this recording along with additional information along to
     this.wordArray = wordArray;
 };
 
+/* eslint-enable max-params */
+
 module.exports = RecordingResult;

modules/util/GlobalOnErrorHandler.js

  * Custom error handler that calls the old global error handler and executes
  * all handlers that were previously added.
  */
-function JitsiGlobalErrorHandler(message, source, lineno, colno, error) {
-    handlers.forEach(handler => handler(message, source, lineno, colno, error));
-    if (oldOnErrorHandler) {
-        oldOnErrorHandler(message, source, lineno, colno, error);
-    }
+function JitsiGlobalErrorHandler(...args) {
+    handlers.forEach(handler => handler(...args));
+    oldOnErrorHandler && oldOnErrorHandler(...args);
 }
 
 // If an old handler exists, also fire its events.

modules/util/ScriptUtil.js

 const currentExecutingScript = require('current-executing-script');
 
+/* eslint-disable max-params */
 
 /**
  * Implements utility functions which facilitate the dealing with scripts such
      * @param loadCallback on load callback function
      * @param errorCallback callback to be called on error loading the script
      */
-    loadScript(src, async, prepend, relativeURL,
-                          loadCallback, errorCallback) {
+    loadScript(
+            src,
+            async,
+            prepend,
+            relativeURL,
+            loadCallback,
+            errorCallback) {
         const d = document;
         const tagName = 'script';
         const script = d.createElement(tagName);
     }
 };
 
+/* eslint-enable max-params */
+
 module.exports = ScriptUtil;

modules/xmpp/ChatRoom.js

 /* eslint-disable newline-per-chained-call */
 
 export default class ChatRoom extends Listenable {
+
+    /* eslint-disable max-params */
+
     constructor(connection, jid, password, XMPP, options) {
         super();
         this.xmpp = XMPP;
         this.locked = false;
     }
 
+    /* eslint-enable max-params */
+
     initPresenceMap() {
         this.presMap.to = this.myroomjid;
         this.presMap.xns = 'http://jabber.org/protocol/muc';
             error => logger.log('Kick participant error: ', error));
     }
 
+    /* eslint-disable max-params */
+
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
         this.connection.sendIQ(
             onError);
     }
 
+    /* eslint-enable max-params */
+
     addToPresence(key, values) {
         values.tagName = key;
         this.removeFromPresence(key);

modules/xmpp/JingleSession.js

  */
 export default class JingleSession {
 
+    /* eslint-disable max-params */
+
     /**
      * Creates new <tt>JingleSession</tt>.
      * @param {string} sid the Jingle session identifier
      * @param {Object} iceConfig the ICE servers config object as defined by
      * the WebRTC. Passed to the PeerConnection's constructor.
      */
-    constructor(sid,
-                localJid, peerjid, connection, mediaConstraints, iceConfig) {
+    constructor(
+            sid,
+            localJid,
+            peerjid,
+            connection,
+            mediaConstraints,
+            iceConfig) {
         this.sid = sid;
         this.localJid = localJid;
         this.peerjid = peerjid;
         this.rtc = null;
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Prepares this object to initiate a session.
      * @param {boolean} isInitiator whether we will be the Jingle initiator.
      * @param failure a callback called when either timeout occurs or ERROR
      * response is received.
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
+    // eslint-disable-next-line max-params, no-unused-vars, no-empty-function
     terminate(reason, text, success, failure) { }
 
     /**

modules/xmpp/JingleSessionPC.js

 
 export default class JingleSessionPC extends JingleSession {
 
+    /* eslint-disable max-params */
+
     /**
      * Creates new <tt>JingleSessionPC</tt>
      * @param {string} sid the Jingle Session ID - random string which
      *
      * @implements {SignalingLayer}
      */
-    constructor(sid, me, peerjid, connection,
-                mediaConstraints, iceConfig, options) {
+    constructor(
+            sid,
+            me,
+            peerjid,
+            connection,
+            mediaConstraints,
+            iceConfig,
+            options) {
         super(sid, me, peerjid, connection, mediaConstraints, iceConfig);
 
         this.lasticecandidate = false;
             = async.queue(this._processQueueTasks.bind(this), 1);
     }
 
+    /* eslint-enable max-params */
+
     doInitialize() {
         this.lasticecandidate = false;
 
             IQ_TIMEOUT);
     }
 
+    /* eslint-disable max-params */
+
     /**
      * @inheritDoc
      */
         this.connection.jingle.terminate(this.sid);
     }
 
+    /* eslint-enable max-params */
+
     onTerminated(reasonCondition, reasonText) {
         this.state = 'ended';
 
         return removeSsrcInfo;
     }
 
+    /* eslint-disable max-params */
+
     /**
      * Adds stream.
      * @param stream new stream that will be added.
      *  the 'doReplaceStream' task or the 'doAddStream' task (for example)
      */
     addStream(stream, callback, errorCallback, ssrcInfo, dontModifySources) {
-
         const workFunction = finishedCallback => {
             if (!this.peerconnection) {
                 finishedCallback(
             });
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Generate ssrc info object for a stream with the following properties:
      * - ssrcs - Array of the ssrcs associated with the stream.
         }
     }
 
+    /* eslint-disable max-params */
+
     /**
      * Remove streams.
      * @param stream stream that will be removed.
             });
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Figures out added/removed ssrcs and send update IQs.
      * @param oldSDP SDP object for old description.

modules/xmpp/moderator.js

 function createExpBackoffTimer(step) {
     let count = 1;
 
-
     return function(reset) {
         // Reset call
         if (reset) {
     };
 }
 
+/* eslint-disable max-params */
+
 function Moderator(roomName, xmpp, emitter, options) {
     this.roomName = roomName;
     this.xmppService = xmpp;
     // Sip gateway can be enabled by configuring Jigasi host in config.js or
     // it will be enabled automatically if focus detects the component through
     // service discovery.
-    this.sipGatewayEnabled = this.options.connection.hosts
-        && this.options.connection.hosts.call_control !== undefined;
+    this.sipGatewayEnabled
+        = this.options.connection.hosts
+            && this.options.connection.hosts.call_control !== undefined;
 
     this.eventEmitter = emitter;
 
     }
 }
 
+/* eslint-enable max-params */
+
 Moderator.prototype.isExternalAuthEnabled = function() {
     return this.externalAuthEnabled;
 };

modules/xmpp/recording.js

 const JitsiRecorderErrors = require('../../JitsiRecorderErrors');
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
-function Recording(type, eventEmitter, connection, focusMucJid, jirecon,
-    roomjid) {
+/* eslint-disable max-params */
+
+function Recording(
+        type,
+        eventEmitter,
+        connection,
+        focusMucJid,
+        jirecon,
+        roomjid) {
     this.eventEmitter = eventEmitter;
     this.connection = connection;
     this.state = null;
     this.roomjid = roomjid;
 }
 
+/* eslint-enable max-params */
+
 Recording.types = {
     COLIBRI: 'colibri',
     JIRECON: 'jirecon',
     this.eventEmitter.emit(XMPPEvents.RECORDER_STATE_CHANGED, this.state);
 };
 
-Recording.prototype.setRecordingJibri
-    = function(state, callback, errCallback, options = {}) {
+/* eslint-disable max-params */
 
-        if (state === this.state) {
-            errCallback(JitsiRecorderErrors.INVALID_STATE);
-        }
-
-        // FIXME jibri does not accept IQ without 'url' attribute set ?
-        const iq
-            = $iq({ to: this.focusMucJid,
-                type: 'set' })
-                .c('jibri', {
-                    'xmlns': 'http://jitsi.org/protocol/jibri',
-                    'action': state === Recording.status.ON
-                            ? Recording.action.START
-                            : Recording.action.STOP,
-                    'streamid': options.streamId
-                })
-                .up();
-
-        logger.log(`Set jibri recording: ${state}`, iq.nodeTree);
-        logger.log(iq.nodeTree);
-        this.connection.sendIQ(
-        iq,
-        result => {
-            logger.log('Result', result);
+Recording.prototype.setRecordingJibri = function(
+        state,
+        callback,
+        errCallback,
+        options = {}) {
+    if (state === this.state) {
+        errCallback(JitsiRecorderErrors.INVALID_STATE);
+    }
 
-            const jibri = $(result).find('jibri');
+    // FIXME jibri does not accept IQ without 'url' attribute set ?
+    const iq
+        = $iq({
+            to: this.focusMucJid,
+            type: 'set'
+        })
+            .c('jibri', {
+                'xmlns': 'http://jitsi.org/protocol/jibri',
+                'action': state === Recording.status.ON
+                        ? Recording.action.START
+                        : Recording.action.STOP,
+                'streamid': options.streamId
+            })
+            .up();
+
+    logger.log(`Set jibri recording: ${state}`, iq.nodeTree);
+    logger.log(iq.nodeTree);
+    this.connection.sendIQ(
+    iq,
+    result => {
+        logger.log('Result', result);
+
+        const jibri = $(result).find('jibri');
+
+        callback(jibri.attr('state'), jibri.attr('url'));
+    },
+    error => {
+        logger.log('Failed to start recording, error: ', error);
+        errCallback(error);
+    });
+};
 
-            callback(jibri.attr('state'), jibri.attr('url'));
-        },
-        error => {
-            logger.log('Failed to start recording, error: ', error);
-            errCallback(error);
-        });
-    };
+/* eslint-enable max-params */
 
 Recording.prototype.setRecordingJirecon
     = function(state, callback, errCallback) {
         });
     };
 
+/* eslint-disable max-params */
+
 // Sends a COLIBRI message which enables or disables (according to 'state')
 // the recording on the bridge. Waits for the result IQ and calls 'callback'
 // with the new recording state, according to the IQ.
-Recording.prototype.setRecordingColibri
-= function(state, callback, errCallback, options) {
-    const elem = $iq({ to: this.focusMucJid,
-        type: 'set' });
+Recording.prototype.setRecordingColibri = function(
+        state,
+        callback,
+        errCallback,
+        options) {
+    const elem = $iq({
+        to: this.focusMucJid,
+        type: 'set'
+    });
 
     elem.c('conference', {
         xmlns: 'http://jitsi.org/protocol/colibri'
     });
-    elem.c('recording', { state,
-        token: options.token });
+    elem.c('recording', {
+        state,
+        token: options.token
+    });
 
     const self = this;
 
-    this.connection.sendIQ(elem,
+    this.connection.sendIQ(
+        elem,
         result => {
             logger.log('Set recording "', state, '". Result:', result);
             const recordingElem = $(result).find('>conference>recording');
     );
 };
 
-Recording.prototype.setRecording
-= function(state, callback, errCallback, options) {
+/* eslint-enable max-params */
+
+Recording.prototype.setRecording = function(...args) {
     switch (this.type) {
     case Recording.types.JIRECON:
-        this.setRecordingJirecon(state, callback, errCallback, options);
+        this.setRecordingJirecon(...args);
         break;
     case Recording.types.COLIBRI:
-        this.setRecordingColibri(state, callback, errCallback, options);
+        this.setRecordingColibri(...args);
         break;
     case Recording.types.JIBRI:
-        this.setRecordingJibri(state, callback, errCallback, options);
+        this.setRecordingJibri(...args);
         break;
     default: {
         const errmsg = 'Unknown recording type!';

modules/xmpp/strophe.ping.js

         Strophe.addNamespace('PING', 'urn:xmpp:ping');
     }
 
+    /* eslint-disable max-params */
+
     /**
      * Sends "ping" to given <tt>jid</tt>
      * @param jid the JID to which ping request will be sent.
      * @param success callback called on success.
      * @param error callback called on error.
      * @param timeout ms how long are we going to wait for the response. On
-     *        timeout <tt>error<//t> callback is called with undefined error
-     *        argument.
+     * timeout <tt>error<//t> callback is called with undefined error argument.
      */
     ping(jid, success, error, timeout) {
-        const iq = $iq({ type: 'get',
-            to: jid });
+        const iq = $iq({
+            type: 'get',
+            to: jid
+        });
 
         iq.c('ping', { xmlns: Strophe.NS.PING });
         this.connection.sendIQ(iq, success, error, timeout);
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Checks if given <tt>jid</tt> has XEP-0199 ping support.
      * @param jid the JID to be checked for ping support.

modules/xmpp/strophe.rayo.js

         logger.info('Rayo IQ', iq);
     }
 
+    /* eslint-disable max-params */
+
     dial(to, from, roomName, roomPass, focusMucJid) {
         return new Promise((resolve, reject) => {
             if (!focusMucJid) {
                 }).up();
             }
 
-            this.connection.sendIQ(req, result => {
-                logger.info('Dial result ', result);
-
-                // eslint-disable-next-line newline-per-chained-call
-                const resource = $(result).find('ref').attr('uri');
-
-                this.callResource = resource.substr('xmpp:'.length);
-                logger.info(`Received call resource: ${this.callResource}`);
-                resolve();
-            }, error => {
-                logger.info('Dial error ', error);
-                reject(error);
-            });
+            this.connection.sendIQ(
+                req,
+                result => {
+                    logger.info('Dial result ', result);
+
+                    // eslint-disable-next-line newline-per-chained-call
+                    const resource = $(result).find('ref').attr('uri');
+
+                    this.callResource = resource.substr('xmpp:'.length);
+                    logger.info(`Received call resource: ${this.callResource}`);
+                    resolve();
+                },
+                error => {
+                    logger.info('Dial error ', error);
+                    reject(error);
+                });
         });
     }
 
+    /* eslint-enable max-params */
+
     hangup() {
         return new Promise((resolve, reject) => {
             if (!this.callResource) {

modules/xmpp/xmpp.js

         return (this.connection.logger || {}).log || null;
     }
 
-    dial(to, from, roomName, roomPass) {
-        this.connection.rayo.dial(to, from, roomName, roomPass);
+    dial(...args) {
+        this.connection.rayo.dial(...args);
     }
 
     setMute(jid, mute) {