Calls the global error handler on every logger.error

JitsiConference.js

 var JitsiTrackErrors = require("./JitsiTrackErrors");
 var Settings = require("./modules/settings/Settings");
 var ComponentsVersions = require("./modules/version/ComponentsVersions");
+var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
 
 /**
  * Creates a JitsiConference object with the given name and properties.
     if(!options.name || options.name.toLowerCase() !== options.name) {
         logger.error("Invalid conference name (no conference name passed or it"
             + "contains invalid characters like capital letters)!");
-         return;
+        throw new Error("Invalid conference name (no conference name passed or "
+            + "it contains invalid characters like capital letters)!");
     }
     this.options = options;
     this.connection = this.options.connection;
     ).then(this._leaveRoomAndRemoveParticipants.bind(this))
     .catch(function (error) {
         logger.error(error);
+        GlobalOnErrorHandler.callUnhandlerRejectionHandler({promise: this, reason: error});
         // We are proceeding with leaving the conference because room.leave may
         // succeed.
         this._leaveRoomAndRemoveParticipants();
             // Accept incoming call
             conference.room.setJingleSession(jingleSession);
             conference.room.connectionTimes["session.initiate"] = now;
-            jingleSession.initialize(false /* initiator */, conference.room);
+            try{
+                jingleSession.initialize(false /* initiator */,
+                    conference.room);
+            } catch (error) {
+                GlobalOnErrorHandler.callErrorHandler(error);
+            };
             conference.rtc.onIncommingCall(jingleSession);
             jingleSession.acceptOffer(jingleOffer, null,
                 function (error) {
+                    GlobalOnErrorHandler.callErrorHandler(error);
                     logger.error(
                         "Failed to accept incoming Jingle session", error);
                 }
                     jingleSession.peerconnection);
         } else {
             // Error cause this should never happen unless something is wrong !
+            GlobalOnErrorHandler.callErrorHandler(new Error(
+                "Rejecting session-initiate from non focus user: "
+                    + jingleSession.peerjid));
             logger.error(
                 "Rejecting session-initiate from non focus user: "
                         + jingleSession.peerjid);
     conference.room.addListener(XMPPEvents.GRACEFUL_SHUTDOWN, function () {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.GRACEFUL_SHUTDOWN);
     });
