chore: remove usage of `self`

This has become obsolete thanks to ES6 arrow functions

modules/statistics/LocalStatsCollector.js

 
     source.connect(analyser);
 
-
-    const self = this;
-
     this.intervalId = setInterval(
         () => {
             const array = new Uint8Array(analyser.frequencyBinCount);
             analyser.getByteTimeDomainData(array);
             const audioLevel = timeDomainDataToAudioLevel(array);
 
-            if (audioLevel !== self.audioLevel) {
-                self.audioLevel = animateLevel(audioLevel, self.audioLevel);
-                self.callback(self.audioLevel);
+            if (audioLevel !== this.audioLevel) {
+                this.audioLevel = animateLevel(audioLevel, this.audioLevel);
+                this.callback(this.audioLevel);
             }
         },
         this.intervalMilis

modules/statistics/RTPStatsCollector.js

  * Starts stats updates.
  */
 StatsCollector.prototype.start = function(startAudioLevelStats) {
-    const self = this;
-
     if (startAudioLevelStats) {
         this.audioLevelsIntervalId = setInterval(
             () => {
                 // Interval updates
-                self.peerconnection.getStats(
+                this.peerconnection.getStats(
                     report => {
                         let results = null;
 
                         } else {
                             results = report.result();
                         }
-                        self.currentAudioLevelsReport = results;
+                        this.currentAudioLevelsReport = results;
                         if (this._usesPromiseGetStats) {
-                            self.processNewAudioLevelReport();
+                            this.processNewAudioLevelReport();
                         } else {
-                            self.processAudioLevelReport();
+                            this.processAudioLevelReport();
                         }
 
-                        self.baselineAudioLevelsReport
-                            = self.currentAudioLevelsReport;
+                        this.baselineAudioLevelsReport
+                            = this.currentAudioLevelsReport;
                     },
-                    error => self.errorCallback(error)
+                    error => this.errorCallback(error)
                 );
             },
-            self.audioLevelsIntervalMilis
+            this.audioLevelsIntervalMilis
         );
     }
 
     this.statsIntervalId = setInterval(
         () => {
             // Interval updates
-            self.peerconnection.getStats(
+            this.peerconnection.getStats(
                 report => {
                     let results = null;
 
                         results = report.result();
                     }
 
-                    self.currentStatsReport = results;
+                    this.currentStatsReport = results;
                     try {
                         if (this._usesPromiseGetStats) {
-                            self.processNewStatsReport();
+                            this.processNewStatsReport();
                         } else {
-                            self.processStatsReport();
+                            this.processStatsReport();
                         }
                     } catch (e) {
                         GlobalOnErrorHandler.callErrorHandler(e);
                         logger.error(`Unsupported key:${e}`, e);
                     }
 
-                    self.previousStatsReport = self.currentStatsReport;
+                    this.previousStatsReport = this.currentStatsReport;
                 },
-                error => self.errorCallback(error)
+                error => this.errorCallback(error)
             );
         },
-        self.statsIntervalMilis
+        this.statsIntervalMilis
     );
 };
 

modules/xmpp/ChatRoom.js

             .c('x', { xmlns: 'jabber:x:data',
                 type: 'submit' });
 
-        const self = this;
-
         this.connection.sendIQ(getForm, form => {
             if (!$(form).find(
                     '>query>x[xmlns="jabber:x:data"]'
                 return;
             }
 
-            const formSubmit = $iq({ to: self.roomjid,
+            const formSubmit = $iq({ to: this.roomjid,
                 type: 'set' })
                 .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' });
 
             formSubmit.c('field', { 'var': 'muc#roomconfig_whois' })
                 .c('value').t('anyone').up().up();
 
-            self.connection.sendIQ(formSubmit);
+            this.connection.sendIQ(formSubmit);
 
         }, error => {
             GlobalOnErrorHandler.callErrorHandler(error);

modules/xmpp/SDP.js

  * Returns map of MediaChannel mapped per channel idx.
  */
 SDP.prototype.getMediaSsrcMap = function() {
-    const self = this;
     const mediaSSRCs = {};
     let tmp;
 
-    for (let mediaindex = 0; mediaindex < self.media.length; mediaindex++) {
-        tmp = SDPUtil.findLines(self.media[mediaindex], 'a=ssrc:');
+    for (let mediaindex = 0; mediaindex < this.media.length; mediaindex++) {
+        tmp = SDPUtil.findLines(this.media[mediaindex], 'a=ssrc:');
         const mid
             = SDPUtil.parseMID(
-                SDPUtil.findLine(self.media[mediaindex], 'a=mid:'));
+                SDPUtil.findLine(this.media[mediaindex], 'a=mid:'));
         const media = {
             mediaindex,
             mid,
             }
             media.ssrcs[linessrc].lines.push(line);
         });
-        tmp = SDPUtil.findLines(self.media[mediaindex], 'a=ssrc-group:');
+        tmp = SDPUtil.findLines(this.media[mediaindex], 'a=ssrc-group:');
         tmp.forEach(line => {
             const idx = line.indexOf(' ');
             const semantics = line.substr(0, idx).substr(13);
 
 SDP.prototype.transportToJingle = function(mediaindex, elem) {
     let tmp;
-    const self = this;
 
     elem.c('transport');
 
     // XEP-0343 DTLS/SCTP
     const sctpmap
-        = SDPUtil.findLine(this.media[mediaindex], 'a=sctpmap:', self.session);
+        = SDPUtil.findLine(this.media[mediaindex], 'a=sctpmap:', this.session);
 
     if (sctpmap) {
         const sctpAttrs = SDPUtil.parseSCTPMap(sctpmap);
         // eslint-disable-next-line no-param-reassign
         line
             = SDPUtil.findLine(
-                self.media[mediaindex],
+                this.media[mediaindex],
                 'a=setup:',
-                self.session);
+                this.session);
         if (line) {
             tmp.setup = line.substr(8);
         }
             lines.forEach(line => {
                 const candidate = SDPUtil.candidateToJingle(line);
 
-                if (self.failICE) {
+                if (this.failICE) {
                     candidate.ip = '1.1.1.1';
                 }
                 const protocol
                         ? candidate.protocol.toLowerCase()
                         : '';
 
-                if ((self.removeTcpCandidates
+                if ((this.removeTcpCandidates
                         && (protocol === 'tcp' || protocol === 'ssltcp'))
-                    || (self.removeUdpCandidates && protocol === 'udp')) {
+                    || (this.removeUdpCandidates && protocol === 'udp')) {
                     return;
                 }
                 elem.c('candidate', candidate).up();
 
 // construct an SDP from a jingle stanza
 SDP.prototype.fromJingle = function(jingle) {
-    const self = this;
     const sessionId = Date.now();
 
     // Use a unique session id for every TPC.
                     .get();
 
             if (contents.length > 0) {
-                self.raw
+                this.raw
                     += `a=group:${
                         group.getAttribute('semantics')
                             || group.getAttribute('type')} ${
 
     this.session = this.raw;
     jingle.find('>content').each((_, content) => {
-        const m = self.jingle2media($(content));
+        const m = this.jingle2media($(content));
 
-        self.media.push(m);
+        this.media.push(m);
     });
 
     // reconstruct msid-semantic -- apparently not necessary
 SDP.prototype.jingle2media = function(content) {
     const desc = content.find('description');
     let media = '';
-    const self = this;
     const sctp = content.find(
         '>transport>sctpmap[xmlns="urn:xmpp:jingle:transports:dtls-sctp:1"]');
 
         }
 
         // xep-0293
-        media += self.rtcpFbFromJingle($(payloadType), payloadType.getAttribute('id'));
+        media += this.rtcpFbFromJingle($(payloadType), payloadType.getAttribute('id'));
     });
 
     // xep-0293
-    media += self.rtcpFbFromJingle(desc, '*');
+    media += this.rtcpFbFromJingle(desc, '*');
 
     // xep-0294
     tmp
             protocol
                 = typeof protocol === 'string' ? protocol.toLowerCase() : '';
 
-            if ((self.removeTcpCandidates
+            if ((this.removeTcpCandidates
                     && (protocol === 'tcp' || protocol === 'ssltcp'))
-                || (self.removeUdpCandidates && protocol === 'udp')) {
+                || (this.removeUdpCandidates && protocol === 'udp')) {
                 return;
-            } else if (self.failICE) {
+            } else if (this.failICE) {
                 transport.setAttribute('ip', '1.1.1.1');
             }