Add missing semicolons, break some comments at line limit

modules/RTC/JitsiLocalTrack.js

  */
 JitsiLocalTrack.prototype.mute = function () {
     return createMuteUnmutePromise(this, true);
-}
+};
 
 /**
  * Unmutes the stream. Will reject the Promise if there is mute/unmute operation
  */
 JitsiLocalTrack.prototype.unmute = function () {
     return createMuteUnmutePromise(this, false);
-}
+};
 
 /**
  * Creates Promise for mute/unmute operation.
 
 /**
  * Mutes / unmutes the track.
- * @param mute {boolean} if true the track will be muted. Otherwise the track will be unmuted.
+ * @param mute {boolean} if true the track will be muted. Otherwise the track
+ * will be unmuted.
  */
 JitsiLocalTrack.prototype._setMute = function (mute, resolve, reject) {
     if (this.isMuted() === mute) {
                 });
         }
     }
-}
+};
 
 /**
  * Stops sending the media track. And removes it from the HTML.
  */
 JitsiLocalTrack.prototype._setSSRC = function (ssrc) {
     this.ssrc = ssrc;
-}
+};
 
 
 //FIXME: This dependacy is not necessary. This is quick fix.
  */
 JitsiLocalTrack.prototype._setConference = function(conference) {
     this.conference = conference;
-}
+};
 
 /**
  * Gets the SSRC of this local track if it's available already or <tt>null</tt>
  */
 JitsiLocalTrack.prototype.isLocal = function () {
     return true;
-}
+};
 
 module.exports = JitsiLocalTrack;

modules/RTC/JitsiRemoteTrack.js

 
 /**
  * Returns the current muted status of the track.
- * @returns {boolean|*|JitsiRemoteTrack.muted} <tt>true</tt> if the track is muted and <tt>false</tt> otherwise.
+ * @returns {boolean|*|JitsiRemoteTrack.muted} <tt>true</tt> if the track is
+ * muted and <tt>false</tt> otherwise.
  */
 JitsiRemoteTrack.prototype.isMuted = function () {
     return this.muted;
         return;
     this.videoType = type;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
-}
+};
 
 delete JitsiRemoteTrack.prototype.dispose;
 