-    conference.room.addListener(XMPPEvents.JINGLE_FATAL_ERROR, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.JINGLE_FATAL_ERROR);
+    conference.room.addListener(XMPPEvents.JINGLE_FATAL_ERROR, function (session, error) {
+        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
     });
     conference.room.addListener(XMPPEvents.MUC_DESTROYED, function (reason) {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.CONFERENCE_DESTROYED, reason);

JitsiMeetJS.js

 var Statistics = require("./modules/statistics/statistics");
 var Resolutions = require("./service/RTC/Resolutions");
 var ScriptUtil = require("./modules/util/ScriptUtil");
+var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
 
 function getLowerResolution(resolution) {
     if(!Resolutions[resolution])
     _gumFailedHandler: [],
     init: function (options) {
         Statistics.audioLevelsEnabled = !options.disableAudioLevels;
-
+        
         if (options.enableWindowOnErrorHandler) {
-            // if an old handler exists also fire its events
-            var oldOnErrorHandler = window.onerror;
-            window.onerror = function (message, source, lineno, colno, error) {
-
-                this.getGlobalOnErrorHandler(
-                    message, source, lineno, colno, error);
-
-                if (oldOnErrorHandler)
-                    oldOnErrorHandler(message, source, lineno, colno, error);
-            }.bind(this);
-
-            // if an old handler exists also fire its events
-            var oldOnUnhandledRejection = window.onunhandledrejection;
-            window.onunhandledrejection = function(event) {
-
-                this.getGlobalOnErrorHandler(
-                    null, null, null, null, event.reason);
-
-                if(oldOnUnhandledRejection)
-                    oldOnUnhandledRejection(event);
-            }.bind(this);
+            GlobalOnErrorHandler.addHandler(
+                this.getGlobalOnErrorHandler.bind(this));
         }
 
         return RTC.init(options || {});

doc/API.md

         - LOCAL_TRACK_STOPPED - indicates that a local track was stopped. This
         event can be fired when ```dispose()``` method is called or for other reasons.
         - TRACK_AUDIO_OUTPUT_CHANGED - indicates that audio output device for track was changed (parameters - deviceId (string) - new audio output device ID).
-        
+
     4. mediaDevices
         - DEVICE_LIST_CHANGED - indicates that list of currently connected devices has changed (parameters - devices(MediaDeviceInfo[])).
-        
+
 
 * ```JitsiMeetJS.errors``` - JS object that contains all errors used by the API. You can use that object to check the reported errors from the API
     We have two error types - connection and conference. You can access the events with the following code ```JitsiMeetJS.errors.<error_type>.<error_name>```.
         - VIDEOBRIDGE_NOT_AVAILABLE - video bridge issues.
         - RESERVATION_ERROR - error in reservation system
         - GRACEFUL_SHUTDOWN - graceful shutdown
-        - JINGLE_FATAL_ERROR - error in jingle
+        - JINGLE_FATAL_ERROR - error in jingle (the orriginal error is attached as parameter.)
         - CONFERENCE_DESTROYED - conference has been destroyed
         - CHAT_ERROR - chat error happened
         - FOCUS_DISCONNECTED - focus error happened
 9. getParticipantId() - returns id(string) of the track owner
 
    Note: This method is implemented only for the remote tracks.
-   
+
 10. setAudioOutput(audioOutputDeviceId) - sets new audio output device for track's DOM elements. Video tracks are ignored.
 
 11. getDeviceId() - returns device ID associated with track (for local tracks only)

modules/RTC/DataChannels.js

 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCEvents = require("../../service/RTC/RTCEvents");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 
 /**
     };
 
     dataChannel.onerror = function (error) {
+        var e = new Error("Data Channel Error:" + error);
+        GlobalOnErrorHandler.callErrorHandler(e);
         logger.error("Data Channel Error:", error, dataChannel);
     };
 
             obj = JSON.parse(data);
         }
         catch (e) {
+            GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(
                 "Failed to parse data channel message as JSON: ",
                 data,
-                dataChannel);
+                dataChannel, e);
         }
         if (('undefined' !== typeof(obj)) && (null !== obj)) {
             var colibriClass = obj.colibriClass;

modules/RTC/JitsiLocalTrack.js

                             // This is not good when video type changes after
                             // unmute, but let's not crash here
                             if (self.videoType != streamInfo.videoType) {
-                                logger.error(
+                                logger.warn(
                                     "Video type has changed after unmute!",
                                     self.videoType, streamInfo.videoType);
                                 self.videoType = streamInfo.videoType;

modules/RTC/JitsiTrack.js

             .catch(function (error) {
                 logger.error('Failed to change audio output device on element',
                     element, error);
-
-                    throw error;
+                throw error;
             });
     }))
     .then(function () {

modules/RTC/RTC.js

 var JitsiRemoteTrack = require("./JitsiRemoteTrack.js");
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 function createLocalTracks(tracksInfo, options) {
     var newTracks = [];
                 msid: localTrack.initialMSID
             };
         }
-        this.room.addStream(
-            localTrack.getOriginalStream(), function () {}, ssrcInfo, true);
+        try {
+            this.room.addStream(
+                localTrack.getOriginalStream(), function () {}, ssrcInfo, true);
+        } catch(e) {
+            GlobalOnErrorHandler.callErrorHandler(e);
+            logger.error(e);
+        }
     }.bind(this));
 };
 

modules/RTC/RTCUtils.js

 var JitsiTrackErrors = require("../../JitsiTrackErrors");
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 var eventEmitter = new EventEmitter();
 
             };
 
         } else {
+            GlobalOnErrorHandler.callErrorHandler(new Error(
+                "'screen' WebRTC media source is supported only in Chrome" +
+                " and with Temasys plugin"));
             logger.error(
                 "'screen' WebRTC media source is supported only in Chrome" +
                 " and with Temasys plugin");
             stream.getAudioTracks && stream.getAudioTracks().length) {
             element.setSinkId(RTCUtils.getAudioOutputDevice())
                 .catch(function (ex) {
+                    GlobalOnErrorHandler.callUnhandlerRejectionHandler(
+                        {promise: this, reason: ex});
                     logger.error('Failed to set audio output on element',
                         element, ex);
                 });
                 });
             } else {
                 try {
-                    logger.error('Browser does not appear to be WebRTC-capable');
+                    logger.error(
+                        'Browser does not appear to be WebRTC-capable');
                 } catch (e) {
                 }
-                reject('Browser does not appear to be WebRTC-capable');
+                reject(
+                    new Error('Browser does not appear to be WebRTC-capable'));
                 return;
             }
 

modules/RTC/ScreenObtainer.js

 var RTCBrowserType = require("./RTCBrowserType");
 var AdapterJS = require("./adapter.screenshare");
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 /**
  * Indicates whether the Chrome desktop sharing extension is installed.
         return false;
     }
     catch (e) {
+        GlobalOnErrorHandler.callErrorHandler(e);
         logger.error("Failed to parse extension version", e);
         return true;
     }

modules/statistics/CallStats.js

 /* global $, Strophe, callstats */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 var jsSHA = require('jssha');
 var io = require('socket.io-client');
         try {
             f.apply(this, arguments);
         } catch (e) {
+            GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(e);
         }
     };
         // The callstats.io API failed to initialize (e.g. because its
         // download failed to succeed in general or on time). Further
         // attempts to utilize it cannot possibly succeed.
+        GlobalOnErrorHandler.callErrorHandler(e);
         callStats = null;
         logger.error(e);
     }

modules/statistics/RTPStatsCollector.js

 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var StatisticsEvents = require("../../service/statistics/Events");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 /* Whether we support the browser we are running into for logging statistics */
 var browserSupported = RTCBrowserType.isChrome() ||
  * @param error an error that occurred on <tt>getStats</tt> call.
  */
 StatsCollector.prototype.errorCallback = function (error) {
+    GlobalOnErrorHandler.callErrorHandler(error);
     logger.error("Get stats error", error);
     this.stop();
 };
                     else {
                         results = report.result();
                     }
-                    //logger.error("Got interval report", results);
                     self.currentAudioLevelsReport = results;
                     self.processAudioLevelReport();
                     self.baselineAudioLevelsReport =
                             //chrome
                             results = report.result();
                         }
