[eslint] no-param-reassign

.eslintrc.js

         'no-new-wrappers': 2,
         'no-octal': 2,
         'no-octal-escape': 2,
+        'no-param-reassign': 2,
         'no-proto': 2,
         'no-redeclare': 2,
         'no-return-assign': 2,

JitsiConference.js

  * @param options {object}
  * @param connection {JitsiConnection} overrides this.connection
  */
-JitsiConference.prototype._init = function(options) {
-    if (!options) {
-        options = {};
-    }
-
+JitsiConference.prototype._init = function(options = {}) {
     // Override connection and xmpp properties (Usefull if the connection
     // reloaded)
     if (options.connection) {

JitsiConnection.js

  * @param options {object} connecting options
  * (for example authentications parameters).
  */
-JitsiConnection.prototype.connect = function(options) {
-    if (!options) {
-        options = {};
-    }
-
+JitsiConnection.prototype.connect = function(options = {}) {
     this.xmpp.connect(options.id, options.password);
 };
 

JitsiMeetJS.js

  * @returns {*}
  */
 function addDeviceTypeToAnalyticsEvent(name, options) {
+    let ret;
+
     if (options.devices.indexOf('audio') !== -1) {
-        name += '.audio';
+        ret += '.audio';
     }
     if (options.devices.indexOf('desktop') !== -1) {
-        name += '.desktop';
+        ret += '.desktop';
     }
     if (options.devices.indexOf('video') !== -1) {
         // we have video add resolution
-        name += `.video.${options.resolution}`;
+        ret += `.video.${options.resolution}`;
     }
 
-    return name;
+    return ret;
 }
 
 /**

modules/RTC/JitsiTrack.js

  *          library. That's the case when Temasys plugin is in use.
  */
 JitsiTrack.prototype.attach = function(container) {
+    let c;
+
     if (this.stream) {
-        container = RTCUtils.attachMediaStream(container, this.stream);
+        c = RTCUtils.attachMediaStream(container, this.stream);
     }
-    this.containers.push(container);
-
-    this._maybeFireTrackAttached(container);
-
-    this._attachTTFMTracker(container);
+    this.containers.push(c);
+    this._maybeFireTrackAttached(c);
+    this._attachTTFMTracker(c);
 
-    return container;
+    return c;
 };
 
 /**

modules/RTC/RTCUtils.js

             um,
             success_callback,
             failure_callback,
-            options) {
-        options = options || {};
+            options = {}) {
         const constraints = getConstraints(um, options);
 
         logger.info('Get media constraints', constraints);
      * @param {string} options.micDeviceId
      * @returns {*} Promise object that will receive the new JitsiTracks
      */
-    obtainAudioAndVideoPermissions(options) {
+    obtainAudioAndVideoPermissions(options = {}) {
         const self = this;
 
-        options = options || {};
         const dsOptions = options.desktopSharingExtensionExternalInstallation;
 
 

modules/RTC/ScreenObtainer.js

     init(options, gum) {
         let obtainDesktopStream = null;
 
+        // eslint-disable-next-line no-param-reassign
         this.options = options = options || {};
         gumFunction = gum;
 

modules/RTC/TraceablePeerConnection.js

 };
 
 TraceablePeerConnection.prototype.setLocalDescription
-        = function(description, successCallback, failureCallback) {
-            this.trace(
-                'setLocalDescription::preTransform',
-                dumpSDP(description));
-
-            // if we're running on FF, transform to Plan A first.
-            if (RTCBrowserType.usesUnifiedPlan()) {
-                description = this.interop.toUnifiedPlan(description);
-                this.trace('setLocalDescription::postTransform (Plan A)',
-            dumpSDP(description));
-            }
+    = function(description, successCallback, failureCallback) {
+        let d = description;
 
-            const self = this;
+        this.trace('setLocalDescription::preTransform', dumpSDP(d));
 
-            this.peerconnection.setLocalDescription(description,
-        () => {
-            self.trace('setLocalDescriptionOnSuccess');
-            successCallback();
-        },
-        err => {
-            self.trace('setLocalDescriptionOnFailure', err);
-            self.eventEmitter.emit(
-                RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
-                err, self.peerconnection);
-            failureCallback(err);
+        // if we're running on FF, transform to Plan A first.
+        if (RTCBrowserType.usesUnifiedPlan()) {
+            d = this.interop.toUnifiedPlan(d);
+            this.trace(
+                'setLocalDescription::postTransform (Plan A)',
+                dumpSDP(d));
         }
-    );
-        };
 
-TraceablePeerConnection.prototype.setRemoteDescription
-        = function(description, successCallback, failureCallback) {
-            this.trace(
-                'setRemoteDescription::preTransform',
-                dumpSDP(description));
+        const self = this;
+
+        this.peerconnection.setLocalDescription(
+            d,
+            () => {
+                self.trace('setLocalDescriptionOnSuccess');
+                successCallback();
+            },
+            err => {
+                self.trace('setLocalDescriptionOnFailure', err);
+                self.eventEmitter.emit(
+                    RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
+                    err, self.peerconnection);
+                failureCallback(err);
+            }
+        );
+    };
 
-            // TODO the focus should squeze or explode the remote simulcast
-            description = this.simulcast.mungeRemoteDescription(description);
-            this.trace(
-                'setRemoteDescription::postTransform (simulcast)',
-                dumpSDP(description));
+TraceablePeerConnection.prototype.setRemoteDescription
+    = function(description, successCallback, failureCallback) {
+        this.trace('setRemoteDescription::preTransform', dumpSDP(description));
+
+        // TODO the focus should squeze or explode the remote simulcast
+        // eslint-disable-next-line no-param-reassign
+        description = this.simulcast.mungeRemoteDescription(description);
+        this.trace(
+            'setRemoteDescription::postTransform (simulcast)',
+            dumpSDP(description));
 
-            if (this.options.preferH264) {
-                const parsedSdp = transform.parse(description.sdp);
-                const videoMLine
-                    = parsedSdp.media.find(m => m.type === 'video');
+        if (this.options.preferH264) {
+            const parsedSdp = transform.parse(description.sdp);
+            const videoMLine = parsedSdp.media.find(m => m.type === 'video');
 
-                SDPUtil.preferVideoCodec(videoMLine, 'h264');
-                description.sdp = transform.write(parsedSdp);
-            }
+            SDPUtil.preferVideoCodec(videoMLine, 'h264');
+            description.sdp = transform.write(parsedSdp);
+        }
 
-            // if we're running on FF, transform to Plan A first.
-            if (RTCBrowserType.usesUnifiedPlan()) {
-                description.sdp = this.rtxModifier.stripRtx(description.sdp);
-                this.trace(
+        // if we're running on FF, transform to Plan A first.
+        if (RTCBrowserType.usesUnifiedPlan()) {
+            description.sdp = this.rtxModifier.stripRtx(description.sdp);
+            this.trace(
                     'setRemoteDescription::postTransform (stripRtx)',
                     dumpSDP(description));
-                description = this.interop.toUnifiedPlan(description);
-                this.trace(
-            'setRemoteDescription::postTransform (Plan A)',
-            dumpSDP(description));
-            }
 
-            if (RTCBrowserType.usesPlanB()) {
-                description = normalizePlanB(description);
-            }
-
-            const self = this;
+            // eslint-disable-next-line no-param-reassign
+            description = this.interop.toUnifiedPlan(description);
+            this.trace(
+                    'setRemoteDescription::postTransform (Plan A)',
+                    dumpSDP(description));
+        }
 
-            this.peerconnection.setRemoteDescription(description,
-        () => {
-            self.trace('setRemoteDescriptionOnSuccess');
-            successCallback();
-        },
-        err => {
-            self.trace('setRemoteDescriptionOnFailure', err);
-            self.eventEmitter.emit(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
-                err, self.peerconnection);
-            failureCallback(err);
+        if (RTCBrowserType.usesPlanB()) {
+            // eslint-disable-next-line no-param-reassign
+            description = normalizePlanB(description);
         }
-    );
 
-    /*
-     if (this.statsinterval === null && this.maxstats > 0) {
-     // start gathering stats
-     }
-     */
-        };
+        this.peerconnection.setRemoteDescription(
+            description,
+            () => {
+                this.trace('setRemoteDescriptionOnSuccess');
+                successCallback();
+            },
+            err => {
+                this.trace('setRemoteDescriptionOnFailure', err);
+                this.eventEmitter.emit(
+                    RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
+                    err,
+                    this.peerconnection);
+                failureCallback(err);
+            });
+    };
 
 /**
  * Makes the underlying TraceablePeerConnection generate new SSRC for
 };
 
 TraceablePeerConnection.prototype.createAnswer
-        = function(successCallback, failureCallback, constraints) {
-            this.trace('createAnswer', JSON.stringify(constraints, null, ' '));
-            this.peerconnection.createAnswer(
+    = function(successCallback, failureCallback, constraints) {
+        this.trace('createAnswer', JSON.stringify(constraints, null, ' '));
+        this.peerconnection.createAnswer(
         answer => {
             try {
                 this.trace(
 
                 // if we're running on FF, transform to Plan A first.
                 if (RTCBrowserType.usesUnifiedPlan()) {
+                    // eslint-disable-next-line no-param-reassign
                     answer = this.interop.toPlanB(answer);
                     this.trace('createAnswerOnSuccess::postTransform (Plan B)',
                         dumpSDP(answer));
 
                 // Add simulcast streams if simulcast is enabled
                 if (!this.options.disableSimulcast
-                    && this.simulcast.isSupported()) {
+                        && this.simulcast.isSupported()) {
+
+                    // eslint-disable-next-line no-param-reassign
                     answer = this.simulcast.mungeLocalDescription(answer);
                     this.trace(
                         'createAnswerOnSuccess::postTransform (simulcast)',
                 this.peerconnection);
             failureCallback(err);
         },
-        constraints
-    );
-        };
+        constraints);
+    };
 
 TraceablePeerConnection.prototype.addIceCandidate
 
     if (RTCBrowserType.isFirefox()
             || RTCBrowserType.isTemasysPluginUsed()
             || RTCBrowserType.isReactNative()) {
-        if (!errback) {
-            errback = function() {
+        this.peerconnection.getStats(
+            null,
+            callback,
+            errback || (() => {
                 // Making sure that getStats won't fail if error callback is
                 // not passed.
-            };
-        }
-        this.peerconnection.getStats(null, callback, errback);
+            }));
     } else {
         this.peerconnection.getStats(callback);
     }

modules/statistics/CallStats.js

  * @private
  */
 CallStats._reportError = function(type, e, pc) {
-    if (!e) {
+    let error = e;
+
+    if (!error) {
         logger.warn('No error is passed!');
-        e = new Error('Unknown error');
+        error = new Error('Unknown error');
     }
     if (CallStats.initialized) {
-        callStats.reportError(pc, this.confID, type, e);
+        callStats.reportError(pc, this.confID, type, error);
     } else {
         CallStats.reportsQueue.push({
             type: reportType.ERROR,
-            data: { type,
-                error: e,
-                pc }
+            data: {
+                error,
+                pc,
+                type
+            }
         });
         CallStats._checkInitialize();
     }

modules/util/RandomUtil.js

     randomHexString(len) {
         let ret = '';
 
-        while (len--) {
+        while (len--) { // eslint-disable-line no-param-reassign
             ret += this.randomHexDigit();
         }
 

modules/util/ScriptUtil.js

                     = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
 
                 if (scriptSrc && baseScriptSrc) {
+                    // eslint-disable-next-line no-param-reassign
                     src = baseScriptSrc + src;
                 }
             }

modules/xmpp/JingleSessionPC.js

         const remoteSdp = new SDP(this.peerconnection.remoteDescription.sdp);
 
         removeSsrcInfo.forEach((lines, idx) => {
+            // eslint-disable-next-line no-param-reassign
             lines = lines.split('\r\n');
             lines.pop(); // remove empty last element;
             lines.forEach(line => {

modules/xmpp/SDP.js

         tmp.xmlns = 'urn:xmpp:jingle:apps:dtls:0';
         elem.c('fingerprint').t(tmp.fingerprint);
         delete tmp.fingerprint;
+
+        // eslint-disable-next-line no-param-reassign
         line
             = SDPUtil.find_line(
                 self.media[mediaindex],

modules/xmpp/SDPUtil.js

         //      <candidate component=... foundation=... generation=... id=...
         // ip=... network=... port=... priority=... protocol=... type=.../>
         if (line.indexOf('candidate:') === 0) {
+            // eslint-disable-next-line no-param-reassign
             line = `a=${line}`;
         } else if (line.substring(0, 12) != 'a=candidate:') {
             logger.log(
             return null;
         }
         if (line.substring(line.length - 2) == '\r\n') { // chomp it
+            // eslint-disable-next-line no-param-reassign
             line = line.substring(0, line.length - 2);
         }
         const candidate = {};

modules/xmpp/recording.js

-/* global $, $iq */
+  /* global $, $iq */
 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
 };
 
 Recording.prototype.setRecordingJibri
-    = function(state, callback, errCallback, options) {
+    = function(state, callback, errCallback, options = {}) {
 
         if (state == this.state) {
             errCallback(JitsiRecorderErrors.INVALID_STATE);
         }
-        options = options || {};
 
-    // FIXME jibri does not accept IQ without 'url' attribute set ?
+        // FIXME jibri does not accept IQ without 'url' attribute set ?
         const iq
             = $iq({ to: this.focusMucJid,
                 type: 'set' })

modules/xmpp/strophe.jingle.js

                 const iceservers = [];
 
                 $(res).find('>services>service').each((idx, el) => {
+                    // eslint-disable-next-line no-param-reassign
                     el = $(el);
                     const dict = {};
                     const type = el.attr('type');

modules/xmpp/strophe.util.js

         if (typeof msg === 'string'
                 && msg.indexOf('Request ') !== -1
                 && msg.indexOf('timed out (secondary), restarting') !== -1) {
+            // eslint-disable-next-line no-param-reassign
             level = Strophe.LogLevel.WARN;
         }
 
             break;
         case Strophe.LogLevel.ERROR:
         case Strophe.LogLevel.FATAL:
+            // eslint-disable-next-line no-param-reassign
             msg = `Strophe: ${msg}`;
             GlobalOnErrorHandler.callErrorHandler(new Error(msg));
             logger.error(msg);

modules/xmpp/xmpp.js

 function createConnection(token, bosh = '/http-bind') {
     // Append token as URL param
     if (token) {
+        // eslint-disable-next-line no-param-reassign
         bosh += `${bosh.indexOf('?') == -1 ? '?' : '&'}token=${token}`;
     }
 
                         || this.options.token)) {
                 configDomain = this.options.hosts.domain;
             }
+
+            // eslint-disable-next-line no-param-reassign
             jid = configDomain || window.location.hostname;
         }