[eslint] no-shadow

.eslintrc.js

         'no-delete-var': 2,
         'no-label-var': 2,
         'no-restricted-globals': 0,
+        'no-shadow': 2,
         'no-shadow-restricted-names': 2,
         'no-undef': 2,
         'no-undef-init': 2,

JitsiMeetJS.js

     let res = null;
     let resName = null;
 
-    Object.keys(Resolutions).forEach(resolution => {
-        const value = Resolutions[resolution];
+    Object.keys(Resolutions).forEach(r => {
+        const value = Resolutions[r];
 
         if (!res || (res.order < value.order && value.order < order)) {
-            resName = resolution;
+            resName = r;
             res = value;
         }
     });

modules/RTC/DataChannels.js

         logger.error('Data Channel Error:', error, dataChannel);
     };
 
-    dataChannel.onmessage = function(event) {
-        const data = event.data;
-
+    dataChannel.onmessage = function({ data }) {
         // JSON
         let obj;
 

modules/RTC/RTCUtils.js

     // do not matter. This fixes situation when we have no devices initially,
     // and then plug in a new one.
     if (rawEnumerateDevicesWithCallback) {
-        rawEnumerateDevicesWithCallback(devices => {
+        rawEnumerateDevicesWithCallback(ds => {
             // We don't fire RTCEvents.DEVICE_LIST_CHANGED for the first time
             // we call enumerateDevices(). This is the initial step.
             if (typeof currentlyAvailableMediaDevices === 'undefined') {
-                currentlyAvailableMediaDevices = devices.slice(0);
-            } else if (compareAvailableMediaDevices(devices)) {
-                onMediaDevicesListChanged(devices);
+                currentlyAvailableMediaDevices = ds.slice(0);
+            } else if (compareAvailableMediaDevices(ds)) {
+                onMediaDevicesListChanged(ds);
             }
 
             window.setTimeout(pollForAvailableMediaDevices,
     initRawEnumerateDevicesWithCallback();
 
     if (rtcUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
-        rawEnumerateDevicesWithCallback(devices => {
-            currentlyAvailableMediaDevices = devices.splice(0);
+        rawEnumerateDevicesWithCallback(ds => {
+            currentlyAvailableMediaDevices = ds.splice(0);
 
             eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
                 currentlyAvailableMediaDevices);
     }
 
     const device = options.devices.splice(0, 1);
-    const devices = [];
 
-    devices.push(device);
     options.deviceGUM[device](
         stream => {
             options.streams = options.streams || {};
             obtainDevices(options);
         },
         error => {
-            Object.keys(options.streams).forEach(device => {
-                rtcUtils.stopMediaStream(options.streams[device]);
-            });
+            Object.keys(options.streams).forEach(
+                d => rtcUtils.stopMediaStream(options.streams[d]));
             logger.error(
                 `failed to obtain ${device} stream - stop`, error);
 
                         this.getUserMediaWithConstraints.bind(this));
                 };
                 const webRTCReadyPromise
-                    = new Promise(resolve => AdapterJS.webRTCReady(resolve));
+                    = new Promise(r => AdapterJS.webRTCReady(r));
 
                 // Resolve or reject depending on whether the Temasys plugin is
                 // installed.
                                 // didn't get corresponding MediaStreamTrack in
                                 // response stream. We don't know the reason why
                                 // this happened, so reject with general error.
+                                // eslint-disable-next-line no-shadow
                                 const devices = [];
 
                                 if (audioDeviceRequested
      * @returns {MediaDeviceInfo} device.
      */
     getEventDataForActiveDevice(device) {
-        const devices = [];
+        const deviceList = [];
         const deviceData = {
             'deviceId': device.deviceId,
             'kind': device.kind,
             'groupId': device.groupId
         };
 
-        devices.push(deviceData);
+        deviceList.push(deviceData);
 
-        return { deviceList: devices };
+        return { deviceList };
     }
 }
 

modules/RTC/ScreenObtainer.js

         }
 
         if (RTCBrowserType.isNWJS()) {
-            obtainDesktopStream = (options, onSuccess, onFailure) => {
+            obtainDesktopStream = (_, onSuccess, onFailure) => {
                 window.JitsiMeetNW.obtainDesktopStream(
                     onSuccess,
                     (error, constraints) => {
                     });
             };
         } else if (RTCBrowserType.isElectron()) {
-            obtainDesktopStream = (options, onSuccess, onFailure) =>
+            obtainDesktopStream = (_, onSuccess, onFailure) =>
                 window.JitsiMeetElectron.obtainDesktopStream(
                     streamId =>
                         onGetStreamResponse({ streamId }, onSuccess, onFailure),

modules/RTC/TraceablePeerConnection.js

 
                 for (let i = 0; i < results.length; ++i) {
                     results[i].names().forEach(name => {
+                        // eslint-disable-next-line no-shadow
                         const id = `${results[i].id}-${name}`;
+                        let s = self.stats[id];
 
-                        if (!self.stats[id]) {
-                            self.stats[id] = {
+                        if (!s) {
+                            self.stats[id] = s = {
                                 startTime: now,
                                 endTime: now,
                                 values: [],
                                 times: []
                             };
                         }
-                        self.stats[id].values.push(results[i].stat(name));
-                        self.stats[id].times.push(now.getTime());
-                        if (self.stats[id].values.length > self.maxstats) {
-                            self.stats[id].values.shift();
-                            self.stats[id].times.shift();
+                        s.values.push(results[i].stat(name));
+                        s.times.push(now.getTime());
+                        if (s.values.length > self.maxstats) {
+                            s.values.shift();
+                            s.times.shift();
                         }
-                        self.stats[id].endTime = now;
+                        s.endTime = now;
                     });
                 }
             });
 
     const remoteSDP = new SDP(this.remoteDescription.sdp);
     const mediaLines
-        = remoteSDP.media.filter(
-            mediaLines => mediaLines.startsWith(`m=${mediaType}`));
+        = remoteSDP.media.filter(mls => mls.startsWith(`m=${mediaType}`));
 
     if (!mediaLines.length) {
         GlobalOnErrorHandler.callErrorHandler(
         return desc;
     }
 
+    // eslint-disable-next-line no-shadow
     const transform = require('sdp-transform');
     const session = transform.parse(desc.sdp);
 

modules/transcription/audioRecorder.js

     const originalStream = trackRecorder.track.getOriginalStream();
     const stream = createEmptyStream();
 
-    originalStream.getAudioTracks().forEach(track => stream.addTrack(track));
+    originalStream.getAudioTracks().forEach(t => stream.addTrack(t));
 
     // Create the MediaRecorder
     trackRecorder.recorder = new MediaRecorder(stream,

modules/xmpp/JingleSessionPC.js

     }
 
     readSsrcInfo(contents) {
-        $(contents).each((idx, content) => {
+        $(contents).each((i1, content) => {
             const ssrcs
                 = $(content).find(
                     'description>'
                         + 'source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
 
-            ssrcs.each((idx, ssrcElement) => {
+            ssrcs.each((i2, ssrcElement) => {
                 const ssrc = ssrcElement.getAttribute('ssrc');
 
                 $(ssrcElement)
                     .find('>ssrc-info[xmlns="http://jitsi.org/jitmeet"]')
-                    .each((idx, ssrcInfoElement) => {
+                    .each((i3, ssrcInfoElement) => {
                         const owner = ssrcInfoElement.getAttribute('owner');
 
                         if (owner && owner.length) {
     _parseSsrcInfoFromSourceAdd(sourceAddElem, currentRemoteSdp) {
         const addSsrcInfo = [];
 
-        $(sourceAddElem).each((idx, content) => {
+        $(sourceAddElem).each((i1, content) => {
             const name = $(content).attr('name');
             let lines = '';
 
                     lines += '\r\n';
                 });
             });
-            currentRemoteSdp.media.forEach((media, idx) => {
+            currentRemoteSdp.media.forEach((media, i2) => {
                 if (!SDPUtil.findLine(media, `a=mid:${name}`)) {
                     return;
                 }
-                if (!addSsrcInfo[idx]) {
-                    addSsrcInfo[idx] = '';
+                if (!addSsrcInfo[i2]) {
+                    addSsrcInfo[i2] = '';
                 }
-                addSsrcInfo[idx] += lines;
+                addSsrcInfo[i2] += lines;
             });
         });
 
     _parseSsrcInfoFromSourceRemove(sourceRemoveElem, currentRemoteSdp) {
         const removeSsrcInfo = [];
 
-        $(sourceRemoveElem).each((idx, content) => {
+        $(sourceRemoveElem).each((i1, content) => {
             const name = $(content).attr('name');
             let lines = '';
 
 
                 ssrcs.push(ssrc);
             });
-            currentRemoteSdp.media.forEach((media, idx) => {
+            currentRemoteSdp.media.forEach((media, i2) => {
                 if (!SDPUtil.findLine(media, `a=mid:${name}`)) {
                     return;
                 }
-                if (!removeSsrcInfo[idx]) {
-                    removeSsrcInfo[idx] = '';
+                if (!removeSsrcInfo[i2]) {
+                    removeSsrcInfo[i2] = '';
                 }
                 ssrcs.forEach(ssrc => {
                     const ssrcLines
                         = SDPUtil.findLines(media, `a=ssrc:${ssrc}`);
 
                     if (ssrcLines.length) {
-                        removeSsrcInfo[idx] += `${ssrcLines.join('\r\n')}\r\n`;
+                        removeSsrcInfo[i2] += `${ssrcLines.join('\r\n')}\r\n`;
                     }
                 });
-                removeSsrcInfo[idx] += lines;
+                removeSsrcInfo[i2] += lines;
             });
         });
 

modules/xmpp/SDP.js

                         if (kv.indexOf(':') === -1) {
                             elem.attrs({ name: kv });
                         } else {
-                            const k = kv.split(':', 2)[0];
+                            const name = kv.split(':', 2)[0];
 
-                            elem.attrs({ name: k });
+                            elem.attrs({ name });
 
                             let v = kv.split(':', 2)[1];
 
                     if (ssrcs.length) {
                         elem.c('ssrc-group', { semantics,
                             xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
-                        ssrcs.forEach(ssrc => elem.c('source', { ssrc }).up());
+                        ssrcs.forEach(s => elem.c('source', { ssrc: s }).up());
                         elem.up();
                     }
                 });
             const contents
                 = $(group)
                     .find('>content')
-                    .map((idx, content) => content.getAttribute('name'))
+                    .map((_, content) => content.getAttribute('name'))
                     .get();
 
             if (contents.length > 0) {

modules/xmpp/recording.js

             if (newState === 'pending') {
                 self.connection.addHandler(iq => {
                     // eslint-disable-next-line newline-per-chained-call
-                    const state = $(iq).find('recording').attr('state');
+                    const s = $(iq).find('recording').attr('state');
 
-                    if (state) {
+                    if (s) {
                         self.state = newState;
-                        callback(state);
+                        callback(s);
                     }
                 }, 'http://jitsi.org/protocol/colibri', 'iq', null, null, null);
             }