-                        //logger.error("Got interval report", results);
                         self.currentStatsReport = results;
                         try {
                             self.processStatsReport();
                         }
                         catch (e) {
+                            GlobalOnErrorHandler.callErrorHandler(e);
                             logger.error("Unsupported key:" + e, e);
                         }
 

modules/util/GlobalOnErrorHandler.js

+/**
+ * This utility class defines custom onerror and onunhandledrejection functions
+ * The custom error handlers are respecting the previous defined error handlers
+ * GlobalOnErrorHandler class provides utilities to add many custom error
+ * handlers and to execute the error handlers directly.
+ */
+
+
+/**
+ * List with global error handlers that will be executed.
+ */
+var handlers = [];
+
+// if an old handler exists also fire its events
+var oldOnErrorHandler = window.onerror;
+
+/**
+ * Custom error handler that calls the old global error handler and executes
+ * all handlers that were previously added.
+ */
+function JitsiGlobalErrorHandler(message, source, lineno, colno, error) {
+    handlers.forEach(function (handler) {
+        handler(message, source, lineno, colno, error);
+    });
+    if (oldOnErrorHandler)
+        oldOnErrorHandler(message, source, lineno, colno, error);
+}
+
+// if an old handler exists also fire its events
+var oldOnUnhandledRejection = window.onunhandledrejection;
+
+/**
+ * Custom handler that calls the old global handler and executes
+ * all handlers that were previously added. This handler handles rejected
+ * Promises.
+ */
+function JitsiGlobalUnhandlerRejection(event) {
+    handlers.forEach(function (handler) {
+        handler(null, null, null, null, event.reason);
+    });
+    if(oldOnUnhandledRejection)
+        oldOnUnhandledRejection(event);
+}
+
+//Setting the custom error handlers.
+window.onerror = JitsiGlobalErrorHandler;
+window.onunhandledrejection = JitsiGlobalUnhandlerRejection;
+
+
+var GlobalOnErrorHandler = {
+    /**
+     * Adds new error handlers.
+     * @param handler the new handler.
+     */
+    addHandler: function (handler) {
+        handlers.push(handler);
+    },
+    /**
+     * Calls the global error handler if there is one.
+     * @param error the error that is going to be passed to the error handler
+     */
+    callErrorHandler: function (error) {
+        var errHandler = window.onerror;
+        if(!errHandler)
+            return;
+        errHandler.call(null, null, null, null, null, error);
+    },
+    /**
+     * Calls the global rejection handler if there is one.
+     * @param error the error that is going to be passed to the rejection
+     * handler.
+     */
+    callUnhandlerRejectionHandler: function (error) {
+        var errHandler = window.onunhandledrejection;
+        if(!errHandler)
+            return;
+        errHandler.call(null, error);
+    }
+};
+
+
+module.exports = GlobalOnErrorHandler;

