[eslint] prefer-arrow-callback

.eslintrc.js

             'always',
             { 'avoidQuotes': true }
         ],
+        'prefer-arrow-callback': [ 'error', { 'allowNamedFunctions': true } ],
         'prefer-const': 2,
         'prefer-reflect': 0,
         'prefer-rest-params': 2,

JitsiConference.js

  * @returns {Promise}
  */
 JitsiConference.prototype.getExternalAuthUrl = function(urlForPopup) {
-    return new Promise(function(resolve, reject) {
+    return new Promise((resolve, reject) => {
         if (!this.isExternalAuthEnabled()) {
             reject();
             return;
         } else {
             this.room.moderator.getLoginUrl(resolve, reject);
         }
-    }.bind(this));
+    });
 };
 
 /**
             && newTrack.videoType !== VideoType.DESKTOP)) {
         // Report active device to statistics
         const devices = RTC.getCurrentlyAvailableMediaDevices();
-        const device = devices.find(function(d) {
-            return d.kind === `${newTrack.getTrack().kind}input`
-                && d.label === newTrack.getTrack().label;
-        });
+        const device
+            = devices.find(
+                d =>
+                    d.kind === `${newTrack.getTrack().kind}input`
+                        && d.label === newTrack.getTrack().label);
         if (device) {
             Statistics.sendActiveDeviceListEvent(
                 RTC.getEventDataForActiveDevice(device));
     }
 
     const conference = this;
-    return new Promise(function(resolve, reject) {
-        conference.room.lockRoom(password || '', function() {
-            resolve();
-        }, function(err) {
-            reject(err);
-        }, function() {
-            reject(JitsiConferenceErrors.PASSWORD_NOT_SUPPORTED);
-        });
+    return new Promise((resolve, reject) => {
+        conference.room.lockRoom(
+            password || '',
+            () => resolve(),
+            err => reject(err),
+            () => reject(JitsiConferenceErrors.PASSWORD_NOT_SUPPORTED));
     });
 };
 
 
     const removedTracks = this.rtc.removeRemoteTracks(id);
 
-    removedTracks.forEach(function(track) {
-        this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
-    }.bind(this));
+    removedTracks.forEach(
+        track =>
+            this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track));
 
     // there can be no participant in case the member that left is focus
     if (participant) {
     const emitter = this.eventEmitter;
     track.addEventListener(
         JitsiTrackEvents.TRACK_MUTE_CHANGED,
-        function() {
-            emitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track);
-        }
-    );
+        () => emitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track));
     track.addEventListener(
         JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-        function(audioLevel) {
+        audioLevel => {
             emitter.emit(
                 JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
                 id,
         jingleSession.terminate(
             'security-error', 'Only focus can start new sessions',
             null /* success callback => we don't care */,
-            function(error) {
+            error => {
                 logger.warn(
-                    'An error occurred while trying to terminate'
-                        + ' invalid Jingle session', error);
+                    'An error occurred while trying to terminate invalid Jingle'
+                        + ' session',
+                    error);
             });
 
         return;
 
     this.rtc.initializeDataChannels(jingleSession.peerconnection);
     // Add local Tracks to the ChatRoom
