fix(eslint): Add no-else-return rule

.eslintrc.js

         'no-caller': 2,
         'no-case-declarations': 2,
         'no-div-regex': 0,
+        'no-else-return': 2,
         'no-empty-pattern': 2,
         'no-eval': 2,
         'no-extend-native': 2,

JitsiConference.js

             // to attempt to add the same local video track twice.
             if (track === localVideoTrack) {
                 return Promise.resolve(track);
-            } else {
-                return Promise.reject(new Error(
-                    'cannot add second video track to the conference'));
             }
+            return Promise.reject(new Error(
+                    'cannot add second video track to the conference'));
+
         }
     }
 
 JitsiConference.prototype._doReplaceTrack = function(oldTrack, newTrack) {
     if (this.jingleSession) {
         return this.jingleSession.replaceTrack(oldTrack, newTrack);
-    } else {
-        return Promise.resolve();
     }
+    return Promise.resolve();
+
 };
 
 /**
 JitsiConference.prototype.getConnectionState = function() {
     if (this.jingleSession) {
         return this.jingleSession.getIceConnectionState();
-    } else {
-        return null;
     }
+    return null;
+
 };
 
 /**

modules/RTC/DataChannels.js

     if (dataChannels && dataChannels.length !== 0) {
         if (thisArg) {
             return dataChannels.some(callback, thisArg);
-        } else {
-            return dataChannels.some(callback);
         }
-    } else {
-        return false;
+        return dataChannels.some(callback);
+
     }
+    return false;
+
 };
 
 /**

modules/RTC/JitsiLocalTrack.js

     }
     if (this.isVideoTrack() && !this.isActive()) {
         return true;
-    } else {
-        return !this.track || !this.track.enabled;
     }
+    return !this.track || !this.track.enabled;
+
 };
 
 /**
         return this.ssrc.groups[0].ssrcs[0];
     } else if(this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length) {
         return this.ssrc.ssrcs[0];
-    } else {
-        return null;
     }
+    return null;
+
 };
 
 /**

modules/RTC/JitsiTrack.js

 JitsiTrack.prototype.getUsageLabel = function() {
     if (this.isAudioTrack()) {
         return 'mic';
-    } else {
-        return this.videoType ? this.videoType : 'default';
     }
+    return this.videoType ? this.videoType : 'default';
+
 };
 
 /**
 JitsiTrack.prototype.getId = function() {
     if(this.stream) {
         return RTCUtils.getStreamID(this.stream);
-    } else {
-        return null;
     }
+    return null;
+
 };
 
 /**
 JitsiTrack.prototype.isActive = function() {
     if(typeof this.stream.active !== 'undefined') {
         return this.stream.active;
-    } else {
-        return true;
     }
+    return true;
+
 };
 
 /**

modules/RTC/RTC.js

             // NOTE Remote tracks are not removed here.
             this.peerConnections.delete(id);
             return true;
-        } else {
-            return false;
         }
+        return false;
+
     }
 
     addLocalTrack(track) {
     getRemoteTrackByType(type, resource) {
         if (this.remoteTracks[resource]) {
             return this.remoteTracks[resource][type];
-        } else {
-            return null;
         }
+        return null;
+
     }
 
     /**
                         && mediaTrack.getTrackId() == trackId) {
                         result = mediaTrack;
                         return true;
-                    } else {
-                        return false;
                     }
+                    return false;
+
                 });
         });
 

modules/RTC/RTCUIHelper.js

         var videoElemName = RTCUIHelper.getVideoElementName();
         if (!RTCBrowserType.isTemasysPluginUsed()) {
             return $(containerElement).find(videoElemName)[0];
-        } else {
-            var matching = $(containerElement).find(
+        }
+        var matching = $(containerElement).find(
                 ' ' + videoElemName + '>param[value="video"]');
-            if (matching.length) {
-                if (matching.length > 1) {
-                    logger.warn(
+        if (matching.length) {
+            if (matching.length > 1) {
+                logger.warn(
                         'Container with more than one video elements: ',
                         containerElement);
-                }
-                return matching.parent()[0];
             }
+            return matching.parent()[0];
         }
+
         return undefined;
     },
     /**

modules/RTC/RTCUtils.js

     onRTCReady() {
         if (rtcReady) {
             return Promise.resolve();
-        } else {
-            return new Promise(resolve => {
-                const listener = () => {
-                    eventEmitter.removeListener(RTCEvents.RTC_READY, listener);
-                    resolve();
-                };
-                eventEmitter.addListener(RTCEvents.RTC_READY, listener);
+        }
+        return new Promise(resolve => {
+            const listener = () => {
+                eventEmitter.removeListener(RTCEvents.RTC_READY, listener);
+                resolve();
+            };
+            eventEmitter.addListener(RTCEvents.RTC_READY, listener);
                 // We have no failed event, so... it either resolves or nothing
                 // happens
-            });
-        }
+        });
+
     }
 
     /**

modules/statistics/RTPStatsCollector.js

         var key = keys[name];
         if (key) {
             return key;
-        } else {
-            throw 'The property \'' + name + '\' isn\'t supported!';
         }
+        throw 'The property \'' + name + '\' isn\'t supported!';
+
     };
 
     // Define the function which retrieves the value from a specific report
                 if (pair.hasOwnProperty(key)) {
                     value = pair[key];
                     return true;
-                } else {
-                    return false;
                 }
+                return false;
+
             });
             return value;
         };

modules/transcription/audioRecorder.js

         return AUDIO_WEBM;
     } else if(MediaRecorder.isTypeSupported(AUDIO_OGG)) {
         return AUDIO_OGG;
-    } else {
-        throw new Error('unable to create a MediaRecorder with the'
-            + 'right mimetype!');
     }
+    throw new Error('unable to create a MediaRecorder with the'
+            + 'right mimetype!');
+
 }
 
 /**
         return new MediaStream();
     } else if(typeof webkitMediaStream !== 'undefined') {
         return new webkitMediaStream(); // eslint-disable-line new-cap
-    } else {
-        throw new Error('cannot create a clean mediaStream');
     }
+    throw new Error('cannot create a clean mediaStream');
+
 }
 
 /**

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

         var toReturn = config.sphinxURL;
         if(toReturn.includes !== undefined && toReturn.includes('https://')) {
             return toReturn;
-        } else{
-            console.log(message);
         }
+        console.log(message);
+
     }
 }
 

modules/xmpp/ChatRoom.js

         var member = this.members[mucJid];
         if (member) {
             return member.isFocus;
-        } else {
-            return null;
         }
+        return null;
+
     }
 
     isModerator() {

modules/xmpp/RtxModifier.spec.js

     const videoMLine = parsedSdp.media.find(m => m.type === 'video');
     if (numVideoSsrcs(parsedSdp) === 1) {
         return [videoMLine.ssrcs[0].id];
-    } else {
-        const simGroups = getVideoGroups(parsedSdp, 'SIM');
-        if (simGroups.length > 1) {
-            return;
-        }
-        const simGroup = simGroups[0];
-        return SDPUtil.parseGroupSsrcs(simGroup);
     }
+    const simGroups = getVideoGroups(parsedSdp, 'SIM');
+    if (simGroups.length > 1) {
+        return;
+    }
+    const simGroup = simGroups[0];
+    return SDPUtil.parseGroupSsrcs(simGroup);
+
 }
 
 /**

modules/xmpp/SdpTransformUtil.js

 function _getSSRCCount(mLine) {
     if (!mLine.ssrcs) {
         return 0;
-    } else {
-        return mLine.ssrcs
+    }
+    return mLine.ssrcs
             .map(ssrcInfo => ssrcInfo.id)
             .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
             .length;
-    }
+
 }
 
 /**
         if (numSsrcs === 1) {
             // Not using _ssrcs on purpose here
             return this.mLine.ssrcs[0].id;
-        } else {
+        }
             // Look for a SIM or FID group
-            if (this.mLine.ssrcGroups) {
-                const simGroup = this.findGroup('SIM');
-                if (simGroup) {
-                    return parsePrimarySSRC(simGroup);
-                }
-                const fidGroup = this.findGroup('FID');
-                if (fidGroup) {
-                    return parsePrimarySSRC(fidGroup);
-                }
+        if (this.mLine.ssrcGroups) {
+            const simGroup = this.findGroup('SIM');
+            if (simGroup) {
+                return parsePrimarySSRC(simGroup);
+            }
+            const fidGroup = this.findGroup('FID');
+            if (fidGroup) {
+                return parsePrimarySSRC(fidGroup);
             }
         }
+
     }
 
     /**