modules/xmpp/ChatRoom.js

 var Moderator = require("./moderator");
 var EventEmitter = require("events");
 var Recorder = require("./recording");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+
 var JIBRI_XMLNS = 'http://jitsi.org/protocol/jibri';
 
 var parser = {
         if (!$(form).find(
                 '>query>x[xmlns="jabber:x:data"]' +
                 '>field[var="muc#roomconfig_whois"]').length) {
-
-            logger.error('non-anonymous rooms not supported');
+            GlobalOnErrorHandler.callErrorHandler(
+                new Error("non-anonymous rooms not supported"));
+            logger.error("non-anonymous rooms not supported");
             return;
         }
 
         self.connection.sendIQ(formSubmit);
 
     }, function (error) {
+        GlobalOnErrorHandler.callErrorHandler(error);
         logger.error("Error getting room configuration form");
     });
 };
             this.presHandlers[node.tagName](
                 node, Strophe.getResourceFromJid(from), from);
     } catch (e) {
+        GlobalOnErrorHandler.callErrorHandler(e);
         logger.error('Error processing:' + node.tagName
             + ' node.', e);
     }

modules/xmpp/JingleSession.js

  */
 JingleSession.prototype.initialize = function(isInitiator, room) {
     if (this.state !== null) {
+
         logger.error('attempt to initiate on session ' + this.sid +
         'in state ' + this.state);
-        return;
+        throw new Error('attempt to initiate on session ' + this.sid +
+            'in state ' + this.state);
     }
     this.room = room;
     this.state = 'pending';

modules/xmpp/JingleSessionPC.js

 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var RTC = require("../RTC/RTC");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 /**
  * Constant tells how long we're going to wait for IQ response, before timeout
         var ice = SDPUtil.iceparams(this.localSDP.media[candidate.sdpMLineIndex], this.localSDP.session);
         var jcand = SDPUtil.candidateToJingle(candidate.candidate);
         if (!(ice && jcand)) {
-            logger.error('failed to get ice && jcand');
+            //FIxed
+            GlobalOnErrorHandler.callErrorHandler(
+                new Error("failed to get ice && jcand"));
+            logger.error("failed to get ice && jcand");
             return;
         }
         ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
     // might merge last-candidate notification into this, but it is called alot later. See webrtc issue #2340
     //logger.log('was this the last candidate', this.lasticecandidate);
     this.connection.sendIQ(
-        cand, null, this.newJingleErrorHandler(cand), IQ_TIMEOUT);
+        cand, null, this.newJingleErrorHandler(cand, function (error) {
+            GlobalOnErrorHandler.callErrorHandler(
+                new Error("Jingle error: " + JSON.stringify(error)));
+        }), IQ_TIMEOUT);
 };
 
 JingleSessionPC.prototype.readSsrcInfo = function (contents) {
             logger.error('setLocalDescription failed', error);
             if (failure)
                 failure(error);
-            self.room.eventEmitter.emit(XMPPEvents.CONFERENCE_SETUP_FAILED);
+            self.room.eventEmitter.emit(XMPPEvents.CONFERENCE_SETUP_FAILED,
+                error);
         }
     );
     // Some checks for STUN and TURN candiates present in local SDP
         IQ_TIMEOUT);
 };
 
+//FIXME: I think this method is not used!
 JingleSessionPC.prototype.terminate = function (reason,  text,
                                                 success, failure) {
     var term = $iq({to: this.peerjid,
             var ssrc = $(this).attr('ssrc');
             // This should never happen, but can be useful for bug detection
             if(mySdp.containsSSRC(ssrc)){
-                logger.error("Got remove stream request for my own ssrc: "+ssrc);
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Got remove stream request for my own ssrc: " +
+                    ssrc));
+                logger.error("Got remove stream request for my own ssrc: " +
+                    ssrc);
                 return;
             }
             ssrcs.push(ssrc);
 
             if(self.signalingState == 'closed') {
                 logger.error("createAnswer attempt on closed state");
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("createAnswer attempt on closed state"));
                 queueCallback("createAnswer attempt on closed state");
                 return;
             }
                             queueCallback();
                         },
                         function(error) {
-                            logger.error('modified setLocalDescription failed', error);
+                            GlobalOnErrorHandler.callErrorHandler(new Error(
+                                "modified setLocalDescription failed" +
+                                error));
+                            logger.error("modified setLocalDescription failed",
+                                error);
                             queueCallback(error);
                         }
                     );
                 },
                 function(error) {
+                    GlobalOnErrorHandler.callErrorHandler(new Error(
+                        "modified answer failed" + error));
                     logger.error('modified answer failed', error);
                     queueCallback(error);
                 }
             );
         },
         function(error) {
+            GlobalOnErrorHandler.callErrorHandler(new Error(
+                'modify failed' + error));
             logger.error('modify failed', error);
             queueCallback(error);
         }
     if (removed && remove) {
         logger.info("Sending source-remove", remove.tree());
         this.connection.sendIQ(
-            remove, null, this.newJingleErrorHandler(remove), IQ_TIMEOUT);
+            remove, null, this.newJingleErrorHandler(remove, function (error) {
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Jingle error: " + JSON.stringify(error)));
+            }), IQ_TIMEOUT);
     } else {
         logger.log('removal not necessary');
     }
     if (added && add) {
         logger.info("Sending source-add", add.tree());
         this.connection.sendIQ(
-            add, null, this.newJingleErrorHandler(add), IQ_TIMEOUT);
+            add, null, this.newJingleErrorHandler(add, function (error) {
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Jingle error: " + JSON.stringify(error)));
+            }), IQ_TIMEOUT);
     } else {
         logger.log('addition not necessary');
     }
         if (failureCb) {
             failureCb(error);
         }
-
-        this.room.eventEmitter.emit(XMPPEvents.JINGLE_ERROR, error);
-
     }.bind(this);
 };
 
         owner: undefined, /* to be determined below */
         muted: null /* will be set in the ChatRoom */
     };