-    this.getLocalTracks().forEach(function(localTrack) {
+    this.getLocalTracks().forEach(localTrack => {
         let ssrcInfo = null;
         /**
          * We don't do this for Firefox because, on Firefox, we keep the
             GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(e);
         }
-    }.bind(this));
+    });
     // Generate the 'recvonly' SSRC in case there are no video tracks
     if (!this.getLocalTracks(MediaType.VIDEO).length) {
         jingleSession.generateRecvonlySsrc();
     }
 
     jingleSession.acceptOffer(jingleOffer, null,
-        function(error) {
+        error => {
             GlobalOnErrorHandler.callErrorHandler(error);
             logger.error(
                 'Failed to accept incoming Jingle session', error);
     // will learn what their SSRC from the new PeerConnection which will be
     // created on incoming call event.
     const self = this;
-    this.getLocalTracks().forEach(function(localTrack) {
+    this.getLocalTracks().forEach(localTrack => {
         // Reset SSRC as it will no longer be valid
         localTrack._setSSRC(null);
         // Bind the handler to fetch new SSRC, it will un register itself once
  */
 JitsiConference.prototype.toggleRecording = function(options) {
     if (this.room) {
-        return this.room.toggleRecording(options, function(status, error) {
+        return this.room.toggleRecording(options, (status, error) => {
             this.eventEmitter.emit(
                 JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
-        }.bind(this));
+        });
     }
     this.eventEmitter.emit(
         JitsiConferenceEvents.RECORDER_STATE_CHANGED, 'error',
     if (this.room) {
         return this.room.dial(number);
     }
-    return new Promise(function(resolve, reject) {
+    return new Promise((resolve, reject) => {
         reject(new Error('The conference is not created yet!'));
     });
 };
     if (this.room) {
         return this.room.hangup();
     }
-    return new Promise(function(resolve, reject) {
+    return new Promise((resolve, reject) => {
         reject(new Error('The conference is not created yet!'));
     });
 };
         return this.jingleSession.getIceConnectionState();
     }
     return null;
-
 };
 
 /**

JitsiConferenceEventManager.js

 
     // Listeners related to the conference only
     conference.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED,
-        function(track) {
+        track => {
             if(!track.isLocal() || !conference.statistics) {
                 return;
             }
     this.chatRoomForwarder = new EventEmitterForwarder(chatRoom,
         this.conference.eventEmitter);
 
-    chatRoom.addListener(XMPPEvents.ICE_RESTARTING, function() {
+    chatRoom.addListener(XMPPEvents.ICE_RESTARTING, () => {
         // All data channels have to be closed, before ICE restart
         // otherwise Chrome will not trigger "opened" event for the channel
         // established with the new bridge
     });
 
     chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
-        function(value) {
+        value => {
             // set isMutedByFocus when setAudioMute Promise ends
             conference.rtc.setAudioMute(value).then(
-                function() {
+                () => {
                     conference.isMutedByFocus = true;
                 },
-                function() {
+                () =>
                     logger.warn(
-                        'Error while audio muting due to focus request');
-                });
+                        'Error while audio muting due to focus request'));
         }
     );
 
         JitsiConferenceErrors.GRACEFUL_SHUTDOWN);
 
     chatRoom.addListener(XMPPEvents.JINGLE_FATAL_ERROR,
-        function(session, error) {
+        (session, error) => {
             conference.eventEmitter.emit(
                 JitsiConferenceEvents.CONFERENCE_FAILED,
                 JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
         });
 
     chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
-        function() {
+        () => {
             chatRoom.eventEmitter.emit(
                 XMPPEvents.CONFERENCE_SETUP_FAILED,
                 new Error('ICE fail'));
         JitsiConferenceErrors.FOCUS_DISCONNECTED);
 
     chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
-        function() {
+        () => {
             Statistics.analytics.sendEvent('conference.focusLeft');
             conference.eventEmitter.emit(
                 JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.SETUP_FAILED);
 
-    chatRoom.setParticipantPropertyListener(function(node, from) {
+    chatRoom.setParticipantPropertyListener((node, from) => {
         const participant = conference.getParticipantById(from);
         if (!participant) {
             return;
     this.chatRoomForwarder.forward(XMPPEvents.KICKED,
         JitsiConferenceEvents.KICKED);
     chatRoom.addListener(XMPPEvents.KICKED,
-        function() {
+        () => {
             conference.room = null;
             conference.leave();
         });
     chatRoom.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
         conference.onDisplayNameChanged.bind(conference));
 
-    chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function(role) {
+    chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, role => {
         conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED,
             conference.myUserId(), role);
 
         // log all events for the recorder operated by the moderator
         if (conference.statistics && conference.isModerator()) {
             conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
-                function(status, error) {
+                (status, error) => {
                     const logObject = {
                         id: 'recorder_status',
                         status
         conference.onUserRoleChanged.bind(conference));
 
     chatRoom.addListener(AuthenticationEvents.IDENTITY_UPDATED,
-        function(authEnabled, authIdentity) {
+        (authEnabled, authIdentity) => {
             conference.authEnabled = authEnabled;
             conference.authIdentity = authIdentity;
             conference.eventEmitter.emit(
         });
 
     chatRoom.addListener(XMPPEvents.MESSAGE_RECEIVED,
-        function(jid, displayName, txt, myJid, ts) {
+        (jid, displayName, txt, myJid, ts) => {
             const id = Strophe.getResourceFromJid(jid);
             conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED,
                 id, txt, ts);
         });
 
     chatRoom.addListener(XMPPEvents.PRESENCE_STATUS,
-        function(jid, status) {
+        (jid, status) => {
             const id = Strophe.getResourceFromJid(jid);
             const participant = conference.getParticipantById(id);
             if (!participant || participant._status === status) {
         });
 
     conference.room.addListener(XMPPEvents.LOCAL_UFRAG_CHANGED,
-        function(ufrag) {
+        ufrag => {
             Statistics.sendLog(
                 JSON.stringify({id: 'local_ufrag', value: ufrag}));
         });
     conference.room.addListener(XMPPEvents.REMOTE_UFRAG_CHANGED,
-        function(ufrag) {
+        ufrag => {
             Statistics.sendLog(
                 JSON.stringify({id: 'remote_ufrag', value: ufrag}));
         });
 
-    chatRoom.addPresenceListener('startmuted', function(data, from) {
+    chatRoom.addPresenceListener('startmuted', (data, from) => {
         let isModerator = false;
         if (conference.myUserId() === from && conference.isModerator()) {
             isModerator = true;
         }
     });
 
-    chatRoom.addPresenceListener('videomuted', function(values, from) {
+    chatRoom.addPresenceListener('videomuted', (values, from) => {
         conference.rtc.handleRemoteTrackMute(MediaType.VIDEO,
             values.value == 'true', from);
     });
 
-    chatRoom.addPresenceListener('audiomuted', function(values, from) {
+    chatRoom.addPresenceListener('audiomuted', (values, from) => {
         conference.rtc.handleRemoteTrackMute(MediaType.AUDIO,
             values.value == 'true', from);
     });
 
-    chatRoom.addPresenceListener('videoType', function(data, from) {
+    chatRoom.addPresenceListener('videoType', (data, from) => {
         conference.rtc.handleRemoteTrackVideoTypeChanged(data.value, from);
     });
 
-    chatRoom.addPresenceListener('devices', function(data, from) {
+    chatRoom.addPresenceListener('devices', (data, from) => {
         let isAudioAvailable = false;
         let isVideoAvailable = false;
-        data.children.forEach(function(config) {
+        data.children.forEach(config => {
             if (config.tagName === 'audio') {
                 isAudioAvailable = config.value === 'true';
             }
     if(conference.statistics) {
         // FIXME ICE related events should end up in RTCEvents eventually
         chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
-            function(pc) {
+            pc => {
                 conference.statistics.sendIceConnectionFailedEvent(pc);
             });
         chatRoom.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
-            function(e, pc) {
+            (e, pc) => {
                 conference.statistics.sendAddIceCandidateFailed(e, pc);
             });
     }
         conference.onRemoteTrackRemoved.bind(conference));
 
     rtc.addListener(RTCEvents.DOMINANT_SPEAKER_CHANGED,
-        function(id) {
+        id => {
             if(conference.lastDominantSpeaker !== id && conference.room) {
                 conference.lastDominantSpeaker = id;
                 conference.eventEmitter.emit(
             }
         });
 
-    rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, function() {
+    rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, () => {
         const now = window.performance.now();
         logger.log('(TIME) data channel opened ', now);
         conference.room.connectionTimes['data.channel.opened'] = now;
     this.rtcForwarder.forward(RTCEvents.LASTN_ENDPOINT_CHANGED,
         JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED);
 
-    rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED,
-        function(devices) {
-            conference.room.updateDeviceAvailability(devices);
-        });
+    rtc.addListener(
+        RTCEvents.AVAILABLE_DEVICES_CHANGED,
+        devices => conference.room.updateDeviceAvailability(devices));
 
     rtc.addListener(RTCEvents.ENDPOINT_MESSAGE_RECEIVED,
-        function(from, payload) {
+        (from, payload) => {
             const participant = conference.getParticipantById(from);
             if (participant) {
                 conference.eventEmitter.emit(
         XMPPEvents.CALL_ENDED, conference.onCallEnded.bind(conference));
 
     conference.xmpp.addListener(XMPPEvents.START_MUTED_FROM_FOCUS,
-        function(audioMuted, videoMuted) {
+        (audioMuted, videoMuted) => {
             conference.startAudioMuted = audioMuted;
             conference.startVideoMuted = videoMuted;
 
             // mute existing local tracks because this is initial mute from
             // Jicofo
-            conference.getLocalTracks().forEach(function(track) {
+            conference.getLocalTracks().forEach(track => {
                 switch (track.getType()) {
                 case MediaType.AUDIO:
                     conference.startAudioMuted && track.mute();
         return;
     }
 
-    conference.statistics.addAudioLevelListener(function(ssrc, level) {
+    conference.statistics.addAudioLevelListener((ssrc, level) => {
         const resource = conference.rtc.getResourceBySSRC(ssrc);
         if (!resource) {
             return;
         conference.rtc.setAudioLevel(resource, level);
     });
     // Forward the "before stats disposed" event
-    conference.statistics.addBeforeDisposedListener(function() {
+    conference.statistics.addBeforeDisposedListener(() => {
         conference.eventEmitter.emit(
             JitsiConferenceEvents.BEFORE_STATISTICS_DISPOSED);
     });
-    conference.statistics.addConnectionStatsListener(function(stats) {
+    conference.statistics.addConnectionStatsListener(stats => {
         const ssrc2resolution = stats.resolution;
 
         const id2resolution = {};
 
         // preprocess resolutions: group by user id, skip incorrect
         // resolutions etc.
-        Object.keys(ssrc2resolution).forEach(function(ssrc) {
+        Object.keys(ssrc2resolution).forEach(ssrc => {
             const resolution = ssrc2resolution[ssrc];
 
             if (!resolution.width || !resolution.height
             JitsiConferenceEvents.CONNECTION_STATS, stats);
     });
 
-    conference.statistics.addByteSentStatsListener(function(stats) {
-        conference.getLocalTracks(MediaType.AUDIO).forEach(function(track) {
+    conference.statistics.addByteSentStatsListener(stats => {
+        conference.getLocalTracks(MediaType.AUDIO).forEach(track => {
             const ssrc = track.getSSRC();
             if (!ssrc || !stats.hasOwnProperty(ssrc)) {
                 return;

JitsiConnection.js

     this.xmpp = new XMPP(options, token);
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
-        function(errType, msg) {
+        (errType, msg) => {
             // sends analytics and callstats event
             Statistics.sendEventToAll(`connection.failed.${errType}`,
                 {label: msg});
         });
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-        function(msg) {
+        msg => {
             // we can see disconnects from normal tab closing of the browser
             // and then there are no msgs, but we want to log only disconnects
             // when there is real error

JitsiMediaDevices.js

 
 const eventEmitter = new EventEmitter();
 
-RTC.addListener(RTCEvents.DEVICE_LIST_CHANGED,
-    function(devices) {
-        eventEmitter.emit(JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED, devices);
-    });
+RTC.addListener(
+    RTCEvents.DEVICE_LIST_CHANGED,
+    devices =>
+        eventEmitter.emit(
+            JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED,
+            devices));
 
 RTC.addListener(RTCEvents.DEVICE_LIST_AVAILABLE,
-    function(devices) {
+    devices => {
         // log output device
         logOutputDevice(
             JitsiMediaDevices.getAudioOutputDevice(),
  * @param devices list of devices
  */
 function logOutputDevice(deviceID, devices) {
-    const device = devices.find(function(d) {
-        return d.kind === 'audiooutput' && d.deviceId === deviceID;
-    });
+    const device
+        = devices.find(
+            d => d.kind === 'audiooutput' && d.deviceId === deviceID);
 
     if (device) {
         Statistics.sendActiveDeviceListEvent(

JitsiMeetJS.js

         let promiseFulfilled = false;
 
         if (firePermissionPromptIsShownEvent === true) {
-            window.setTimeout(function() {
+            window.setTimeout(() => {
                 if (!promiseFulfilled) {
                     JitsiMediaDevices.emitEvent(
                         JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
             = window.performance.now();
 
         return RTC.obtainAudioAndVideoPermissions(options || {})
-            .then(function(tracks) {
+            .then(tracks => {
                 promiseFulfilled = true;
 
                 window.connectionTimes['obtainPermissions.end']
                                 track.setAudioLevel.bind(track));
                             track.addEventListener(
                                 JitsiTrackEvents.LOCAL_TRACK_STOPPED,
-                                function() {
+                                () => {
                                     Statistics.stopLocalStats(mStream);
                                 });
                         }
                 }
 
                 return tracks;
-            }).catch(function(error) {
+            }).catch(error => {
                 promiseFulfilled = true;
 
                 if(error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {

JitsiParticipant.js

      * {@link JitsiTrack.isWebRTCTrackMuted}.
      */
     hasAnyVideoTrackWebRTCMuted() {
-        return this.getTracks().some(function(jitsiTrack) {
-            return jitsiTrack.getType() === MediaType.VIDEO
-                && jitsiTrack.isWebRTCTrackMuted();
-        });
+        return (
+            this.getTracks().some(
+                jitsiTrack =>
+                    jitsiTrack.getType() === MediaType.VIDEO
+                        && jitsiTrack.isWebRTCTrackMuted()));
     }
 
     /**

doc/example/example.js

 function onLocalTracks(tracks) {
     localTracks = tracks;
     for(let i = 0; i < localTracks.length; i++) {
-        localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
-            function(audioLevel) {
-                console.log(`Audio Level local: ${audioLevel}`);
-            });
-        localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
-            function() {
-                console.log('local track muted');
-            });
-        localTracks[i].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
-            function() {
-                console.log('local track stoped');
-            });
-        localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_OUTPUT_CHANGED,
-            function(deviceId) {
-                console.log(`track audio output device was changed to ${deviceId}`);
-            });
+        localTracks[i].addEventListener(
+            JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
+            audioLevel => console.log(`Audio Level local: ${audioLevel}`));
+        localTracks[i].addEventListener(
+            JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
+            () => console.log('local track muted'));
+        localTracks[i].addEventListener(
+            JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
+            () => console.log('local track stoped'));
+        localTracks[i].addEventListener(
+            JitsiMeetJS.events.track.TRACK_AUDIO_OUTPUT_CHANGED,
+            deviceId =>
+                console.log(
+                    `track audio output device was changed to ${deviceId}`));
         if(localTracks[i].getType() == 'video') {
             $('body').append(`<video autoplay='1' id='localVideo${i}' />`);
             localTracks[i].attach($(`#localVideo${i}`)[0]);
         remoteTracks[participant] = [];
     }
     const idx = remoteTracks[participant].push(track);
-    track.addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
-        function(audioLevel) {
-            console.log(`Audio Level remote: ${audioLevel}`);
-        });
-    track.addEventListener(JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
-        function() {
-            console.log('remote track muted');
-        });
-    track.addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
-        function() {
-            console.log('remote track stoped');
-        });
+    track.addEventListener(
+        JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
+        audioLevel => console.log(`Audio Level remote: ${audioLevel}`));
+    track.addEventListener(
+        JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
+        () => console.log('remote track muted'));
+    track.addEventListener(
+        JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
+        () => console.log('remote track stoped'));
     track.addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_OUTPUT_CHANGED,
-        function(deviceId) {
-            console.log(`track audio output device was changed to ${deviceId}`);
-        });
+        deviceId =>
+            console.log(
+                `track audio output device was changed to ${deviceId}`));
     const id = participant + track.getType() + idx;
     if(track.getType() == 'video') {
         $('body').append(`<video autoplay='1' id='${participant}video${idx}' />`);
 function onConnectionSuccess() {
     room = connection.initJitsiConference('conference', confOptions);
     room.on(JitsiMeetJS.events.conference.TRACK_ADDED, onRemoteTrack);
-    room.on(JitsiMeetJS.events.conference.TRACK_REMOVED, function(track) {
+    room.on(JitsiMeetJS.events.conference.TRACK_REMOVED, track => {
         console.log(`track removed!!!${track}`);
     });
     room.on(JitsiMeetJS.events.conference.CONFERENCE_JOINED, onConferenceJoined);
-    room.on(JitsiMeetJS.events.conference.USER_JOINED, function(id) {
+    room.on(JitsiMeetJS.events.conference.USER_JOINED, id => {
         console.log('user join'); remoteTracks[id] = [];
     });
     room.on(JitsiMeetJS.events.conference.USER_LEFT, onUserLeft);
-    room.on(JitsiMeetJS.events.conference.TRACK_MUTE_CHANGED, function(track) {
+    room.on(JitsiMeetJS.events.conference.TRACK_MUTE_CHANGED, track => {
         console.log(`${track.getType()} - ${track.isMuted()}`);
     });
-    room.on(JitsiMeetJS.events.conference.DISPLAY_NAME_CHANGED, function(userID, displayName) {
+    room.on(JitsiMeetJS.events.conference.DISPLAY_NAME_CHANGED, (userID, displayName) => {
         console.log(`${userID} - ${displayName}`);
     });
     room.on(JitsiMeetJS.events.conference.TRACK_AUDIO_LEVEL_CHANGED,
-      function(userID, audioLevel) {
+      (userID, audioLevel) => {
           console.log(`${userID} - ${audioLevel}`);
       });
-    room.on(JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED, function() {
+    room.on(JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED, () => {
         console.log(`${room.isRecordingSupported()} - ${
              room.getRecordingState()} - ${
              room.getRecordingURL()}`);
     });
-    room.on(JitsiMeetJS.events.conference.PHONE_NUMBER_CHANGED, function() {
+    room.on(JitsiMeetJS.events.conference.PHONE_NUMBER_CHANGED, () => {
         console.log(
             `${room.getPhoneNumber()} - ${
              room.getPhonePin()}`);
         localTracks.pop();
     }
     JitsiMeetJS.createLocalTracks({devices: isVideo ? ['video'] : ['desktop']})
-        .then(function(tracks) {
+        .then(tracks => {
             localTracks.push(tracks[0]);
             localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
-                function() {
+                () => {
                     console.log('local track muted');
                 });
             localTracks[1].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
-                function() {
+                () => {
                     console.log('local track stoped');
                 });
             localTracks[1].attach($('#localVideo1')[0]);
             room.addTrack(localTracks[1]);
-        }).catch(function(error) {
+        }).catch(error => {
             console.log(error);
         });
 }
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
 };
-JitsiMeetJS.init(initOptions).then(function() {
+JitsiMeetJS.init(initOptions).then(() => {
     connection = new JitsiMeetJS.JitsiConnection(null, null, options);
 
     connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, onConnectionSuccess);
 
     connection.connect();
     JitsiMeetJS.createLocalTracks({devices: ['audio', 'video']})
-        .then(onLocalTracks).catch(function(error) {
+        .then(onLocalTracks).catch(error => {
             throw error;
         });
-}).catch(function(error) {
+}).catch(error => {
     console.log(error);
 });
 
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
-    JitsiMeetJS.mediaDevices.enumerateDevices(function(devices) {
-        const audioOutputDevices = devices.filter(function(d) {
-            return d.kind === 'audiooutput';
-        });
+    JitsiMeetJS.mediaDevices.enumerateDevices(devices => {
+        const audioOutputDevices = devices.filter(d => d.kind === 'audiooutput');
 
         if (audioOutputDevices.length > 1) {
             $('#audioOutputSelect').html(
-                audioOutputDevices.map(function(d) {
-                    return `<option value="${d.deviceId}">${d.label}</option>`;
-                }).join('\n')
+                audioOutputDevices.map(d => `<option value="${d.deviceId}">${d.label}</option>`).join('\n')
             );
 
             $('#audioOutputSelectWrapper').show();

modules/RTC/DataChannels.js

  * Closes all currently opened data channels.
  */
 DataChannels.prototype.closeAllChannels = function() {
-    this._dataChannels.forEach(function(dc) {
+    this._dataChannels.forEach(dc => {
         // the DC will be removed from the array on 'onclose' event
         dc.close();
     });
  * or Error with "No opened data channels found!" message.
  */
 DataChannels.prototype.send = function(jsonObject) {
-    if(!this._some(function(dataChannel) {
+    if(!this._some(dataChannel => {
         if (dataChannel.readyState == 'open') {
             dataChannel.send(JSON.stringify(jsonObject));
             return true;

modules/RTC/JitsiLocalTrack.js

 
     JitsiTrack.call(this,
         null /* RTC */, stream, track,
-        function() {
+        () => {
             if(!this.dontFireRemoveEvent) {
                 this.eventEmitter.emit(
                     JitsiTrackEvents.LOCAL_TRACK_STOPPED);
             }
             this.dontFireRemoveEvent = false;
-        }.bind(this) /* inactiveHandler */,
+        } /* inactiveHandler */,
         mediaType, videoType, null /* ssrc */);
     this.dontFireRemoveEvent = false;
     this.resolution = resolution;
         // device ID "".
         if (typeof self.getTrack().readyState === 'undefined'
             && typeof self._realDeviceId !== 'undefined'
-            && !devices.find(function(d) {
-                return d.deviceId === self._realDeviceId;
-            })) {
+            && !devices.find(d => d.deviceId === self._realDeviceId)) {
             self._trackEnded = true;
         }
     };
     track.inMuteOrUnmuteProgress = true;
 
     return track._setMute(mute)
-        .then(function() {
+        .then(() => {
             track.inMuteOrUnmuteProgress = false;
         })
-        .catch(function(status) {
+        .catch(status => {
             track.inMuteOrUnmuteProgress = false;
             throw status;
         });
             }
 
             promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
-                .then(function(streamsInfo) {
+                .then(streamsInfo => {
                     const mediaType = self.getType();
-                    const streamInfo = streamsInfo.find(function(info) {
-                        return info.mediaType === mediaType;
-                    });
+                    const streamInfo = streamsInfo.find(info => info.mediaType === mediaType);
 
                     if(!streamInfo) {
                         throw new JitsiTrackError(
                         }
                     }
 
-                    self.containers = self.containers.map(function(cont) {
-                        return RTCUtils.attachMediaStream(cont, self.stream);
-                    });
+                    self.containers = self.containers.map(cont => RTCUtils.attachMediaStream(cont, self.stream));
 
                     return self._addStreamToConferenceAsUnmute();
                 });
     }
 
     return promise
-        .then(function() {
-            return self._sendMuteStatus(mute);
-        })
+        .then(() => self._sendMuteStatus(mute))
         .then(function() {
             self.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
         });
     }
 
     return promise
-        .then(function() {
-            return JitsiTrack.prototype.dispose.call(self); // super.dispose();
-        });
+        .then(() => JitsiTrack.prototype.dispose.call(self) // super.dispose();
+        );
 };
 
 /**
     const iceConnectionState
         = this.conference ? this.conference.getConnectionState() : null;
     if(this._testByteSent && 'connected' === iceConnectionState) {
-        setTimeout(function() {
+        setTimeout(() => {
             if(this._bytesSent <= 0) {
                 // we are not receiving anything from the microphone
                 this._fireNoDataFromSourceEvent();
             }
-        }.bind(this), 3000);
+        }, 3000);
         this._testByteSent = false;
     }
 };

modules/RTC/JitsiRemoteTrack.js

     // 2. It does mix MediaStream('inactive') with MediaStreamTrack events
     // 3. Allowing to bind more than one event handler requires too much
     //    refactoring around camera issues detection.
-    this.track.addEventListener('mute', function() {
+    this.track.addEventListener('mute', () => {
 
         logger.debug(
             `"onmute" event(${Date.now()}): `,
             this.getParticipantId(), this.getType(), this.getSSRC());
 
         this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_MUTE, this);
-    }.bind(this));
+    });
 
     // Bind 'onunmute'
-    this.track.addEventListener('unmute', function() {
+    this.track.addEventListener('unmute', () => {
 
         logger.debug(
             `"onunmute" event(${Date.now()}): `,
             this.getParticipantId(), this.getType(), this.getSSRC());
 
         this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_UNMUTE, this);
-    }.bind(this));
+    });
 };
 
 /**

modules/RTC/JitsiTrack.js

         }
         addMediaStreamInactiveHandler(this.stream, handler);
     } else if(trackHandler2Prop.hasOwnProperty(type)) {
-        this.stream.getVideoTracks().forEach(function(track) {
+        this.stream.getVideoTracks().forEach(track => {
             track[trackHandler2Prop[type]] = handler;
         }, this);
     }
         return Promise.resolve();
     }
 
-    return Promise.all(this.containers.map(function(element) {
-        return element.setSinkId(audioOutputDeviceId)
-            .catch(function(error) {
+    return Promise.all(this.containers.map(element => element.setSinkId(audioOutputDeviceId)
+            .catch(error => {
                 logger.warn(
                     'Failed to change audio output device on element. Default'
                     + ' or previously set audio output device will be used.',
                     element, error);
                 throw error;
-            });
-    }))
-    .then(function() {
+            })))
+    .then(() => {
         self.eventEmitter.emit(JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED,
             audioOutputDeviceId);
     });

modules/RTC/RTC.js

 function createLocalTracks(tracksInfo, options) {
     const newTracks = [];
     let deviceId = null;
-    tracksInfo.forEach(function(trackInfo) {
+    tracksInfo.forEach(trackInfo => {
         if (trackInfo.mediaType === MediaType.AUDIO) {
             deviceId = options.micDeviceId;
         } else if (trackInfo.videoType === VideoType.CAMERA) {
      */
     static obtainAudioAndVideoPermissions(options) {
         return RTCUtils.obtainAudioAndVideoPermissions(options).then(
-            function(tracksInfo) {
+            tracksInfo => {
                 const tracks = createLocalTracks(tracksInfo, options);
                 return !tracks.some(track =>
                     !track._isReceivingData()) ? tracks
      */
     setAudioMute(value) {
         const mutePromises = [];
-        this.getLocalTracks(MediaType.AUDIO).forEach(function(audioTrack) {
+        this.getLocalTracks(MediaType.AUDIO).forEach(audioTrack => {
             // this is a Promise
             mutePromises.push(value ? audioTrack.mute() : audioTrack.unmute());
         });
      * matches given SSRC or <tt>undefined</tt> if no such track was found.
      */
     getRemoteTrackBySSRC(ssrc) {
-        return this.getRemoteTracks().find(function(remoteTrack) {
-            return ssrc == remoteTrack.getSSRC();
-        });
+        return this.getRemoteTracks().find(remoteTrack => ssrc == remoteTrack.getSSRC());
     }
 
     /**

modules/RTC/RTCUtils.js

         && navigator.mediaDevices.enumerateDevices
         ? function(callback) {
             navigator.mediaDevices.enumerateDevices().then(
-                callback, function() {
-                    callback([]);
-                });
+                callback,
+                () => callback([]));
         }
         // Safari:
         // "ReferenceError: Can't find variable: MediaStreamTrack"
         // until WebRTC is ready.
         : MediaStreamTrack && MediaStreamTrack.getSources
         ? function(callback) {
-            MediaStreamTrack.getSources(function(sources) {
-                callback(sources.map(convertMediaStreamTrackSource));
-            });
+            MediaStreamTrack.getSources(
+                sources =>
+                    callback(sources.map(convertMediaStreamTrackSource)));
         }
         : undefined;
 }
     // do not matter. This fixes situation when we have no devices initially,
     // and then plug in a new one.
     if (rawEnumerateDevicesWithCallback) {
-        rawEnumerateDevicesWithCallback(function(devices) {
+        rawEnumerateDevicesWithCallback(devices => {
             // We don't fire RTCEvents.DEVICE_LIST_CHANGED for the first time
             // we call enumerateDevices(). This is the initial step.
             if (typeof currentlyAvailableMediaDevices === 'undefined') {
     initRawEnumerateDevicesWithCallback();
 
     if (rtcUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
-        rawEnumerateDevicesWithCallback(function(devices) {
+        rawEnumerateDevicesWithCallback(devices => {
             currentlyAvailableMediaDevices = devices.splice(0);
 
             eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
             if (isDeviceChangeEventSupported) {
                 navigator.mediaDevices.addEventListener(
                     'devicechange',
-                    function() {
-                        rtcUtils.enumerateDevices(
-                            onMediaDevicesListChanged);
-                    });
+                    () => rtcUtils.enumerateDevices(onMediaDevicesListChanged));
             } else {
                 pollForAvailableMediaDevices();
             }
  */
 function wrapGetUserMedia(getUserMedia) {
     return function(constraints, successCallback, errorCallback) {
-        getUserMedia(constraints, function(stream) {
+        getUserMedia(constraints, stream => {
             maybeApply(successCallback, [stream]);
             if (!getUserMediaStatus.initialized) {
                 getUserMediaStatus.initialized = true;
-                getUserMediaStatus.callbacks.forEach(function(callback) {
-                    callback();
-                });
+                getUserMediaStatus.callbacks.forEach(callback => callback());
                 getUserMediaStatus.callbacks.length = 0;
             }
-        }, function(error) {
+        }, error => {
             maybeApply(errorCallback, [error]);
         });
     };
 function wrapEnumerateDevices(enumerateDevices) {
     return function(callback) {
         // enumerate devices only after initial getUserMedia
-        afterUserMediaInitialized(function() {
-            enumerateDevices().then(callback, function(err) {
+        afterUserMediaInitialized(() => {
+            enumerateDevices().then(callback, err => {
                 logger.error('cannot enumerate devices: ', err);
                 callback([]);
             });
  * @param {Function} callback function to call when received devices list.
  */
 function enumerateDevicesThroughMediaStreamTrack(callback) {
-    MediaStreamTrack.getSources(function(sources) {
-        callback(sources.map(convertMediaStreamTrackSource));
-    });
+    MediaStreamTrack.getSources(
+        sources => callback(sources.map(convertMediaStreamTrackSource)));
 }
 
 /**
     const device = options.devices.splice(0, 1);
     const devices = [];
     devices.push(device);
-    options.deviceGUM[device](function(stream) {
-        options.streams = options.streams || {};
-        options.streams[device] = stream;
-        obtainDevices(options);
-    },
-        function(error) {
-            Object.keys(options.streams).forEach(function(device) {
+    options.deviceGUM[device](
+        stream => {
+            options.streams = options.streams || {};
+            options.streams[device] = stream;
+            obtainDevices(options);
+        },
+        error => {
+            Object.keys(options.streams).forEach(device => {
                 rtcUtils.stopMediaStream(options.streams[device]);
             });
             logger.error(
             logger.info(`Disable NS: ${disableNS}`);
         }
 
-        return new Promise(function(resolve, reject) {
+        return new Promise((resolve, reject) => {
             if (RTCBrowserType.isFirefox()) {
                 const FFversion = RTCBrowserType.getFirefoxVersion();
                 if (FFversion < 40) {
                     navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices)
                 );
                 this.pc_constraints = {};
-                this.attachMediaStream = wrapAttachMediaStream(function(element, stream) {
+                this.attachMediaStream = wrapAttachMediaStream((element, stream) => {
                     //  srcObject is being standardized and FF will eventually
                     //  support that unprefixed. FF also supports the
                     //  "element.src = URL.createObjectURL(...)" combo, but that
                     this.getUserMedia = getUserMedia;
                     this.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
                 }
-                this.attachMediaStream = wrapAttachMediaStream(function(element, stream) {
+                this.attachMediaStream = wrapAttachMediaStream((element, stream) => {
                     defaultSetVideoSrc(element, stream);
                     return element;
                 });
                 onReady(options, this.getUserMediaWithConstraints.bind(this));
                 resolve();
             }
-        }.bind(this));
+        });
     }
 
     /**
         logger.info('Get media constraints', constraints);
 
         try {
-            this.getUserMedia(constraints,
-                function(stream) {
+            this.getUserMedia(
+                constraints,
+                stream => {
                     logger.log('onUserMediaSuccess');
                     setAvailableDevices(um, stream);
                     success_callback(stream);
                 },
-                function(error) {
+                error => {
                     setAvailableDevices(um, undefined);
                     logger.warn('Failed to get access to local media. Error ',
                         error, constraints);
 
         options = options || {};
         const dsOptions = options.desktopSharingExtensionExternalInstallation;
-        return new Promise(function(resolve, reject) {
+        return new Promise((resolve, reject) => {
             const successCallback = function(stream) {
                 resolve(handleLocalStream(stream, options.resolution));
             };
                 if(options.devices.length) {
                     this.getUserMediaWithConstraints(
                         options.devices,
-                        function(stream) {
+                        stream => {
                             const audioDeviceRequested
                                 = options.devices.indexOf('audio') !== -1;
                             const videoDeviceRequested
                                 // set to not ask for permissions)
                                 self.getUserMediaWithConstraints(
                                     devices,
-                                    function() {
+                                    () => {
                                         // we already failed to obtain this
                                         // media, so we are not supposed in any
                                         // way to receive success for this call
                                             devices)
                                         );
                                     },
-                                    function(error) {
+                                    error => {
                                         // rejects with real error for not
                                         // obtaining the media
                                         reject(error);
                             if(hasDesktop) {
                                 screenObtainer.obtainStream(
                                     dsOptions,
-                                    function(desktopStream) {
+                                    desktopStream => {
                                         successCallback({audioVideo: stream,
                                             desktopStream});
-                                    }, function(error) {
+                                    }, error => {
                                         self.stopMediaStream(stream);
 
                                         reject(error);
                                 successCallback({audioVideo: stream});
                             }
                         },
-                        function(error) {
-                            reject(error);
-                        },
+                        error => reject(error),
                         options);
                 } else if (hasDesktop) {
                     screenObtainer.obtainStream(
                         dsOptions,
-                        function(stream) {
-                            successCallback({desktopStream: stream});
-                        }, function(error) {
-                            reject(error);
-                        });
+                        stream => successCallback({desktopStream: stream}),
+                        error => reject(error));
                 }
             }
-        }.bind(this));
+        });
     }
 
     getDeviceAvailability() {
      * @param mediaStream MediaStream object to stop.
      */
     stopMediaStream(mediaStream) {
-        mediaStream.getTracks().forEach(function(track) {
+        mediaStream.getTracks().forEach(track => {
             // stop() not supported with IE
             if (!RTCBrowserType.isTemasysPluginUsed() && track.stop) {
                 track.stop();
         }
 
         return featureDetectionAudioEl.setSinkId(deviceId)
-            .then(function() {
+            .then(() => {
                 audioOutputDeviceId = deviceId;
                 audioOutputChanged = true;
 

modules/RTC/TraceablePeerConnection.js

     };
     // XXX: do all non-firefox browsers which we support also support this?
     if (!RTCBrowserType.isFirefox() && this.maxstats) {
-        this.statsinterval = window.setInterval(function() {
-            self.peerconnection.getStats(function(stats) {
+        this.statsinterval = window.setInterval(() => {
+            self.peerconnection.getStats(stats => {
                 const results = stats.result();
                 const now = new Date();
                 for (let i = 0; i < results.length; ++i) {
-                    results[i].names().forEach(function(name) {
+                    results[i].names().forEach(name => {
                         const id = `${results[i].id}-${name}`;
                         if (!self.stats[id]) {
                             self.stats[id] = {
     let ssrcLines = SDPUtil.find_lines(mediaLines[0], 'a=ssrc:');
 
     ssrcLines = ssrcLines.filter(
-        function(line) {
+        line => {
             const msid
                 = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
             return line.indexOf(`${msid}:${streamId}`) !== -1;
 
     if (typeof session !== 'undefined'
         && typeof session.media !== 'undefined' && Array.isArray(session.media)) {
-        session.media.forEach(function(mLine) {
+        session.media.forEach(mLine => {
 
             // Chrome appears to be picky about the order in which a=ssrc lines
             // are listed in an m-line when rtx is enabled (and thus there are
 
             if (typeof mLine.ssrcGroups !== 'undefined'
                 && Array.isArray(mLine.ssrcGroups)) {
-                mLine.ssrcGroups.forEach(function(group) {
+                mLine.ssrcGroups.forEach(group => {
                     if (typeof group.semantics !== 'undefined'
                         && group.semantics === 'FID') {
                         if (typeof group.ssrcs !== 'undefined') {
         return desc;
     }
 };
-Object.keys(getters).forEach(function(prop) {
+Object.keys(getters).forEach(prop => {
     Object.defineProperty(
         TraceablePeerConnection.prototype,
         prop, {
 
             const self = this;
             this.peerconnection.setLocalDescription(description,
-        function() {
+        () => {
             self.trace('setLocalDescriptionOnSuccess');
             successCallback();
         },
-        function(err) {
+        err => {
             self.trace('setLocalDescriptionOnFailure', err);
             self.eventEmitter.emit(
                 RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
 
             const self = this;
             this.peerconnection.setRemoteDescription(description,
-        function() {
+        () => {
             self.trace('setRemoteDescriptionOnSuccess');
             successCallback();
         },
-        function(err) {
+        err => {
             self.trace('setRemoteDescriptionOnFailure', err);
             self.eventEmitter.emit(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
                 err, self.peerconnection);
     if (offer && answer
             && offer.media && answer.media
             && offer.media.length == answer.media.length) {
-        answer.media.forEach(function(a, i) {
+        answer.media.forEach((a, i) => {
             if (SDPUtil.find_line(
                     offer.media[i],
                     'a=setup:actpass',

modules/connectivity/ParticipantConnectionStatus.js

                 this._onRemoteTrackRemoved);
         }
 
-        Object.keys(this.trackTimers).forEach(function(participantId) {
+        Object.keys(this.trackTimers).forEach(participantId => {
             this.clearTimeout(participantId);
             this.clearRtcMutedTimestamp(participantId);
-        }.bind(this));
+        });
 
         // Clear RTC connection status cache
         this.connStatusFromJvb = {};
             // it some time, before the connection interrupted event is
             // triggered.
             this.clearTimeout(participantId);
-            this.trackTimers[participantId] = window.setTimeout(function() {
+            this.trackTimers[participantId] = window.setTimeout(() => {
                 logger.debug(`RTC mute timeout for: ${participantId}`);
                 this.clearTimeout(participantId);
                 this.figureOutConnectionStatus(participantId);
-            }.bind(this), this.rtcMuteTimeout);
+            }, this.rtcMuteTimeout);
         }
     }
 

modules/statistics/CallStats.js

     MST_WITH_USERID: 'mstWithUserID'
 };
 
-CallStats.prototype.pcCallback = _try_catch(function(err, msg) {
+CallStats.prototype.pcCallback = _try_catch((err, msg) => {
     if (callStats && err !== 'success') {
         logger.error(`Monitoring status: ${err} msg: ${msg}`);
     }
  * @param type {String} "audio"/"video"
  * @param {CallStats} cs callstats instance related to the event
  */
-CallStats.sendMuteEvent = _try_catch(function(mute, type, cs) {
+CallStats.sendMuteEvent = _try_catch((mute, type, cs) => {
     let event;
 
     if (type === 'video') {
  * false for not stopping
  * @param {CallStats} cs callstats instance related to the event
  */
-CallStats.sendScreenSharingEvent = _try_catch(function(start, cs) {
+CallStats.sendScreenSharingEvent = _try_catch((start, cs) => {
     CallStats._reportEvent.call(
         cs,
         start ? fabricEvent.screenShareStart : fabricEvent.screenShareStop);
  * Notifies CallStats that we are the new dominant speaker in the conference.
  * @param {CallStats} cs callstats instance related to the event
  */
-CallStats.sendDominantSpeakerEvent = _try_catch(function(cs) {
+CallStats.sendDominantSpeakerEvent = _try_catch(cs => {
     CallStats._reportEvent.call(cs, fabricEvent.dominantSpeaker);
 });
 
  * @param {{deviceList: {String:String}}} list of devices with their data
  * @param {CallStats} cs callstats instance related to the event
  */
-CallStats.sendActiveDeviceListEvent = _try_catch(function(devicesData, cs) {
+CallStats.sendActiveDeviceListEvent = _try_catch((devicesData, cs) => {
     CallStats._reportEvent.call(cs, fabricEvent.activeDeviceList, devicesData);
 });
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.prototype.sendIceConnectionFailedEvent = _try_catch(function(pc, cs) {
+CallStats.prototype.sendIceConnectionFailedEvent = _try_catch((pc, cs) => {
     CallStats._reportError.call(
         cs, wrtcFuncNames.iceConnectionFailure, null, pc);
 });
  * @param {Error} e error to send
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendGetUserMediaFailed = _try_catch(function(e, cs) {
+CallStats.sendGetUserMediaFailed = _try_catch((e, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.getUserMedia, e, null);
 });
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendCreateOfferFailed = _try_catch(function(e, pc, cs) {
+CallStats.sendCreateOfferFailed = _try_catch((e, pc, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.createOffer, e, pc);
 });
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendCreateAnswerFailed = _try_catch(function(e, pc, cs) {
+CallStats.sendCreateAnswerFailed = _try_catch((e, pc, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.createAnswer, e, pc);
 });
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendSetLocalDescFailed = _try_catch(function(e, pc, cs) {
+CallStats.sendSetLocalDescFailed = _try_catch((e, pc, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.setLocalDescription, e, pc);
 });
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendSetRemoteDescFailed = _try_catch(function(e, pc, cs) {
+CallStats.sendSetRemoteDescFailed = _try_catch((e, pc, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.setRemoteDescription, e, pc);
 });
 
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendAddIceCandidateFailed = _try_catch(function(e, pc, cs) {
+CallStats.sendAddIceCandidateFailed = _try_catch((e, pc, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.addIceCandidate, e, pc);
 });
 
  * @param {Error} e error to send or {String} message
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendApplicationLog = _try_catch(function(e, cs) {
+CallStats.sendApplicationLog = _try_catch((e, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.applicationLog, e, null);
 });
 

modules/statistics/LocalStatsCollector.js

     const self = this;
 
     this.intervalId = setInterval(
-        function() {
+        () => {
             const array = new Uint8Array(analyser.frequencyBinCount);
             analyser.getByteTimeDomainData(array);
             const audioLevel = timeDomainDataToAudioLevel(array);

modules/statistics/RTPStatsCollector.js

     const self = this;
     if(startAudioLevelStats) {
         this.audioLevelsIntervalId = setInterval(
-            function() {
+            () => {
                 // Interval updates
                 self.peerconnection.getStats(
-                    function(report) {
+                    report => {
                         let results = null;
                         if (!report || !report.result
                             || typeof report.result != 'function') {
 
     if (browserSupported) {
         this.statsIntervalId = setInterval(
-            function() {
+            () => {
                 // Interval updates
                 self.peerconnection.getStats(
-                    function(report) {
+                    report => {
                         let results = null;
                         if (!report || !report.result
                             || typeof report.result != 'function') {
         // Array in which each element is a key-value pair.
         itemStatByKey = function(item, key) {
             let value;
-            item.values.some(function(pair) {
+            item.values.some(pair => {
                 if (pair.hasOwnProperty(key)) {
                     value = pair[key];
                     return true;

modules/statistics/statistics.js

  */
 Statistics.sendActiveDeviceListEvent = function(devicesData) {
     if (Statistics.callsStatsInstances.length) {
-        Statistics.callsStatsInstances.forEach(function(cs) {
+        Statistics.callsStatsInstances.forEach(cs => {
             CallStats.sendActiveDeviceListEvent(devicesData, cs);
         });
     } else {
 Statistics.sendGetUserMediaFailed = function(e) {
 
     if (Statistics.callsStatsInstances.length) {
-        Statistics.callsStatsInstances.forEach(function(cs) {
-            CallStats.sendGetUserMediaFailed(
-                e instanceof JitsiTrackError
-                    ? formatJitsiTrackErrorForCallStats(e)
-                    : e,
-                cs);
-        });
+        Statistics.callsStatsInstances.forEach(
+            cs =>
+                CallStats.sendGetUserMediaFailed(
+                    e instanceof JitsiTrackError
+                        ? formatJitsiTrackErrorForCallStats(e)
+                        : e,
+                    cs));
     } else {
         CallStats.sendGetUserMediaFailed(
             e instanceof JitsiTrackError
  */
 Statistics.sendLog = function(m) {
     if (Statistics.callsStatsInstances.length) {
-        Statistics.callsStatsInstances.forEach(function(cs) {
-            CallStats.sendApplicationLog(m, cs);
-        });
+        Statistics.callsStatsInstances.forEach(
+            cs => CallStats.sendApplicationLog(m, cs));
     } else {
         CallStats.sendApplicationLog(m, null);
     }

modules/transcription/audioRecorder.js

     // Create a new stream which only holds the audio track
     const originalStream = trackRecorder.track.getOriginalStream();
     const stream = createEmptyStream();
-    originalStream.getAudioTracks().forEach(function(track) {
-        stream.addTrack(track);
-    });
+    originalStream.getAudioTracks().forEach(track => stream.addTrack(track));
     // Create the MediaRecorder
     trackRecorder.recorder = new MediaRecorder(stream,
         {mimeType: audioRecorder.fileType});
  */
 audioRecorder.prototype.updateNames = function() {
     const conference = this.jitsiConference;
-    this.recorders.forEach(function(trackRecorder) {
+    this.recorders.forEach(trackRecorder => {
         if(trackRecorder.track.isLocal()) {
             trackRecorder.name = 'the transcriber';
         } else {
     // conference, that track can instantly start recording as well
     this.isRecording = true;
     // start all the mediaRecorders
-    this.recorders.forEach(function(trackRecorder) {
-        startRecorder(trackRecorder);
-    });
+    this.recorders.forEach(trackRecorder => startRecorder(trackRecorder));
     // log that recording has started
     console.log(
         `Started the recording of the audio. There are currently ${
  */
 audioRecorder.prototype.download = function() {
     const t = this;
-    this.recorders.forEach(function(trackRecorder) {
+    this.recorders.forEach(trackRecorder => {
         const blob = new Blob(trackRecorder.data, {type: t.fileType});
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a');
 
     const array = [];
     const t = this;
-    this.recorders.forEach(function(recorder) {
-        array.push(
-            new RecordingResult(
-            new Blob(recorder.data, {type: t.fileType}),
-            recorder.name,
-            recorder.startTime)
-        );
-    });
+    this.recorders.forEach(
+          recorder =>
+              array.push(
+                  new RecordingResult(
+                      new Blob(recorder.data, {type: t.fileType}),
+                      recorder.name,
+                      recorder.startTime)));
     return array;
 };
 
         return new webkitMediaStream(); // eslint-disable-line new-cap
     }
     throw new Error('cannot create a clean mediaStream');
-
 }
 
 /**

modules/transcription/transcriber.js

     const t = this;
 
     const callBack = blobCallBack.bind(this);
-    this.audioRecorder.getRecordingResults().forEach(function(recordingResult) {
+    this.audioRecorder.getRecordingResults().forEach(recordingResult => {
         t.transcriptionService.send(recordingResult, callBack);
         t.counter++;
     });
         }
 
         let array = '[';
-        answer.wordArray.forEach(function(wordObject) {
+        answer.wordArray.forEach(wordObject => {
             wordObject.begin += offset;
             wordObject.end += offset;
             array += `${wordObject.word},`;
     hasPopulatedArrays(arrays);
 
     // populate all the potential Words for a first time
-    arrays.forEach(function(array) {
-        pushWordToSortedArray(potentialWords, array);
-    });
+    arrays.forEach(array => pushWordToSortedArray(potentialWords, array));
 
     // keep adding words to transcription until all arrays are exhausted
     let lowestWordArray;
     while(hasPopulatedArrays(arrays)) {
         // first select the lowest array;
         lowestWordArray = arrays[0];
-        arrays.forEach(function(wordArray) {
+        arrays.forEach(wordArray => {
             if(wordArray[0].begin < lowestWordArray[0].begin) {
                 lowestWordArray = wordArray;
             }
         // keep going until a word in another array has a smaller time
         // or the array is empty
         while(!foundSmaller && lowestWordArray.length > 0) {
-            arrays.forEach(function(wordArray) {
+            arrays.forEach(wordArray => {
                 if(wordArray[0].begin < lowestWordArray[0].begin) {
                     foundSmaller = true;
                 }

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

  */
 TranscriptionService.prototype.send = function send(recordingResult, callback) {
     const t = this;
-    this.sendRequest(recordingResult.blob, function(response) {
+    this.sendRequest(recordingResult.blob, response => {
         if(!t.verify(response)) {
             console.log('the retrieved response from the server'
                    + ' is not valid!');

modules/util/GlobalOnErrorHandler.js

  * all handlers that were previously added.
  */
 function JitsiGlobalErrorHandler(message, source, lineno, colno, error) {
-    handlers.forEach(function(handler) {
-        handler(message, source, lineno, colno, error);
-    });
+    handlers.forEach(handler => handler(message, source, lineno, colno, error));
     if (oldOnErrorHandler) {
         oldOnErrorHandler(message, source, lineno, colno, error);
     }
  * that were previously added. This handler handles rejected Promises.
  */
 function JitsiGlobalUnhandledRejection(event) {
-    handlers.forEach(function(handler) {
-        handler(null, null, null, null, event.reason);
-    });
+    handlers.forEach(handler => handler(null, null, null, null, event.reason));
     if(oldOnUnhandledRejection) {
         oldOnUnhandledRejection(event);
     }
 window.onerror = JitsiGlobalErrorHandler;
 window.onunhandledrejection = JitsiGlobalUnhandledRejection;
 
-
 const GlobalOnErrorHandler = {
     /**
      * Adds new error handlers.

modules/version/ComponentsVersions.js

         }
 
         const log = [];
-        node.children.forEach(function(item) {
+        node.children.forEach(item => {
 
             const componentName = item.attributes.name;
             if (componentName !== ComponentsVersions.FOCUS_COMPONENT
                     version
                 });
             }
-        }.bind(this));
+        });
 
         // logs versions to stats
         if (log.length > 0) {

modules/xmpp/ChatRoom.js

                 tagName
             };
             node.attributes = {};
-            $($(this)[0].attributes).each(function(index, attr) {
+            $($(this)[0].attributes).each((index, attr) => {
                 node.attributes[ attr.name ] = attr.value;
             });
             const text = Strophe.getText($(this)[0]);
 };
 
 /**
- * Returns array of JS objects from the presence JSON associated with the passed nodeName
+ * Returns array of JS objects from the presence JSON associated with the passed
+ / nodeName
  * @param pres the presence JSON
  * @param nodeName the name of the node (videomuted, audiomuted, etc)
  */
 
     join(password) {
         this.password = password;
-        const self = this;
-        this.moderator.allocateConferenceFocus(function() {
-            self.sendPresence(true);
-        });
+        this.moderator.allocateConferenceFocus(() => this.sendPresence(true));
     }
 
     sendPresence(fromJoin) {
         const getInfo = $iq({type: 'get', to: this.roomjid})
         .c('query', {xmlns: Strophe.NS.DISCO_INFO});
 
-        this.connection.sendIQ(getInfo, function(result) {
-            const locked = $(result).find('>query>feature[var="muc_passwordprotected"]')
-            .length === 1;
+        this.connection.sendIQ(getInfo, result => {
+            const locked
+                = $(result).find('>query>feature[var="muc_passwordprotected"]')
+                        .length
+                    === 1;
             if (locked != this.locked) {
                 this.eventEmitter.emit(XMPPEvents.MUC_LOCK_CHANGED, locked);
                 this.locked = locked;
             }
-        }.bind(this), function(error) {
+        }, error => {
             GlobalOnErrorHandler.callErrorHandler(error);
             logger.error('Error getting room info: ', error);
         });
 
         const self = this;
 
-        this.connection.sendIQ(getForm, function(form) {
-
+        this.connection.sendIQ(getForm, form => {
             if (!$(form).find(
                     '>query>x[xmlns="jabber:x:data"]'
                     + '>field[var="muc#roomconfig_whois"]').length) {
 
             self.connection.sendIQ(formSubmit);
 
-        }, function(error) {
+        }, error => {
             GlobalOnErrorHandler.callErrorHandler(error);
             logger.error('Error getting room configuration form: ', error);
         });
         parser.packet2JSON(pres, nodes);
         this.lastPresences[from] = nodes;
         let jibri = null;
-        // process nodes to extract data needed for MUC_JOINED and MUC_MEMBER_JOINED
-        // events
+        // process nodes to extract data needed for MUC_JOINED and
+        // MUC_MEMBER_JOINED events
         for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
             switch(node.tagName) {
 
         this.connection.sendIQ(
             kickIQ,
-            function(result) {
-                logger.log('Kick participant with jid: ', jid, result);
-            },
-            function(error) {
-                logger.log('Kick participant error: ', error);
-            });
+            result => logger.log('Kick participant with jid: ', jid, result),
+            error => logger.log('Kick participant error: ', error));
     }
 
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
-        const ob = this;
-        this.connection.sendIQ($iq({to: this.roomjid, type: 'get'}).c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'}),
-            function(res) {
+        this.connection.sendIQ(
+            $iq({to: this.roomjid, type: 'get'}).c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'}),
+            res => {
                 if ($(res).find('>query>x[xmlns="jabber:x:data"]>field[var="muc#roomconfig_roomsecret"]').length) {
-                    const formsubmit = $iq({to: ob.roomjid, type: 'set'}).c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
+                    const formsubmit
+                        = $iq({to: this.roomjid, type: 'set'})
+                            .c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
                     formsubmit.c('x', {xmlns: 'jabber:x:data', type: 'submit'});
                     formsubmit.c('field', {'var': 'FORM_TYPE'}).c('value').t('http://jabber.org/protocol/muc#roomconfig').up().up();
                     formsubmit.c('field', {'var': 'muc#roomconfig_roomsecret'}).c('value').t(key).up().up();
                     // Fixes a bug in prosody 0.9.+ https://code.google.com/p/lxmppd/issues/detail?id=373
                     formsubmit.c('field', {'var': 'muc#roomconfig_whois'}).c('value').t('anyone').up().up();
                     // FIXME: is muc#roomconfig_passwordprotectedroom required?
-                    ob.connection.sendIQ(formsubmit,
-                        onSuccess,
-                        onError);
+                    this.connection.sendIQ(formsubmit, onSuccess, onError);
                 } else {
                     onNotSupported();
                 }
-            }, onError);
+            },
+            onError);
     }
 
     addToPresence(key, values) {
     }
 
     removeFromPresence(key) {
-        const nodes = this.presMap.nodes.filter(function(node) {
-            return key !== node.tagName;
-        });
+        const nodes = this.presMap.nodes.filter(node => key !== node.tagName);
         this.presMap.nodes = nodes;
     }
 
             return member.isFocus;
         }
         return null;
-
     }
 
     isModerator() {
 
         this.connection.sendIQ(
             iqToFocus,
-            function(result) {
-                logger.log('set mute', result);
-            },
-            function(error) {
-                logger.log('set mute error', error);
-            });
+            result => logger.log('set mute', result),
+            error => logger.log('set mute error', error));
     }
 
     onMute(iq) {

modules/xmpp/JingleSessionPC.js

 
         const localSDP = new SDP(this.peerconnection.localDescription.sdp);
         for (let mid = 0; mid < localSDP.media.length; mid++) {
-            const cands = candidates.filter(function(el) {
-                return el.sdpMLineIndex == mid;
-            });
+            const cands = candidates.filter(el => el.sdpMLineIndex == mid);
             const mline
                 = SDPUtil.parse_mline(localSDP.media[mid].split('\r\n')[0]);
             if (cands.length > 0) {
         // a lot later. See webrtc issue #2340
         // logger.log('was this the last candidate', this.lasticecandidate);
         this.connection.sendIQ(
-            cand, null, this.newJingleErrorHandler(cand, function(error) {
+            cand, null, this.newJingleErrorHandler(cand, error => {
                 GlobalOnErrorHandler.callErrorHandler(
                     new Error(`Jingle error: ${JSON.stringify(error)}`));
             }), IQ_TIMEOUT);
      */
     _parseSsrcInfoFromSourceAdd(sourceAddElem, currentRemoteSdp) {
         const addSsrcInfo = [];
-        $(sourceAddElem).each(function(idx, content) {
+        $(sourceAddElem).each((idx, content) => {
             const name = $(content).attr('name');
             let lines = '';
             $(content)
                     lines += '\r\n';
                 });
             });
-            currentRemoteSdp.media.forEach(function(media, idx) {
+            currentRemoteSdp.media.forEach((media, idx) => {
                 if (!SDPUtil.find_line(media, `a=mid:${name}`)) {
                     return;
                 }
      */
     _processRemoteRemoveSource(removeSsrcInfo) {
         const remoteSdp = new SDP(this.peerconnection.remoteDescription.sdp);
-        removeSsrcInfo.forEach(function(lines, idx) {
+        removeSsrcInfo.forEach((lines, idx) => {
             lines = lines.split('\r\n');
             lines.pop(); // remove empty last element;
-            lines.forEach(function(line) {
+            lines.forEach(line => {
                 remoteSdp.media[idx]
                     = remoteSdp.media[idx].replace(`${line}\r\n`, '');
             });
      */
     _processRemoteAddSource(addSsrcInfo) {
         const remoteSdp = new SDP(this.peerconnection.remoteDescription.sdp);
-        addSsrcInfo.forEach(function(lines, idx) {
+        addSsrcInfo.forEach((lines, idx) => {
             remoteSdp.media[idx] += lines;
         });
         remoteSdp.raw = remoteSdp.session + remoteSdp.media.join('');
      */
     _parseSsrcInfoFromSourceRemove(sourceRemoveElem, currentRemoteSdp) {
         const removeSsrcInfo = [];
-        $(sourceRemoveElem).each(function(idx, content) {
+        $(sourceRemoveElem).each((idx, content) => {
             const name = $(content).attr('name');
             let lines = '';
             $(content)
                 const ssrc = $(this).attr('ssrc');
                 ssrcs.push(ssrc);
             });
-            currentRemoteSdp.media.forEach(function(media, idx) {
+            currentRemoteSdp.media.forEach((media, idx) => {
                 if (!SDPUtil.find_line(media, `a=mid:${name}`)) {
                     return;
                 }
                 if (!removeSsrcInfo[idx]) {
                     removeSsrcInfo[idx] = '';
                 }
-                ssrcs.forEach(function(ssrc) {
+                ssrcs.forEach(ssrc => {
                     const ssrcLines
                         = SDPUtil.find_lines(media, `a=ssrc:${ssrc}`);
                     if (ssrcLines.length) {
         }
 
         // Find the right sender (for audio or video)
-        this.peerconnection.peerconnection.getSenders().some(function(s) {
+        this.peerconnection.peerconnection.getSenders().some(s => {
             if (s.track === track) {
                 sender = s;
                 return true;
             logger.info('Sending source-remove', remove.tree());
             this.connection.sendIQ(
                 remove, null,
-                this.newJingleErrorHandler(remove, function(error) {
+                this.newJingleErrorHandler(remove, error => {
                     GlobalOnErrorHandler.callErrorHandler(
                         new Error(`Jingle error: ${JSON.stringify(error)}`));
                 }), IQ_TIMEOUT);
         if (added && add) {
             logger.info('Sending source-add', add.tree());
             this.connection.sendIQ(
-                add, null, this.newJingleErrorHandler(add, function(error) {
+                add, null, this.newJingleErrorHandler(add, error => {
                     GlobalOnErrorHandler.callErrorHandler(
                         new Error(`Jingle error: ${JSON.stringify(error)}`));
                 }), IQ_TIMEOUT);
         let ssrcs = this.modifiedSSRCs.unmute;
         this.modifiedSSRCs.unmute = [];
         if (ssrcs && ssrcs.length) {
-            ssrcs.forEach(function(ssrcObj) {
+            ssrcs.forEach(ssrcObj => {
                 const desc
                     = $(jingle.tree()).find(
                         `>jingle>content[name="${ssrcObj.mtype}"]>description`);
                 if (!desc || !desc.length) {
                     return;
                 }
-                ssrcObj.ssrcs.forEach(function(ssrc) {
+                ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode = desc.find(`>source[ssrc="${ssrc}"]`);
                     sourceNode.remove();
                 });
-                ssrcObj.groups.forEach(function(group) {
+                ssrcObj.groups.forEach(group => {
                     const groupNode = desc.find(`>ssrc-group[semantics="${
                          group.semantics}"]:has(source[ssrc="${
                          group.ssrcs[0]}"])`);
         ssrcs = this.modifiedSSRCs.addMuted;
         this.modifiedSSRCs.addMuted = [];
         if (ssrcs && ssrcs.length) {
-            ssrcs.forEach(function(ssrcObj) {
+            ssrcs.forEach(ssrcObj => {
                 const desc
                     = JingleSessionPC.createDescriptionNode(
                         jingle, ssrcObj.mtype);
                 const cname = Math.random().toString(36).substring(2);
-                ssrcObj.ssrcs.forEach(function(ssrc) {
+                ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode
                         = desc.find(`>source[ssrc="${ssrc}"]`);
                     sourceNode.remove();
                         + '</source>';
                     desc.append(sourceXML);
                 });
-                ssrcObj.groups.forEach(function(group) {
+                ssrcObj.groups.forEach(group => {
                     const groupNode
                         = desc.find(
                             `>ssrc-group[semantics="${group.semantics
         let ssrcs = this.modifiedSSRCs.mute;
         this.modifiedSSRCs.mute = [];
         if (ssrcs && ssrcs.length) {
-            ssrcs.forEach(function(ssrcObj) {
-                ssrcObj.ssrcs.forEach(function(ssrc) {
+            ssrcs.forEach(ssrcObj => {
+                ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode
                         = $(jingle.tree()).find(
                             `>jingle>content[name="${ssrcObj.mtype
                                 }"]>description>source[ssrc="${ssrc}"]`);
                     sourceNode.remove();
                 });
-                ssrcObj.groups.forEach(function(group) {
+                ssrcObj.groups.forEach(group => {
                     const groupNode
                         = $(jingle.tree()).find(
                             `>jingle>content[name="${ssrcObj.mtype
         ssrcs = this.modifiedSSRCs.remove;
         this.modifiedSSRCs.remove = [];
         if (ssrcs && ssrcs.length) {
-            ssrcs.forEach(function(ssrcObj) {
+            ssrcs.forEach(ssrcObj => {
                 const desc
                     = JingleSessionPC.createDescriptionNode(
                         jingle, ssrcObj.mtype);
-                ssrcObj.ssrcs.forEach(function(ssrc) {
+                ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode
                         = desc.find(`>source[ssrc="${ssrc}"]`);
                     if (!sourceNode || !sourceNode.length) {
                                 + `ssrc="${ssrc}"></source>`);
                     }
                 });
-                ssrcObj.groups.forEach(function(group) {
+                ssrcObj.groups.forEach(group => {
                     const groupNode
                         = desc.find(`>ssrc-group[semantics="${
                              group.semantics}"]:has(source[ssrc="${

modules/xmpp/RtxModifier.spec.js

     .filter(g => g.semantics === groupSemantics);
 }
 
-describe('RtxModifier', function() {
+describe('RtxModifier', () => {
     beforeEach(function() {
         this.rtxModifier = new RtxModifier();
         this.transform = transform;
         this.SDPUtil = SDPUtil;
     });
 
-    describe('modifyRtxSsrcs', function() {
-        describe('when given an sdp with a single video ssrc', function() {
+    describe('modifyRtxSsrcs', () => {
+        describe('when given an sdp with a single video ssrc', () => {
             beforeEach(function() {
                 this.singleVideoSdp = SampleSdpStrings.plainVideoSdp;
                 this.primaryVideoSsrc = getPrimaryVideoSsrc(this.singleVideoSdp);
             });
         });
 
-        describe('when given an sdp with multiple video ssrcs', function() {
+        describe('when given an sdp with multiple video ssrcs', () => {
             beforeEach(function() {
                 this.multipleVideoSdp = SampleSdpStrings.simulcastSdp;
                 this.primaryVideoSsrcs = getPrimaryVideoSsrcs(this.multipleVideoSdp);
             });
         });
 
-        describe('(corner cases)', function() {
+        describe('(corner cases)', () => {
             it('should handle a recvonly video mline', function() {
                 const sdp = SampleSdpStrings.plainVideoSdp;
                 const videoMLine = sdp.media.find(m => m.type === 'video');
         });
     });
 
-    describe('stripRtx', function() {
-        beforeEach(function() { }); // eslint-disable-line no-empty-function
+    describe('stripRtx', () => {
+        beforeEach(() => { }); // eslint-disable-line no-empty-function
         it('should strip all rtx streams from an sdp with rtx', function() {
             const sdpStr = transform.write(SampleSdpStrings.rtxVideoSdp);
             const newSdpStr = this.rtxModifier.stripRtx(sdpStr);

modules/xmpp/SDP.js

             ssrcGroups: []
         };
         media_ssrcs[mediaindex] = media;
-        tmp.forEach(function(line) {
+        tmp.forEach(line => {
             const linessrc = line.substring(7).split(' ')[0];
             // allocate new ChannelSsrc
             if(!media.ssrcs[linessrc]) {
             media.ssrcs[linessrc].lines.push(line);
         });
         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc-group:');
-        tmp.forEach(function(line) {
+        tmp.forEach(line => {
             const idx = line.indexOf(' ');
             const semantics = line.substr(0, idx).substr(13);
             const ssrcs = line.substr(14 + semantics.length).split(' ');
     // FIXME this code is really strange - improve it if you can
     const medias = this.getMediaSsrcMap();
     let result = false;
-    Object.keys(medias).forEach(function(mediaindex) {
+    Object.keys(medias).forEach(mediaindex => {
         if (result) {
             return;
         }
 SDP.prototype.removeSessionLines = function(prefix) {
     const self = this;
     const lines = SDPUtil.find_lines(this.session, prefix);
-    lines.forEach(function(line) {
+    lines.forEach(line => {
         self.session = self.session.replace(`${line}\r\n`, '');
     });
     this.raw = this.session + this.media.join('');
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
     const self = this;
     const lines = SDPUtil.find_lines(this.media[mediaindex], prefix);
-    lines.forEach(function(line) {
-        self.media[mediaindex] = self.media[mediaindex].replace(`${line}\r\n`, '');
+    lines.forEach(line => {
+        self.media[mediaindex]
+            = self.media[mediaindex].replace(`${line}\r\n`, '');
     });
     this.raw = this.session + this.media.join('');
     return lines;
             const crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
             if (crypto.length) {
                 elem.c('encryption', {required: 1});
-                crypto.forEach(function(line) {
-                    elem.c('crypto', SDPUtil.parse_crypto(line)).up();
-                });
+                crypto.forEach(
+                    line => elem.c('crypto', SDPUtil.parse_crypto(line)).up());
                 elem.up(); // end of encryption
             }
 
                 // FIXME: group by ssrc and support multiple different ssrcs
                 const ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
                 if(ssrclines.length > 0) {
-                    ssrclines.forEach(function(line) {
+                    ssrclines.forEach(line => {
                         const idx = line.indexOf(' ');
                         const linessrc = line.substr(0, idx).substr(7);
                         if (linessrc != ssrc) {
 
                 // XEP-0339 handle ssrc-group attributes
                 const ssrc_group_lines = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
-                ssrc_group_lines.forEach(function(line) {
+                ssrc_group_lines.forEach(line => {
                     const idx = line.indexOf(' ');
                     const semantics = line.substr(0, idx).substr(13);
                     const ssrcs = line.substr(14 + semantics.length).split(' ');
                     if (ssrcs.length) {
                         elem.c('ssrc-group', { semantics, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
-                        ssrcs.forEach(function(ssrc) {
-                            elem.c('source', { ssrc })
-                                .up();
-                        });
+                        ssrcs.forEach(ssrc => elem.c('source', { ssrc }).up());
                         elem.up();
                     }
                 });
     // XEP-0320
     const fingerprints
         = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
-    fingerprints.forEach(function(line) {
+    fingerprints.forEach(line => {
         tmp = SDPUtil.parse_fingerprint(line);
         tmp.xmlns = 'urn:xmpp:jingle:apps:dtls:0';
         elem.c('fingerprint').t(tmp.fingerprint);
         // XEP-0176
         if (SDPUtil.find_line(this.media[mediaindex], 'a=candidate:', this.session)) { // add any a=candidate lines
             const lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
-            lines.forEach(function(line) {
+            lines.forEach(line => {
                 const candidate = SDPUtil.candidateToJingle(line);
                 if (self.failICE) {
                     candidate.ip = '1.1.1.1';
 
 SDP.prototype.rtcpFbToJingle = function(mediaindex, elem, payloadtype) { // XEP-0293
     const lines = SDPUtil.find_lines(this.media[mediaindex], `a=rtcp-fb:${payloadtype}`);
-    lines.forEach(function(line) {
+    lines.forEach(line => {
         const tmp = SDPUtil.parse_rtcpfb(line);
         if (tmp.type == 'trr-int') {
             elem.c('rtcp-fb-trr-int', {xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0', value: tmp.params[0]});
         + 't=0 0\r\n';
     // http://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-04#section-8
     if ($(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').length) {
-        $(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').each(function(idx, group) {
-            const contents = $(group).find('>content').map(function(idx, content) {
-                return content.getAttribute('name');
-            }).get();
+        $(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').each((idx, group) => {
+            const contents = $(group).find('>content').map((idx, content) => content.getAttribute('name')).get();
             if (contents.length > 0) {
                 self.raw += `a=group:${group.getAttribute('semantics') || group.getAttribute('type')} ${contents.join(' ')}\r\n`;
             }
     return media;
 };
 
-
 module.exports = SDP;

modules/xmpp/SDPDiffer.js

     const myMedias = this.mySDP.getMediaSsrcMap();
     const othersMedias = this.otherSDP.getMediaSsrcMap();
     const newMedia = {};
-    Object.keys(othersMedias).forEach(function(othersMediaIdx) {
+    Object.keys(othersMedias).forEach(othersMediaIdx => {
         const myMedia = myMedias[othersMediaIdx];
         const othersMedia = othersMedias[othersMediaIdx];
         if(!myMedia && othersMedia) {
             return;
         }
         // Look for new ssrcs across the channel
-        Object.keys(othersMedia.ssrcs).forEach(function(ssrc) {
+        Object.keys(othersMedia.ssrcs).forEach(ssrc => {
             if(Object.keys(myMedia.ssrcs).indexOf(ssrc) === -1) {
                 // Allocate channel if we've found ssrc that doesn't exist in
                 // our channel
         });
 
         // Look for new ssrc groups across the channels
-        othersMedia.ssrcGroups.forEach(function(otherSsrcGroup) {
+        othersMedia.ssrcGroups.forEach(otherSsrcGroup => {
 
             // try to match the other ssrc-group with an ssrc-group of ours
             let matched = false;
     const sdpMediaSsrcs = this.getNewMedia();
 
     let modified = false;
-    Object.keys(sdpMediaSsrcs).forEach(function(mediaindex) {
+    Object.keys(sdpMediaSsrcs).forEach(mediaindex => {
         modified = true;
         const media = sdpMediaSsrcs[mediaindex];
         modify.c('content', {name: media.mid});
         // FIXME: not completely sure this operates on blocks and / or handles
         // different ssrcs correctly
         // generate sources from lines
-        Object.keys(media.ssrcs).forEach(function(ssrcNum) {
+        Object.keys(media.ssrcs).forEach(ssrcNum => {
             const mediaSsrc = media.ssrcs[ssrcNum];
             modify.c('source', { xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
             modify.attrs({ssrc: mediaSsrc.ssrc});
             // iterate over ssrc lines
-            mediaSsrc.lines.forEach(function(line) {
+            mediaSsrc.lines.forEach(line => {
                 const idx = line.indexOf(' ');
                 const kv = line.substr(idx + 1);
                 modify.c('parameter');
         });
 
         // generate source groups from lines
-        media.ssrcGroups.forEach(function(ssrcGroup) {
+        media.ssrcGroups.forEach(ssrcGroup => {
             if (ssrcGroup.ssrcs.length) {
 
                 modify.c('ssrc-group', {
                     xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0'
                 });
 
-                ssrcGroup.ssrcs.forEach(function(ssrc) {
+                ssrcGroup.ssrcs.forEach(ssrc => {
                     modify.c('source', { ssrc })
                         .up(); // end of source
                 });

modules/xmpp/SDPUtil.spec.js

 import * as SDPUtil from './SDPUtil';
 import * as SampleSdpStrings from './SampleSdpStrings.js';
 
-describe('SDPUtil', function() {
-    it('should parse an ice ufrag correctly', function() {
+describe('SDPUtil', () => {
+    it('should parse an ice ufrag correctly', () => {
         const line = 'a=ice-ufrag:3jlcc1b3j1rqt6';
         const parsed = SDPUtil.parse_iceufrag(line);
 
         expect(parsed).toEqual('3jlcc1b3j1rqt6');
     });
 
-    describe('preferVideoCodec', function() {
-        it('should move a preferred codec to the front', function() {
+    describe('preferVideoCodec', () => {
+        it('should move a preferred codec to the front', () => {
             const sdp = SampleSdpStrings.multiCodecVideoSdp;
             const videoMLine = sdp.media.find(m => m.type === 'video');
             SDPUtil.preferVideoCodec(videoMLine, 'H264');

modules/xmpp/moderator.js

     }
     this.connection.sendIQ(
         iq,
-        function(result) {
+        result => {
             let url = $(result).find('login-url').attr('url');
             url = decodeURIComponent(url);
             if (url) {
     });
     this.connection.sendIQ(
         iq,
-        function(result) {
+        result => {
             let logoutUrl = $(result).find('logout').attr('logout-url');
             if (logoutUrl) {
                 logoutUrl = decodeURIComponent(logoutUrl);
             Settings.clearSessionId();
             callback(logoutUrl);
         },
-        function(error) {
+        error => {
             const errmsg = 'Logout error';
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
             logger.error(errmsg, error);

modules/xmpp/recording.js

         logger.log(iq.nodeTree);
         this.connection.sendIQ(
         iq,
-        function(result) {
+        result => {
             logger.log('Result', result);
             callback($(result).find('jibri').attr('state'),
             $(result).find('jibri').attr('url'));
         },
-        function(error) {
+        error => {
             logger.log('Failed to start recording, error: ', error);
             errCallback(error);
         });
         const self = this;
         this.connection.sendIQ(
         iq,
-        function(result) {
+        result => {
             // TODO wait for an IQ with the real status, since this is
             // provisional?
             self.jireconRid = $(result).find('recording').attr('rid');
 
             callback(state);
         },
-        function(error) {
+        error => {
             logger.log('Failed to start recording, error: ', error);
             errCallback(error);
         });
 
     const self = this;
     this.connection.sendIQ(elem,
-        function(result) {
+        result => {
             logger.log('Set recording "', state, '". Result:', result);
             const recordingElem = $(result).find('>conference>recording');
             const newState = recordingElem.attr('state');
             callback(newState);
 
             if (newState === 'pending') {
-                self.connection.addHandler(function(iq) {
+                self.connection.addHandler(iq => {
                     const state = $(iq).find('recording').attr('state');
                     if (state) {
                         self.state = newState;
                 }, 'http://jitsi.org/protocol/colibri', 'iq', null, null, null);
             }
         },
-        function(error) {
+        error => {
             logger.warn(error);
             errCallback(error);
         }
 
     const self = this;
     logger.log('Toggle recording (old state, new state): ', oldState, newState);
-    this.setRecording(newState,
-        function(state, url) {
+    this.setRecording(
+        newState,
+        (state, url) => {
             // If the state is undefined we're going to wait for presence
             // update.
             if (state && state !== oldState) {
                 self.url = url;
                 statusChangeHandler(state);
             }
-        }, function(error) {
-            statusChangeHandler(Recording.status.FAILED, error);
-        }, options);
+        },
+        error => statusChangeHandler(Recording.status.FAILED, error),
+        options);
 };
 
 /**

modules/xmpp/xmpp.js

             const pingJid = this.connection.domain;
             this.connection.ping.hasPingSupport(
                 pingJid,
-                function(hasPing) {
+                hasPing => {
                     if (hasPing) {
                         this.connection.ping.startInterval(pingJid);
                     } else {
                         logger.warn(`Ping NOT supported by ${pingJid}`);
                     }
-                }.bind(this));
+                });
 
             if (password) {
                 this.authenticatedUser = true;