modules/RTC/JitsiTrack.js

  */
 JitsiTrack.prototype.getOriginalStream = function() {
     return this.stream;
-}
+};
 
 /**
  * Return meaningful usage label for this track depending on it's media and
     if(container) {
         require("./RTCUtils").setVideoSrc(container, null);
     }
-}
+};
 
 /**
  * Dispose sending the media track. And removes it from the HTML.
  * NOTE: Works for local tracks only.
  */
 JitsiTrack.prototype.dispose = function () {
-}
+};
 
 /**
  * Returns true if this is a video track and the source of the video is a
  */
 JitsiTrack.prototype.isScreenSharing = function(){
 
-}
+};
 
 /**
  * Returns id of the track.
- * @returns {string} id of the track or null if this is fake track.
+ * @returns {string|null} id of the track or null if this is fake track.
  */
 JitsiTrack.prototype._getId = function () {
     var tracks = this.stream.getTracks();
 
 /**
  * Returns id of the track.
- * @returns {string} id of the track or null if this is fake track.
+ * @returns {string|null} id of the track or null if this is fake track.
  */
 JitsiTrack.prototype.getId = function () {
     if(this.stream)
 JitsiTrack.prototype.on = function (eventId, handler) {
     if(this.eventEmitter)
         this.eventEmitter.on(eventId, handler);
-}
+};
 
 /**
  * Removes event listener
 JitsiTrack.prototype.off = function (eventId, handler) {
     if(this.eventEmitter)
         this.eventEmitter.removeListener(eventId, handler);
-}
+};
 
 // Common aliases for event emitter
 JitsiTrack.prototype.addEventListener = JitsiTrack.prototype.on;
             audioLevel);
         this.audioLevel = audioLevel;
     }
- }
+ };
 
 /**
  * Returns the msid of the stream attached to the JitsiTrack object or null if
     return (!this.stream || !this.stream.id || !(tracks = this._getTracks()) ||
         !tracks.length || !(track = tracks[0]) || !track.id)?
             null : this.stream.id + " " + track.id;
-}
+};
 
 module.exports = JitsiTrack;

modules/RTC/RTC.js

  * @param {Object} [options] optional parameters
  * @param {Array} options.devices the devices that will be requested
  * @param {string} options.resolution resolution constraints
- * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with the following structure {stream: the Media Stream,
+ * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with the
+ * following structure {stream: the Media Stream,
  * type: "audio" or "video", videoType: "camera" or "desktop"}
- * will be returned trough the Promise, otherwise JitsiTrack objects will be returned.
+ * will be returned trough the Promise, otherwise JitsiTrack objects will be
+ * returned.
  * @param {string} options.cameraDeviceId
  * @param {string} options.micDeviceId
  * @returns {*} Promise object that will receive the new JitsiTracks
     return RTCUtils.obtainAudioAndVideoPermissions(options).then(function (streams) {
         return createLocalTracks(streams, options);
     });
-}
+};
 
 RTC.prototype.onIncommingCall = function(event) {
     if(this.options.config.openSctp)
             this.room.addStream(this.localStreams[i].getOriginalStream(),
                 function () {}, ssrcInfo, true);
         }
-}
+};
 
 RTC.prototype.selectedEndpoint = function (id) {
     if(this.dataChannels)
         this.dataChannels.handleSelectedEndpointEvent(id);
-}
+};
 
 RTC.prototype.pinEndpoint = function (id) {
     if(this.dataChannels)
         this.dataChannels.handlePinnedEndpointEvent(id);
-}
+};
 
 RTC.prototype.addListener = function (type, listener) {
     this.eventEmitter.on(type, listener);
 
 RTC.addListener = function (eventType, listener) {
     RTCUtils.addListener(eventType, listener);
-}
+};
 
 RTC.removeListener = function (eventType, listener) {
     RTCUtils.removeListener(eventType, listener)
-}
+};
 
 RTC.isRTCReady = function () {
     return RTCUtils.isRTCReady();
-}
+};
 
 RTC.init = function (options) {
     this.options = options || {};
     return RTCUtils.init(this.options);
-}
+};
 
 RTC.getDeviceAvailability = function () {
     return RTCUtils.getDeviceAvailability();
-}
+};
 
 RTC.prototype.addLocalStream = function (stream) {
     this.localStreams.push(stream);
     }
     // we return a Promise from all Promises so we can wait for their execution
     return Promise.all(mutePromises);
-}
+};
 
 RTC.prototype.removeLocalStream = function (stream) {
     var pos = this.localStreams.indexOf(stream);
  */
 RTC.isDeviceChangeAvailable = function () {
     return RTCUtils.isDeviceChangeAvailable();
-}
+};
 /**
  * Allows to receive list of available cameras/microphones.
  * @param {function} callback would receive array of devices as an argument

modules/xmpp/ChatRoom.js

 };
 
 ChatRoom.prototype.setVideoMute = function (mute, callback, options) {
-    var self = this;
     this.sendVideoInfoPresence(mute);
     if(callback)
         callback(mute);
     if(this.recording)
         return this.recording.getState();
     return "off";
-}
+};
 
 /**
  * Returns the url of the recorded video.
     if(this.recording)
         return this.recording.getURL();
     return null;
-}
+};
 
 /**
  * Starts/stops the recording
 
     return statusChangeHandler("error",
         new Error("The conference is not created yet!"));
-}
+};
 
 /**
  * Returns true if the SIP calls are supported and false otherwise
     if(this.moderator)
         return this.moderator.isSipGatewayEnabled();
     return false;
-}
+};
 
 /**
  * Dials a number.
     return this.connection.rayo.dial(number, "fromnumber",
         Strophe.getNodeFromJid(this.myroomjid), this.password,
         this.focusMucJid);
-}
+};
 
 /**
  * Hangup an existing call
  */
 ChatRoom.prototype.hangup = function () {
     return this.connection.rayo.hangup();
-}
+};
 
 /**
  * Returns the phone number for joining the conference.
  */
 ChatRoom.prototype.getPhoneNumber = function () {
     return this.phoneNumber;
-}
+};
 
 /**
  * Returns the pin for joining the conference with phone.
  */
 ChatRoom.prototype.getPhonePin = function () {
     return this.phonePin;
-}
+};
 
 /**
  * Returns the connection state for the current session.
     if(!this.session)
         return null;
     return this.session.getIceConnectionState();
-}
+};
 
 /**
  * Mutes remote participant.
         function (error) {
             logger.log('set mute error', error);
         });
-}
+};
 
 ChatRoom.prototype.onMute = function (iq) {
     var from = iq.getAttribute('from');
         this.eventEmitter.emit(XMPPEvents.AUDIO_MUTED_BY_FOCUS, doMuteAudio);
     }
     return true;
-}
+};
 
 /**
  * Leaves the room. Closes the jingle session.

modules/xmpp/JingleSessionPC.js

 JingleSessionPC.prototype.close = function () {
     this.closed = true;
     this.peerconnection && this.peerconnection.close();
-}
+};
 
 
 /**