+    try{
+        // look up an associated JID for a stream id
+        if (!mediaType) {
+            logger.error("MediaType undefined", track);
+            throw new Error("MediaType undefined for remote track");
+        }
 
-    // look up an associated JID for a stream id
-    if (!mediaType) {
-        logger.error("MediaType undefined", track);
-        return;
-    }
-
-    var remoteSDP = new SDP(this.peerconnection.remoteDescription.sdp);
-    var medialines = remoteSDP.media.filter(function (mediaLines) {
-        return mediaLines.startsWith("m=" + mediaType);
-    });
-
-    if (!medialines.length) {
-        logger.error("No media for type " + mediaType + " found in remote SDP");
-        return;
-    }
+        var remoteSDP = new SDP(this.peerconnection.remoteDescription.sdp);
+        var medialines = remoteSDP.media.filter(function (mediaLines){
+            return mediaLines.startsWith("m=" + mediaType);
+        });
+        if (!medialines.length) {
+            logger.error("No media for type " + mediaType + " found in remote SDP");
+            throw new Error("No media for type " + mediaType +
+                " found in remote SDP for remote track");
+        }
 
-    var ssrclines = SDPUtil.find_lines(medialines[0], 'a=ssrc:');
-    ssrclines = ssrclines.filter(function (line) {
-        var msid = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
-        return line.indexOf(msid + ':' + streamId) !== -1;
-    });
+        var ssrclines = SDPUtil.find_lines(medialines[0], 'a=ssrc:');
+        ssrclines = ssrclines.filter(function (line) {
+            var msid = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
+            return line.indexOf(msid + ':' + streamId) !== -1;
+        });
 
-    var thessrc;
-    if (ssrclines.length) {
-        thessrc = ssrclines[0].substring(7).split(' ')[0];
-        if (!this.ssrcOwners[thessrc]) {
-            logger.error("No SSRC owner known for: " + thessrc);
-            return;
+        var thessrc;
+        if (ssrclines.length) {
+            thessrc = ssrclines[0].substring(7).split(' ')[0];
+            if (!this.ssrcOwners[thessrc]) {
+                logger.error("No SSRC owner known for: " + thessrc);
+                throw new Error("No SSRC owner known for: " + thessrc +
+                    " for remote track");
+            }
+            jitsiTrackAddedEvent.owner = this.ssrcOwners[thessrc];
+            logger.log('associated jid', this.ssrcOwners[thessrc], thessrc);
+        } else {
+            logger.error("No SSRC lines for ", streamId);
+            throw new Error("No SSRC lines for streamId " + streamId +
+                " for remote track");
         }
-        jitsiTrackAddedEvent.owner = this.ssrcOwners[thessrc];
-        logger.log('associated jid', this.ssrcOwners[thessrc], thessrc);
-    } else {
-        logger.error("No SSRC lines for ", streamId);
-        return;
-    }
-    jitsiTrackAddedEvent.ssrc = thessrc;
+        jitsiTrackAddedEvent.ssrc = thessrc;
 
-    this.room.remoteTrackAdded(jitsiTrackAddedEvent);
+        this.room.remoteTrackAdded(jitsiTrackAddedEvent);
+    } catch (error) {
+        GlobalOnErrorHandler.callErrorHandler(error);
+    }
 };
 
 /**
     logger.info("Remote track removed", stream, track);
     var streamId = RTC.getStreamID(stream);
     var trackId = track && track.id;
-    if (!streamId) {
-        logger.error("No stream ID for", stream);
-    } else if (!trackId) {
-        logger.error("No track ID for", track);
-    } else {
+    try{
+        if (!streamId) {
+            logger.error("No stream ID for", stream);
+            throw new Error("Remote track removal failed - No stream ID");
+        }
+
+        if (!trackId) {
+            logger.error("No track ID for", track);
+            throw new Error("Remote track removal failed - No track ID");
+        }
+
         this.room.eventEmitter.emit(
             XMPPEvents.REMOTE_TRACK_REMOVED, streamId, trackId);
+    } catch (error) {
+        GlobalOnErrorHandler.callErrorHandler(error);
     }
 };
 
             this.fixSourceRemoveJingle(jingle);
             break;
         default:
+            GlobalOnErrorHandler.callErrorHandler("Unknown jingle action!");
             logger.error("Unknown jingle action!");
             return false;
     }

modules/xmpp/TraceablePeerConnection.js

 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var transform = require('sdp-transform');
 var RandomUtil = require('../util/RandomUtil');
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 var SIMULCAST_LAYERS = 3;
 
                         ssrcOperation.ssrc.ssrcs.length) {
                         ssrc = ssrcOperation.ssrc.ssrcs[0];
                     } else {
+                        GlobalOnErrorHandler.callErrorHandler(
+                            new Error("SSRC replacement error!"));
                         logger.error("SSRC replacement error!");
                         break;
                     }
 
 TraceablePeerConnection.prototype.addStream = function (stream, ssrcInfo) {
     this.trace('addStream', stream? stream.id : "null");
-    try
-    {
-        if(stream)
-            this.peerconnection.addStream(stream);
-        if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype])
-            this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
-    }
-    catch (e)
-    {
-        logger.error(e);
-    }
+    if(stream)
+        this.peerconnection.addStream(stream);
+    if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype])
+        this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
 };
 
 TraceablePeerConnection.prototype.removeStream = function (stream, stopStreams,
     if(stopStreams) {
         RTC.stopMediaStream(stream);
     }
-
-    try {
-        // FF doesn't support this yet.
-        if (this.peerconnection.removeStream) {
-            this.peerconnection.removeStream(stream);
-            // Removing all cached ssrcs for the streams that are removed or
-            // muted.
-            if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype]) {
-                for(i = 0; i < this.replaceSSRCs[ssrcInfo.mtype].length; i++) {
-                    var op = this.replaceSSRCs[ssrcInfo.mtype][i];
-                    if(op.type === "unmute" &&
-                        op.ssrc.ssrcs.join("_") ===
-                        ssrcInfo.ssrc.ssrcs.join("_")) {
-                        this.replaceSSRCs[ssrcInfo.mtype].splice(i, 1);
-                        break;
-                    }
+    // FF doesn't support this yet.
+    if (this.peerconnection.removeStream) {
+        this.peerconnection.removeStream(stream);
+        // Removing all cached ssrcs for the streams that are removed or
+        // muted.
+        if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype]) {
+            for(i = 0; i < this.replaceSSRCs[ssrcInfo.mtype].length; i++) {
+                var op = this.replaceSSRCs[ssrcInfo.mtype][i];
+                if(op.type === "unmute" &&
+                    op.ssrc.ssrcs.join("_") ===
+                    ssrcInfo.ssrc.ssrcs.join("_")) {
+                    this.replaceSSRCs[ssrcInfo.mtype].splice(i, 1);
+                    break;
                 }
-                this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
             }
+            this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
         }
-    } catch (e) {
-        logger.error(e);
     }
 };
 

modules/xmpp/moderator.js

 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
-
 var AuthenticationEvents
     = require("../../service/authentication/AuthenticationEvents");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 function createExpBackoffTimer(step) {
     var count = 1;
         return;
     }
     var waitMs = self.getNextErrorTimeout();
+    GlobalOnErrorHandler.callErrorHandler(
+        new Error("Focus error, retry after "+ waitMs));
     logger.error("Focus error, retry after " + waitMs, error);
     // Show message
     var focusComponent = self.getFocusComponent();
                 logger.info("Got auth url: " + url);
                 urlCallback(url);
             } else {
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Failed to get auth url from the focus"));
                 logger.error(
                     "Failed to get auth url from the focus", result);
                 failureCallback(result);
             }
         },
         function (error) {
+            GlobalOnErrorHandler.callErrorHandler(
+                new Error("Get auth url error"));
             logger.error("Get auth url error", error);
             failureCallback(error);
         }
                 logger.info("Got POPUP auth url:  " + url);
                 urlCallback(url);
             } else {
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Failed to get POPUP auth url from the focus"));
                 logger.error(
                     "Failed to get POPUP auth url from the focus", result);
                failureCallback(result);
             }
         },
         function (error) {
+            GlobalOnErrorHandler.callErrorHandler(
+                new Error("Get POPUP auth url error"));
             logger.error('Get POPUP auth url error', error);
             failureCallback(error);
         }
             callback(logoutUrl);
         }.bind(this),
         function (error) {
+            GlobalOnErrorHandler.callErrorHandler(new Error("Logout error"));
             logger.error("Logout error", error);
         }
     );

modules/xmpp/recording.js

    Toolbar, Util, Promise */
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var JitsiRecorderErrors = require("../../JitsiRecorderErrors");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 
             this.setRecordingJibri(state, callback, errCallback, options);
             break;
         default:
