[eslint] camelcase

.eslintrc.js

         ],
         'block-spacing': [ 'error', 'always' ],
         'brace-style': 2,
+        'camelcase': 2,
         'comma-dangle': 2,
         'comma-spacing': 2,
         'comma-style': 2,

connection_optimization/external_connect.js

  *
  * @param webserviceUrl the url for the web service that is going to create the
  * connection.
- * @param success_callback callback function called with the result of the AJAX
+ * @param successCallback callback function called with the result of the AJAX
  * request if the request was successfull. The callback will receive one
  * parameter which will be JS Object with properties - rid, sid and jid. This
  * result should be passed to JitsiConnection.attach method in order to use that
  */
 function createConnectionExternally( // eslint-disable-line no-unused-vars
         webserviceUrl,
-        success_callback,
+        successCallback,
         error_callback) {
     if (!window.XMLHttpRequest) {
         error_callback(new Error('XMLHttpRequest is not supported!'));
                         'CrossRegion': proxyRegion !== jitsiRegion ? 1 : 0
                     };
 
-                    success_callback(data);
+                    successCallback(data);
                 } catch (e) {
                     error_callback(e);
                 }

modules/RTC/RTC.js

     }
 
     static getPCConstraints() {
-        return RTCUtils.pc_constraints;
+        return RTCUtils.pcConstraints;
     }
 
     static attachMediaStream(elSelector, stream) {

modules/RTC/RTCUtils.js

                     = wrapEnumerateDevices(
                         navigator.mediaDevices.enumerateDevices.bind(
                             navigator.mediaDevices));
-                this.pc_constraints = {};
+                this.pcConstraints = {};
                 this.attachMediaStream
                     = wrapAttachMediaStream((element, stream) => {
                         // srcObject is being standardized and FF will
                         id = tracks[0].id;
                     }
 
-                    return SDPUtil.filter_special_chars(id);
+                    return SDPUtil.filterSpecialChars(id);
                 };
 
                 /* eslint-disable no-global-assign, no-native-reassign */
                     return (
                         typeof id === 'number'
                             ? id
-                            : SDPUtil.filter_special_chars(id));
+                            : SDPUtil.filterSpecialChars(id));
                 };
 
-                this.pc_constraints = { optional: [] };
+                this.pcConstraints = { optional: [] };
 
                 // Allows sending of video to be suspended if the bandwidth
                 // estimation is too low.
                 if (!options.disableSuspendVideo) {
-                    this.pc_constraints.optional.push(
+                    this.pcConstraints.optional.push(
                         { googSuspendBelowMinBitrate: true });
                 }
 
                 if (options.useIPv6) {
                     // https://code.google.com/p/webrtc/issues/detail?id=2828
-                    this.pc_constraints.optional.push({ googIPv6: true });
+                    this.pcConstraints.optional.push({ googIPv6: true });
                 }
 
                 if (!webkitMediaStream.prototype.getVideoTracks) {
                             return attachMediaStream(element, stream);
                         });
                     this.getStreamID