+            GlobalOnErrorHandler.callErrorHandler(
+                new Error("Unknown recording type!"));
             logger.error("Unknown recording type!");
             return;
     }

modules/xmpp/strophe.emuc.js

             var roomJid = Strophe.getBareJidFromJid(jid);
             if (this.rooms[roomJid]) {
                 logger.error("You are already in the room!");
+                throw new Error("You are already in the room!");
                 return;
             }
             this.rooms[roomJid] = new ChatRoom(this.connection, jid,

modules/xmpp/strophe.jingle.js

 var JingleSession = require("./JingleSessionPC");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 
 module.exports = function(XMPP, eventEmitter) {
                                 window.performance.now());
                         },
                         function(error) {
+                            GlobalOnErrorHandler.callErrorHandler(error);
                             logger.error('Transport replace failed', error);
                             sess.sendTransportReject();
                         });

modules/xmpp/strophe.ping.js

 /* global $, $iq, Strophe */
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
-
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 
 /**
                         callback(ping.length > 0);
                     },
                     function (error) {
+                        GlobalOnErrorHandler.callErrorHandler(
+                            new Error("Ping feature discovery error" + error));
                         logger.error("Ping feature discovery error", error);
                         callback(false);
                     }
          */
         startInterval: function (remoteJid, interval) {
             if (this.intervalId) {
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Ping task scheduled already"));
                 logger.error("Ping task scheduled already");
                 return;
             }
                 },
                 function (error) {
                     self.failedPings += 1;
+                    GlobalOnErrorHandler.callErrorHandler(
+                        new Error("Ping " + (error ? "error" : "timeout")));
                     logger.error(
                         "Ping " + (error ? "error" : "timeout"), error);
                     if (self.failedPings >= PING_THRESHOLD) {

modules/xmpp/strophe.util.js

  * Strophe logger implementation. Logs from level WARN and above.
  */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 module.exports = function () {
 
                 break;
             case Strophe.LogLevel.ERROR:
             case Strophe.LogLevel.FATAL:
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error("Strophe: " + msg));
                 logger.error("Strophe: " + msg);
                 break;
         }

service/xmpp/XMPPEvents.js

     FOCUS_DISCONNECTED: 'xmpp.focus_disconnected',
     FOCUS_LEFT: "xmpp.focus_left",
     GRACEFUL_SHUTDOWN: "xmpp.graceful_shutdown",
-    /* Event fired when XMPP error is returned to any request, it is meant to be
-     * used to report 'signaling' errors to CallStats
-     *
-     * {
-     *   code: {XMPP error code}
-     *   reason: {XMPP error condition}
-     *   source = request.tree()
-     *   session = {JingleSession instance}
-     * }
-     */
-    JINGLE_ERROR: 'xmpp.jingle_error',
     // Event fired when we have failed to set initial offer
     JINGLE_FATAL_ERROR: 'xmpp.jingle_fatal_error',
     // Designates an event indicating that we were kicked from the XMPP MUC.