-                        = stream => SDPUtil.filter_special_chars(stream.label);
+                        = stream => SDPUtil.filterSpecialChars(stream.label);
 
                     onReady(
                         options,
 
     /**
     * @param {string[]} um required user media types
-    * @param {function} success_callback
-    * @param {Function} failure_callback
+    * @param {function} successCallback
+    * @param {Function} failureCallback
     * @param {Object} [options] optional parameters
     * @param {string} options.resolution
     * @param {number} options.bandwidth
     **/
     getUserMediaWithConstraints(
             um,
-            success_callback,
-            failure_callback,
+            successCallback,
+            failureCallback,
             options = {}) {
         const constraints = getConstraints(um, options);
 
                 stream => {
                     logger.log('onUserMediaSuccess');
                     setAvailableDevices(um, stream);
-                    success_callback(stream);
+                    successCallback(stream);
                 },
                 error => {
                     setAvailableDevices(um, undefined);
                     logger.warn('Failed to get access to local media. Error ',
                         error, constraints);
 
-                    if (failure_callback) {
-                        failure_callback(
+                    if (failureCallback) {
+                        failureCallback(
                             new JitsiTrackError(error, constraints, um));
                     }
                 });
         } catch (e) {
             logger.error('GUM failed: ', e);
 
-            if (failure_callback) {
-                failure_callback(new JitsiTrackError(e, constraints, um));
+            if (failureCallback) {
+                failureCallback(new JitsiTrackError(e, constraints, um));
             }
         }
     }

modules/RTC/TraceablePeerConnection.js

  * @param {RTC} rtc the instance of <tt>RTC</tt> service
  * @param {number} id the peer connection id assigned by the parent RTC module.
  * @param {SignalingLayer} signalingLayer the signaling layer instance
- * @param {object} ice_config WebRTC 'PeerConnection' ICE config
+ * @param {object} iceConfig WebRTC 'PeerConnection' ICE config
  * @param {object} constraints WebRTC 'PeerConnection' constraints
  * @param {object} options <tt>TracablePeerConnection</tt> config options.
  * @param {boolean} options.disableSimulcast if set to 'true' will disable
  *
  * @constructor
  */
-function TraceablePeerConnection(rtc, id, signalingLayer, ice_config,
+function TraceablePeerConnection(rtc, id, signalingLayer, iceConfig,
                                  constraints, options) {
     const self = this;
 
     } else {
         RTCPeerConnectionType = webkitRTCPeerConnection;
     }
-    this.peerconnection = new RTCPeerConnectionType(ice_config, constraints);
+    this.peerconnection = new RTCPeerConnectionType(iceConfig, constraints);
     this.updateLog = [];
     this.stats = {};
     this.statsinterval = null;
         return;
     }
 
-    let ssrcLines = SDPUtil.find_lines(mediaLines[0], 'a=ssrc:');
+    let ssrcLines = SDPUtil.findLines(mediaLines[0], 'a=ssrc:');
 
     ssrcLines = ssrcLines.filter(
         line => {
             && offer.media && answer.media
             && offer.media.length === answer.media.length) {
         answer.media.forEach((a, i) => {
-            if (SDPUtil.find_line(
+            if (SDPUtil.findLine(
                     offer.media[i],
                     'a=setup:actpass',
                     offer.session)) {

modules/statistics/CallStats.js

  * @return a function which invokes f in a try/catch block, logs any exception
  * to the console, and then swallows it
  */
-function _try_catch(f) {
+function tryCatch(f) {
     return function() {
         try {
             f.apply(this, arguments); // eslint-disable-line prefer-rest-params
  * @param peerConnection {JingleSessionPC} the session object
  * @param options {object} credentials for callstats.
  */
-const CallStats = _try_catch(function(jingleSession, options) {
+const CallStats = tryCatch(function(jingleSession, options) {
     try {
         CallStats.feedbackEnabled = false;
         callStats = new callstats($, io, jsSHA); // eslint-disable-line new-cap
     MST_WITH_USERID: 'mstWithUserID'
 };
 
-CallStats.prototype.pcCallback = _try_catch((err, msg) => {
+CallStats.prototype.pcCallback = tryCatch((err, msg) => {
     if (callStats && err !== 'success') {
         logger.error(`Monitoring status: ${err} msg: ${msg}`);
     }
     // 'jitsi' is default remote user ID for now
     const callStatsId = isLocal ? this.userID : DEFAULT_REMOTE_USER;
 
-    _try_catch(function() {
+    tryCatch(function() {
         logger.debug(
             'Calling callStats.associateMstWithUserID with:',
             this.peerconnection,
  * @param type {String} "audio"/"video"
  * @param {CallStats} cs callstats instance related to the event
  */
-CallStats.sendMuteEvent = _try_catch((mute, type, cs) => {
+CallStats.sendMuteEvent = tryCatch((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((start, cs) => {
+CallStats.sendScreenSharingEvent = tryCatch((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(cs => {
+CallStats.sendDominantSpeakerEvent = tryCatch(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((devicesData, cs) => {
+CallStats.sendActiveDeviceListEvent = tryCatch((devicesData, cs) => {
     CallStats._reportEvent.call(cs, fabricEvent.activeDeviceList, devicesData);
 });
 
 /**
  * Notifies CallStats for connection setup errors
  */
-CallStats.prototype.sendTerminateEvent = _try_catch(function() {
+CallStats.prototype.sendTerminateEvent = tryCatch(function() {
     if (!CallStats.initialized) {
         return;
     }
  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.prototype.sendIceConnectionFailedEvent = _try_catch((pc, cs) => {
+CallStats.prototype.sendIceConnectionFailedEvent = tryCatch((pc, cs) => {
     CallStats._reportError.call(
         cs, wrtcFuncNames.iceConnectionFailure, null, pc);
 });
  * user feedback
  * @param detailedFeedback detailed feedback from the user. Not yet used
  */
-CallStats.prototype.sendFeedback = _try_catch(
+CallStats.prototype.sendFeedback = tryCatch(
 function(overallFeedback, detailedFeedback) {
     if (!CallStats.feedbackEnabled) {
         return;
  * @param {Error} e error to send
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendGetUserMediaFailed = _try_catch((e, cs) => {
+CallStats.sendGetUserMediaFailed = tryCatch((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((e, pc, cs) => {
+CallStats.sendCreateOfferFailed = tryCatch((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((e, pc, cs) => {
+CallStats.sendCreateAnswerFailed = tryCatch((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((e, pc, cs) => {
+CallStats.sendSetLocalDescFailed = tryCatch((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((e, pc, cs) => {
+CallStats.sendSetRemoteDescFailed = tryCatch((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((e, pc, cs) => {
+CallStats.sendAddIceCandidateFailed = tryCatch((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((e, cs) => {
+CallStats.sendApplicationLog = tryCatch((e, cs) => {
     CallStats._reportError.call(cs, wrtcFuncNames.applicationLog, e, null);
 });
 

modules/xmpp/JingleSession.js

      * @param {string} localJid our JID
      * @param {string} peerjid the JID of the remote peer
      * @param {Strophe.Connection} connection the XMPP connection
-     * @param {Object} media_constraints the media constraints object passed to
+     * @param {Object} mediaConstraints the media constraints object passed to
      * the PeerConnection onCreateAnswer/Offer as defined by the WebRTC.
-     * @param {Object} ice_config the ICE servers config object as defined by
+     * @param {Object} iceConfig the ICE servers config object as defined by
      * the WebRTC. Passed to the PeerConnection's constructor.
      */
     constructor(sid,
-                localJid, peerjid, connection, media_constraints, ice_config) {
+                localJid, peerjid, connection, mediaConstraints, iceConfig) {
         this.sid = sid;
         this.localJid = localJid;
         this.peerjid = peerjid;
         this.connection = connection;
-        this.media_constraints = media_constraints;
-        this.ice_config = ice_config;
+        this.mediaConstraints = mediaConstraints;
+        this.iceConfig = iceConfig;
 
         /**
          * Whether to use dripping or not. Dripping is sending trickle
         /**
          *  When dripping is used, stores ICE candidates which are to be sent.
          */
-        this.drip_container = [];
+        this.dripContainer = [];
 
         /**
          * The chat room instance associated with the session.

modules/xmpp/JingleSessionPC.js

      * @param {string} peerjid remote peer JID
      * @param {Strophe.Connection} connection Strophe XMPP connection instance
      * used to send packets.
-     * @param media_constraints the media constraints object passed to
+     * @param mediaConstraints the media constraints object passed to
      * createOffer/Answer, as defined by the WebRTC standard
-     * @param ice_config the ICE servers config object as defined by the WebRTC
+     * @param iceConfig the ICE servers config object as defined by the WebRTC
      * standard.
      * @param {object} options a set of config options
      * @param {boolean} options.webrtcIceUdpDisable <tt>true</tt> to block UDP
      * @implements {SignalingLayer}
      */
     constructor(sid, me, peerjid, connection,
-                media_constraints, ice_config, options) {
-        super(sid, me, peerjid, connection, media_constraints, ice_config);
+                mediaConstraints, iceConfig, options) {
+        super(sid, me, peerjid, connection, mediaConstraints, iceConfig);
 
         this.lasticecandidate = false;
         this.closed = false;
         this.peerconnection
             = this.rtc.createPeerConnection(
                 this,
-                this.connection.jingle.ice_config,
+                this.connection.jingle.iceConfig,
 
                 /* Options */
                 {
             ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
 
             if (this.usedrip) {
-                if (this.drip_container.length === 0) {
+                if (this.dripContainer.length === 0) {
                     // start 20ms callout
                     setTimeout(() => {
-                        if (this.drip_container.length === 0) {
+                        if (this.dripContainer.length === 0) {
                             return;
                         }
-                        this.sendIceCandidates(this.drip_container);
-                        this.drip_container = [];
+                        this.sendIceCandidates(this.dripContainer);
+                        this.dripContainer = [];
                     }, 20);
                 }
-                this.drip_container.push(candidate);
+                this.dripContainer.push(candidate);
             } else {
                 this.sendIceCandidates([ candidate ]);
             }
         for (let mid = 0; mid < localSDP.media.length; mid++) {
             const cands = candidates.filter(el => el.sdpMLineIndex === mid);
             const mline
-                = SDPUtil.parse_mline(localSDP.media[mid].split('\r\n')[0]);
+                = SDPUtil.parseMLine(localSDP.media[mid].split('\r\n')[0]);
 
             if (cands.length > 0) {
                 const ice
                 }
 
                 // add fingerprint
-                const fingerprint_line
-                    = SDPUtil.find_line(
+                const fingerprintLine
+                    = SDPUtil.findLine(
                         localSDP.media[mid],
                         'a=fingerprint:', localSDP.session);
 
-                if (fingerprint_line) {
-                    const tmp = SDPUtil.parse_fingerprint(fingerprint_line);
+                if (fingerprintLine) {
+                    const tmp = SDPUtil.parseFingerprint(fingerprintLine);
 
                     tmp.required = true;
                     cand.c(
             });
 
         localSDP.media.forEach((medialines, idx) => {
-            const mline = SDPUtil.parse_mline(medialines.split('\r\n')[0]);
+            const mline = SDPUtil.parseMLine(medialines.split('\r\n')[0]);
 
             transportAccept.c('content',
                 {
                 });
             });
             currentRemoteSdp.media.forEach((media, idx) => {
-                if (!SDPUtil.find_line(media, `a=mid:${name}`)) {
+                if (!SDPUtil.findLine(media, `a=mid:${name}`)) {
                     return;
                 }
                 if (!addSsrcInfo[idx]) {
      *  rejects with an error {string}
      */
     _renegotiate(optionalRemoteSdp) {
-        const media_constraints = this.media_constraints;
+        const mediaConstraints = this.mediaConstraints;
         const remoteSdp
             = optionalRemoteSdp
                 || new SDP(this.peerconnection.remoteDescription.sdp);
                             );
                         },
                         error => reject(`createAnswer failed: ${error}`),
-                        media_constraints
+                        mediaConstraints
                     );
                 },
                 error => {
                 ssrcs.push(ssrc);
             });
             currentRemoteSdp.media.forEach((media, idx) => {
-                if (!SDPUtil.find_line(media, `a=mid:${name}`)) {
+                if (!SDPUtil.findLine(media, `a=mid:${name}`)) {
                     return;
                 }
                 if (!removeSsrcInfo[idx]) {
                 }
                 ssrcs.forEach(ssrc => {
                     const ssrcLines
-                        = SDPUtil.find_lines(media, `a=ssrc:${ssrc}`);
+                        = SDPUtil.findLines(media, `a=ssrc:${ssrc}`);
 
                     if (ssrcLines.length) {
                         removeSsrcInfo[idx] += `${ssrcLines.join('\r\n')}\r\n`;
 
     /**
      * Figures out added/removed ssrcs and send update IQs.
-     * @param old_sdp SDP object for old description.
-     * @param new_sdp SDP object for new description.
+     * @param oldSDP SDP object for old description.
+     * @param newSDP SDP object for new description.
      */
-    notifyMySSRCUpdate(old_sdp, new_sdp) {
+    notifyMySSRCUpdate(oldSDP, newSDP) {
 
         if (this.state !== JingleSessionState.ACTIVE) {
             logger.warn(`Skipping SSRC update in '${this.state} ' state.`);
         }
 
         // send source-remove IQ.
-        let sdpDiffer = new SDPDiffer(new_sdp, old_sdp);
+        let sdpDiffer = new SDPDiffer(newSDP, oldSDP);
         const remove = $iq({ to: this.peerjid,
             type: 'set' })
             .c('jingle', {
         }
 
         // send source-add IQ.
-        sdpDiffer = new SDPDiffer(old_sdp, new_sdp);
+        sdpDiffer = new SDPDiffer(oldSDP, newSDP);
         const add = $iq({ to: this.peerjid,
             type: 'set' })
             .c('jingle', {

modules/xmpp/SDP.js

     const media = sdp.split('\r\nm=');
 
     for (let i = 1, length = media.length; i < length; i++) {
-        let media_i = `m=${media[i]}`;
+        let mediaI = `m=${media[i]}`;
 
         if (i !== length - 1) {
-            media_i += '\r\n';
+            mediaI += '\r\n';
         }
-        media[i] = media_i;
+        media[i] = mediaI;
     }
     const session = `${media.shift()}\r\n`;
 
  */
 SDP.prototype.getMediaSsrcMap = function() {
     const self = this;
-    const media_ssrcs = {};
+    const mediaSSRCs = {};
     let tmp;
 
     for (let mediaindex = 0; mediaindex < self.media.length; mediaindex++) {
-        tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc:');
+        tmp = SDPUtil.findLines(self.media[mediaindex], 'a=ssrc:');
         const mid
-            = SDPUtil.parse_mid(
-                SDPUtil.find_line(self.media[mediaindex],
+            = SDPUtil.parseMID(
+                SDPUtil.findLine(self.media[mediaindex],
                 'a=mid:'));
         const media = {
             mediaindex,
             ssrcGroups: []
         };
 
-        media_ssrcs[mediaindex] = media;
+        mediaSSRCs[mediaindex] = media;
         tmp.forEach(line => {
             const linessrc = line.substring(7).split(' ')[0];
 
             }
             media.ssrcs[linessrc].lines.push(line);
         });
-        tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc-group:');
+        tmp = SDPUtil.findLines(self.media[mediaindex], 'a=ssrc-group:');
         tmp.forEach(line => {
             const idx = line.indexOf(' ');
             const semantics = line.substr(0, idx).substr(13);
         });
     }
 
-    return media_ssrcs;
+    return mediaSSRCs;
 };
 
 /**
     for (i = 0; i < this.media.length; i++) {
         lines = this.media[i].split('\r\n');
         lines.pop(); // remove empty last element
-        mline = SDPUtil.parse_mline(lines.shift());
+        mline = SDPUtil.parseMLine(lines.shift());
         if (mline.media !== 'audio') {
             continue; // eslint-disable-line no-continue
         }
         mline.fmt.length = 0;
         for (j = 0; j < lines.length; j++) {
             if (lines[j].substr(0, 9) === 'a=rtpmap:') {
-                rtpmap = SDPUtil.parse_rtpmap(lines[j]);
+                rtpmap = SDPUtil.parseRTPMap(lines[j]);
                 if (rtpmap.name === 'CN' || rtpmap.name === 'ISAC') {
                     continue; // eslint-disable-line no-continue
                 }
             }
             newdesc += `${lines[j]}\r\n`;
         }
-        this.media[i] = `${SDPUtil.build_mline(mline)}\r\n${newdesc}`;
+        this.media[i] = `${SDPUtil.buildMLine(mline)}\r\n${newdesc}`;
     }
     this.raw = this.session + this.media.join('');
 };
 // remove lines matching prefix from session section
 SDP.prototype.removeSessionLines = function(prefix) {
     const self = this;
-    const lines = SDPUtil.find_lines(this.session, prefix);
+    const lines = SDPUtil.findLines(this.session, prefix);
 
     lines.forEach(line => {
         self.session = self.session.replace(`${line}\r\n`, '');
 // TODO: non-numeric mediaindex could match mid
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
     const self = this;
-    const lines = SDPUtil.find_lines(this.media[mediaindex], prefix);
+    const lines = SDPUtil.findLines(this.media[mediaindex], prefix);
 
     lines.forEach(line => {
         self.media[mediaindex]
 
     // new bundle plan
 
-    lines = SDPUtil.find_lines(this.session, 'a=group:');
+    lines = SDPUtil.findLines(this.session, 'a=group:');
     if (lines.length) {
         for (i = 0; i < lines.length; i++) {
             tmp = lines[i].split(' ');
         }
     }
     for (i = 0; i < this.media.length; i++) {
-        mline = SDPUtil.parse_mline(this.media[i].split('\r\n')[0]);
+        mline = SDPUtil.parseMLine(this.media[i].split('\r\n')[0]);
         if (!(mline.media === 'audio'
               || mline.media === 'video'
               || mline.media === 'application')) {
             continue; // eslint-disable-line no-continue
         }
-        const assrcline = SDPUtil.find_line(this.media[i], 'a=ssrc:');
+        const assrcline = SDPUtil.findLine(this.media[i], 'a=ssrc:');
 
         if (assrcline) {
             ssrc = assrcline.substring(7).split(' ')[0]; // take the first
 
         elem.c('content', { creator: thecreator,
             name: mline.media });
-        const amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
+        const amidline = SDPUtil.findLine(this.media[i], 'a=mid:');
 
         if (amidline) {
             // prefer identifier from a=mid if present
-            const mid = SDPUtil.parse_mid(amidline);
+            const mid = SDPUtil.parseMID(amidline);
 
             elem.attrs({ name: mid });
         }
 
-        if (SDPUtil.find_line(this.media[i], 'a=rtpmap:').length) {
+        if (SDPUtil.findLine(this.media[i], 'a=rtpmap:').length) {
             elem.c('description',
                 { xmlns: 'urn:xmpp:jingle:apps:rtp:1',
                     media: mline.media });
             }
             for (j = 0; j < mline.fmt.length; j++) {
                 rtpmap
-                    = SDPUtil.find_line(
+                    = SDPUtil.findLine(
                         this.media[i],
                         `a=rtpmap:${mline.fmt[j]}`);
-                elem.c('payload-type', SDPUtil.parse_rtpmap(rtpmap));
+                elem.c('payload-type', SDPUtil.parseRTPMap(rtpmap));
 
                 // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo
                 // value=bar/>
                 const afmtpline
-                    = SDPUtil.find_line(
+                    = SDPUtil.findLine(
                         this.media[i],
                         `a=fmtp:${mline.fmt[j]}`);
 
                 if (afmtpline) {
-                    tmp = SDPUtil.parse_fmtp(afmtpline);
+                    tmp = SDPUtil.parseFmtp(afmtpline);
                     for (k = 0; k < tmp.length; k++) {
                         elem.c('parameter', tmp[k]).up();
                     }
                 elem.up();
             }
             const crypto
-                = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
+                = SDPUtil.findLines(this.media[i], 'a=crypto:', this.session);
 
             if (crypto.length) {
                 elem.c('encryption', { required: 1 });
                 crypto.forEach(
-                    line => elem.c('crypto', SDPUtil.parse_crypto(line)).up());
+                    line => elem.c('crypto', SDPUtil.parseCrypto(line)).up());
                 elem.up(); // end of encryption
             }
 
                     xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
 
                 // FIXME: group by ssrc and support multiple different ssrcs
-                const ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
+                const ssrclines = SDPUtil.findLines(this.media[i], 'a=ssrc:');
 
                 if (ssrclines.length > 0) {
                     // eslint-disable-next-line no-loop-func
 
                             let v = kv.split(':', 2)[1];
 
-                            v = SDPUtil.filter_special_chars(v);
+                            v = SDPUtil.filterSpecialChars(v);
                             elem.attrs({ value: v });
                         }
                         elem.up();
                         msid = localTrack.getTrackId();
                     }
                     if (msid !== null) {
-                        msid = SDPUtil.filter_special_chars(msid);
+                        msid = SDPUtil.filterSpecialChars(msid);
                         elem.c('parameter');
                         elem.attrs({ name: 'msid',
                             value: msid });
                 elem.up();
 
                 // XEP-0339 handle ssrc-group attributes
-                const ssrc_group_lines
-                    = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
+                const ssrcGroupLines
+                    = SDPUtil.findLines(this.media[i], 'a=ssrc-group:');
 
-                ssrc_group_lines.forEach(line => {
+                ssrcGroupLines.forEach(line => {
                     const idx = line.indexOf(' ');
                     const semantics = line.substr(0, idx).substr(13);
                     const ssrcs = line.substr(14 + semantics.length).split(' ');
                 });
             }
 
-            if (SDPUtil.find_line(this.media[i], 'a=rtcp-mux')) {
+            if (SDPUtil.findLine(this.media[i], 'a=rtcp-mux')) {
                 elem.c('rtcp-mux').up();
             }
 
             this.rtcpFbToJingle(i, elem, '*');
 
             // XEP-0294
-            lines = SDPUtil.find_lines(this.media[i], 'a=extmap:');
+            lines = SDPUtil.findLines(this.media[i], 'a=extmap:');
             if (lines.length) {
                 for (j = 0; j < lines.length; j++) {
-                    tmp = SDPUtil.parse_extmap(lines[j]);
+                    tmp = SDPUtil.parseExtmap(lines[j]);
                     elem.c('rtp-hdrext', {
                         xmlns: 'urn:xmpp:jingle:apps:rtp:rtp-hdrext:0',
                         uri: tmp.uri,
 
         const m = this.media[i];
 
-        if (SDPUtil.find_line(m, 'a=sendrecv', this.session)) {
+        if (SDPUtil.findLine(m, 'a=sendrecv', this.session)) {
             elem.attrs({ senders: 'both' });
-        } else if (SDPUtil.find_line(m, 'a=sendonly', this.session)) {
+        } else if (SDPUtil.findLine(m, 'a=sendonly', this.session)) {
             elem.attrs({ senders: 'initiator' });
-        } else if (SDPUtil.find_line(m, 'a=recvonly', this.session)) {
+        } else if (SDPUtil.findLine(m, 'a=recvonly', this.session)) {
             elem.attrs({ senders: 'responder' });
-        } else if (SDPUtil.find_line(m, 'a=inactive', this.session)) {
+        } else if (SDPUtil.findLine(m, 'a=inactive', this.session)) {
             elem.attrs({ senders: 'none' });
         }
         if (mline.port === '0') {
 
     // XEP-0343 DTLS/SCTP
     const sctpmap
-        = SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:', self.session);
+        = SDPUtil.findLine(this.media[mediaindex], 'a=sctpmap:', self.session);
 
     if (sctpmap) {
-        const sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
+        const sctpAttrs = SDPUtil.parseSCTPMap(sctpmap);
 
         elem.c('sctpmap', {
             xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
 
     // XEP-0320
     const fingerprints
-        = SDPUtil.find_lines(
+        = SDPUtil.findLines(
             this.media[mediaindex],
             'a=fingerprint:',
             this.session);
 
     fingerprints.forEach(line => {
-        tmp = SDPUtil.parse_fingerprint(line);
+        tmp = SDPUtil.parseFingerprint(line);
         tmp.xmlns = 'urn:xmpp:jingle:apps:dtls:0';
         elem.c('fingerprint').t(tmp.fingerprint);
         delete tmp.fingerprint;
 
         // eslint-disable-next-line no-param-reassign
         line
-            = SDPUtil.find_line(
+            = SDPUtil.findLine(
                 self.media[mediaindex],
                 'a=setup:',
                 self.session);
 
         // XEP-0176
         const lines
-            = SDPUtil.find_lines(
+            = SDPUtil.findLines(
                 this.media[mediaindex],
                 'a=candidate:',
                 this.session);
 // XEP-0293
 SDP.prototype.rtcpFbToJingle = function(mediaindex, elem, payloadtype) {
     const lines
-        = SDPUtil.find_lines(
+        = SDPUtil.findLines(
             this.media[mediaindex],
             `a=rtcp-fb:${payloadtype}`);
 
     lines.forEach(line => {
-        const tmp = SDPUtil.parse_rtcpfb(line);
+        const tmp = SDPUtil.parseRTCPFB(line);
 
         if (tmp.type === 'trr-int') {
             elem.c('rtcp-fb-trr-int', {
 
     // reconstruct msid-semantic -- apparently not necessary
     /*
-     var msid = SDPUtil.parse_ssrc(this.raw);
+     var msid = SDPUtil.parseSSRC(this.raw);
      if (msid.hasOwnProperty('mslabel')) {
      this.session += "a=msid-semantic: WMS " + msid.mslabel + "\r\n";
      }
                     return this.getAttribute('id');
                 })
                 .get();
-        media += `${SDPUtil.build_mline(tmp)}\r\n`;
+        media += `${SDPUtil.buildMLine(tmp)}\r\n`;
     }
 
     media += 'c=IN IP4 0.0.0.0\r\n';
             '>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]');
     if (tmp.length) {
         if (tmp.attr('ufrag')) {
-            media += `${SDPUtil.build_iceufrag(tmp.attr('ufrag'))}\r\n`;
+            media += `${SDPUtil.buildICEUfrag(tmp.attr('ufrag'))}\r\n`;
         }
         if (tmp.attr('pwd')) {
-            media += `${SDPUtil.build_icepwd(tmp.attr('pwd'))}\r\n`;
+            media += `${SDPUtil.buildICEPwd(tmp.attr('pwd'))}\r\n`;
         }
         tmp.find('>fingerprint').each(function() {
             // FIXME: check namespace at some point
         });
     }
     desc.find('payload-type').each(function() {
-        media += `${SDPUtil.build_rtpmap(this)}\r\n`;
+        media += `${SDPUtil.buildRTPMap(this)}\r\n`;
         if ($(this).find('>parameter').length) {
             media += `a=fmtp:${this.getAttribute('id')} `;
             media
             const name = this.getAttribute('name');
             let value = this.getAttribute('value');
 
-            value = SDPUtil.filter_special_chars(value);
+            value = SDPUtil.filterSpecialChars(value);
             media += `a=ssrc:${ssrc} ${name}`;
             if (value && value.length) {
                 media += `:${value}`;

modules/xmpp/SDPDiffer.js

                 } else {
                     const nv = kv.split(':', 2);
                     const name = nv[0];
-                    const value = SDPUtil.filter_special_chars(nv[1]);
+                    const value = SDPUtil.filterSpecialChars(nv[1]);
 
                     modify.attrs({ name });
                     modify.attrs({ value });

modules/xmpp/SDPUtil.js

 const RTCBrowserType = require('../RTC/RTCBrowserType');
 
 const SDPUtil = {
-    filter_special_chars(text) {
+    filterSpecialChars(text) {
         // XXX Neither one of the falsy values (e.g. null, undefined, false,
         // "", etc.) "contain" special chars.
         // eslint-disable-next-line no-useless-escape
         let data = null;
         let pwd, ufrag;
 
-        if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
+        if ((ufrag = SDPUtil.findLine(mediadesc, 'a=ice-ufrag:', sessiondesc))
                 && (pwd
-                    = SDPUtil.find_line(
+                    = SDPUtil.findLine(
                         mediadesc,
                         'a=ice-pwd:',
                         sessiondesc))) {
             data = {
-                ufrag: SDPUtil.parse_iceufrag(ufrag),
-                pwd: SDPUtil.parse_icepwd(pwd)
+                ufrag: SDPUtil.parseICEUfrag(ufrag),
+                pwd: SDPUtil.parseICEPwd(pwd)
             };
         }
 
         return data;
     },
-    parse_iceufrag(line) {
+    parseICEUfrag(line) {
         return line.substring(12);
     },
-    build_iceufrag(frag) {
+    buildICEUfrag(frag) {
         return `a=ice-ufrag:${frag}`;
     },
-    parse_icepwd(line) {
+    parseICEPwd(line) {
         return line.substring(10);
     },
-    build_icepwd(pwd) {
+    buildICEPwd(pwd) {
         return `a=ice-pwd:${pwd}`;
     },
-    parse_mid(line) {
+    parseMID(line) {
         return line.substring(6);
     },
-    parse_mline(line) {
+    parseMLine(line) {
         const data = {};
         const parts = line.substring(2).split(' ');
 
 
         return data;
     },
-    build_mline(mline) {
+    buildMLine(mline) {
         return (
             `m=${mline.media} ${mline.port} ${mline.proto} ${
                 mline.fmt.join(' ')}`);
     },
-    parse_rtpmap(line) {
+    parseRTPMap(line) {
         const data = {};
         let parts = line.substring(9).split(' ');
 
      * @param line eg. "a=sctpmap:5000 webrtc-datachannel"
      * @returns [SCTP port number, protocol, streams]
      */
-    parse_sctpmap(line) {
+    parseSCTPMap(line) {
         const parts = line.substring(10).split(' ');
         const sctpPort = parts[0];
         const protocol = parts[1];
 
         return [ sctpPort, protocol, streamCount ];// SCTP port
     },
-    build_rtpmap(el) {
+    buildRTPMap(el) {
         let line
             = `a=rtpmap:${el.getAttribute('id')} ${el.getAttribute('name')}/${
                 el.getAttribute('clockrate')}`;
 
         return line;
     },
-    parse_crypto(line) {
+    parseCrypto(line) {
         const data = {};
         const parts = line.substring(9).split(' ');
 
 
         return data;
     },
-    parse_fingerprint(line) { // RFC 4572
+    parseFingerprint(line) { // RFC 4572
         const data = {};
         const parts = line.substring(14).split(' ');
 
         // TODO assert that fingerprint satisfies 2UHEX *(":" 2UHEX) ?
         return data;
     },
-    parse_fmtp(line) {
+    parseFmtp(line) {
         const data = [];
         let parts = line.split(' ');
 
 
         return data;
     },
-    parse_icecandidate(line) {
+    parseICECandidate(line) {
         const candidate = {};
         const elems = line.split(' ');
 
                 break;
             default: // TODO
                 logger.log(
-                    `parse_icecandidate not translating "${
+                    `parseICECandidate not translating "${
                         elems[i]}" = "${elems[i + 1]}"`);
             }
         }
 
         return candidate;
     },
-    build_icecandidate(cand) {
+    buildICECandidate(cand) {
         let line = [
             `a=candidate:${cand.foundation}`,
             cand.component,
 
         return line;
     },
-    parse_ssrc(desc) {
+    parseSSRC(desc) {
         // proprietary mapping of a=ssrc lines
         // TODO: see "Jingle RTP Source Description" by Juberti and P. Thatcher
         // on google docs and parse according to that
 
         return data;
     },
-    parse_rtcpfb(line) {
+    parseRTCPFB(line) {
         const parts = line.substr(10).split(' ');
         const data = {};
 
 
         return data;
     },
-    parse_extmap(line) {
+    parseExtmap(line) {
         const parts = line.substr(9).split(' ');
         const data = {};
 
 
         return data;
     },
-    find_line(haystack, needle, sessionpart) {
+    findLine(haystack, needle, sessionpart) {
         let lines = haystack.split('\r\n');
 
         for (let i = 0; i < lines.length; i++) {
 
         return false;
     },
-    find_lines(haystack, needle, sessionpart) {
+    findLines(haystack, needle, sessionpart) {
         let lines = haystack.split('\r\n');
         const needles = [];
 

modules/xmpp/SDPUtil.spec.js

 describe('SDPUtil', () => {
     it('should parse an ice ufrag correctly', () => {
         const line = 'a=ice-ufrag:3jlcc1b3j1rqt6';
-        const parsed = SDPUtil.parse_iceufrag(line);
+        const parsed = SDPUtil.parseICEUfrag(line);
 
         expect(parsed).toEqual('3jlcc1b3j1rqt6');
     });

modules/xmpp/strophe.jingle.js

         this.xmpp = xmpp;
         this.eventEmitter = eventEmitter;
         this.sessions = {};
-        this.ice_config = { iceServers: [] };
-        this.media_constraints = {
+        this.iceConfig = { iceServers: [] };
+        this.mediaConstraints = {
             mandatory: {
                 'OfferToReceiveAudio': true,
                 'OfferToReceiveVideo': true
                         $(iq).attr('to'),
                         fromJid,
                         this.connection,
-                        this.media_constraints,
-                        this.ice_config, this.xmpp.options);
+                        this.mediaConstraints,
+                        this.iceConfig, this.xmpp.options);
 
             this.sessions[sess.sid] = sess;
 
                     }
                     }
                 });
-                this.ice_config.iceServers = iceservers;
+                this.iceConfig.iceServers = iceservers;
             }, err => {
                 logger.warn('getting turn credentials failed', err);
                 logger.warn('is mod_turncredentials or similar installed?');

modules/xmpp/strophe.logger.js

 
     init(connection) {
         super.init(connection);
-        this.connection.rawInput = this.log_incoming.bind(this);
-        this.connection.rawOutput = this.log_outgoing.bind(this);
+        this.connection.rawInput = this.logIncoming.bind(this);
+        this.connection.rawOutput = this.logOutgoing.bind(this);
     }
 
-    log_incoming(stanza) {
+    logIncoming(stanza) {
         this.log.push([ new Date().getTime(), 'incoming', stanza ]);
     }
 
-    log_outgoing(stanza) {
+    logOutgoing(stanza) {
         this.log.push([ new Date().getTime(), 'outgoing', stanza ]);
     }
 }

modules/xmpp/strophe.rayo.js

                 // eslint-disable-next-line newline-per-chained-call
                 const resource = $(result).find('ref').attr('uri');
 
-                this.call_resource = resource.substr('xmpp:'.length);
-                logger.info(`Received call resource: ${this.call_resource}`);
+                this.callResource = resource.substr('xmpp:'.length);
+                logger.info(`Received call resource: ${this.callResource}`);
                 resolve();
             }, error => {
                 logger.info('Dial error ', error);
 
     hangup() {
         return new Promise((resolve, reject) => {
-            if (!this.call_resource) {
+            if (!this.callResource) {
                 reject(new Error('No call in progress'));
                 logger.warn('No call in progress');
 
 
             const req = $iq({
                 type: 'set',
-                to: this.call_resource
+                to: this.callResource
             });
 
             req.c('hangup', {
 
             this.connection.sendIQ(req, result => {
                 logger.info('Hangup result ', result);
-                this.call_resource = null;
+                this.callResource = null;
                 resolve();
             }, error => {
                 logger.info('Hangup error ', error);
-                this.call_resource = null;
+                this.callResource = null;
                 reject(new Error('Hangup error '));
             });
         });