fix(GlobalOnErrorHandler) avoid calling it when we handle the error

JitsiConference.js

 import LocalStatsCollector from './modules/statistics/LocalStatsCollector';
 import SpeakerStatsCollector from './modules/statistics/SpeakerStatsCollector';
 import Statistics from './modules/statistics/statistics';
-import GlobalOnErrorHandler from './modules/util/GlobalOnErrorHandler';
 import { safeSubtract } from './modules/util/MathUtil';
 import RandomUtil from './modules/util/RandomUtil';
 import ComponentsVersions from './modules/version/ComponentsVersions';
                 enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
             });
     } catch (error) {
-        GlobalOnErrorHandler.callErrorHandler(error);
         logger.error(error);
 
         return;
                 }
             },
             error => {
-                GlobalOnErrorHandler.callErrorHandler(error);
                 logger.error('Failed to accept incoming Jingle session', error);
             },
             localTracks
 
         this.statistics.startRemoteStats(this.jvbJingleSession.peerconnection);
     } catch (e) {
-        GlobalOnErrorHandler.callErrorHandler(e);
         logger.error(e);
     }
 };

modules/RTC/BridgeChannel.js

 import RTCEvents from '../../service/RTC/RTCEvents';
 import { createBridgeChannelClosedEvent } from '../../service/statistics/AnalyticsEvents';
 import Statistics from '../statistics/statistics';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 const logger = getLogger(__filename);
 
             try {
                 obj = safeJsonParse(data);
             } catch (error) {
-                GlobalOnErrorHandler.callErrorHandler(error);
                 logger.error('Failed to parse channel message as JSON: ', data, error);
 
                 return;

modules/RTC/RTC.js

 import { MediaType } from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import browser from '../browser';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
 import { safeCounterIncrement } from '../util/MathUtil';
 
 
         this._channelOpenListener = () => {
             const logError = (error, msgType, value) => {
-                GlobalOnErrorHandler.callErrorHandler(error);
                 logger.error(`Cannot send ${msgType}(${JSON.stringify(value)}) endpoint message`, error);
             };
 

modules/RTC/RTCUtils.js

 import { AVAILABLE_DEVICE } from '../../service/statistics/AnalyticsEvents';
 import browser from '../browser';
 import Statistics from '../statistics/statistics';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
 
 import screenObtainer from './ScreenObtainer';
 
                 // we skip setting audio output if there was no explicit change
                 && audioOutputChanged) {
-            return element.setSinkId(rtcUtils.getAudioOutputDevice()).catch(function(ex) {
+            return element.setSinkId(rtcUtils.getAudioOutputDevice()).catch(ex => {
                 const err
                     = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
 
-                GlobalOnErrorHandler.callUnhandledRejectionHandler({
-                    promise: this, // eslint-disable-line no-invalid-this
-                    reason: err
-                });
-
                 logger.warn(
                     'Failed to set audio output device for the element.'
                         + ' Default audio output device will be used'

modules/RTC/TraceablePeerConnection.js

 import SdpConsistency from '../sdp/SdpConsistency';
 import SdpSimulcast from '../sdp/SdpSimulcast';
 import { SdpTransformWrap } from '../sdp/SdpTransformUtil';
-import * as GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 import JitsiRemoteTrack from './JitsiRemoteTrack';
 import RTC from './RTC';
 
     // look up an associated JID for a stream id
     if (!mediaType) {
-        GlobalOnErrorHandler.callErrorHandler(
-            new Error(`MediaType undefined for remote track, stream id: ${streamId}, track creation failed!`));
+        logger.error(`MediaType undefined for remote track, stream id: ${streamId}, track creation failed!`);
 
         return;
     }
     }
 
     if (!mediaLine) {
-        GlobalOnErrorHandler.callErrorHandler(
-            new Error(`Matching media line not found in remote SDP for remote stream[id=${streamId},type=${mediaType}],`
-                + 'track creation failed!'));
+        logger.error(`Matching media line not found in remote SDP for remote stream[id=${streamId},type=${mediaType}],`
+                + 'track creation failed!');
 
         return;
     }
 
     ssrcLines = ssrcLines.filter(line => line.indexOf(`msid:${streamId}`) !== -1);
     if (!ssrcLines.length) {
-        GlobalOnErrorHandler.callErrorHandler(
-            new Error(`No SSRC lines found in remote SDP for remote stream[msid=${streamId},type=${mediaType}]`
-                + 'track creation failed!'));
+        logger.error(`No SSRC lines found in remote SDP for remote stream[msid=${streamId},type=${mediaType}]`
+                + 'track creation failed!');
 
         return;
     }
     const ownerEndpointId = this.signalingLayer.getSSRCOwner(trackSsrc);
 
     if (isNaN(trackSsrc) || trackSsrc < 0) {
-        GlobalOnErrorHandler.callErrorHandler(
-            new Error(`Invalid SSRC for remote stream[ssrc=${trackSsrc},id=${streamId},type=${mediaType}]`
-                + 'track creation failed!'));
+        logger.error(`Invalid SSRC for remote stream[ssrc=${trackSsrc},id=${streamId},type=${mediaType}]`
+                + 'track creation failed!');
 
         return;
     }
 
     if (!ownerEndpointId) {
-        GlobalOnErrorHandler.callErrorHandler(
-            new Error(`No SSRC owner known for remote stream[ssrc=${trackSsrc},id=${streamId},type=${mediaType}]`
-            + 'track creation failed!'));
+        logger.error(`No SSRC owner known for remote stream[ssrc=${trackSsrc},id=${streamId},type=${mediaType}]`
+            + 'track creation failed!');
 
         return;
     }
     }
 
     if (!streamId) {
-        GlobalOnErrorHandler.callErrorHandler(new Error(`${this} remote track removal failed - no stream ID`));
+        logger.error(`${this} remote track removal failed - no stream ID`);
 
         return;
     }
 
     if (!trackId) {
-        GlobalOnErrorHandler.callErrorHandler(new Error(`${this} remote track removal failed - no track ID`));
+        logger.error(`${this} remote track removal failed - no track ID`);
 
         return;
     }
         remoteTrack => remoteTrack.getStreamId() === streamId && remoteTrack.getTrackId() === trackId);
 
     if (!toBeRemoved) {
-        GlobalOnErrorHandler.callErrorHandler(new Error(`${this} remote track removal failed - track not found`));
+        logger.error(`${this} remote track removal failed - track not found`);
 
         return;
     }

modules/statistics/RTPStatsCollector.js

 import browser from '../browser';
 import FeatureFlags from '../flags/FeatureFlags';
 
-const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
-
 const logger = getLogger(__filename);
 
 /**
  * @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();
 };
                 try {
                     this.processStatsReport();
                 } catch (error) {
-                    GlobalOnErrorHandler.callErrorHandler(error);
                     logger.error('Processing of RTP stats failed:', error);
                 }
                 this.previousStatsReport = this.currentStatsReport;

modules/xmpp/ChatRoom.js

 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import Settings from '../settings/Settings';
 import EventEmitterForwarder from '../util/EventEmitterForwarder';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
 
 import AVModeration from './AVModeration';
                 }
             }
         }, error => {
-            GlobalOnErrorHandler.callErrorHandler(error);
             logger.error('Error getting room info: ', error);
         });
     }
             if (!$(form).find(
                     '>query>x[xmlns="jabber:x:data"]'
                     + '>field[var="muc#roomconfig_whois"]').length) {
-                const errmsg = 'non-anonymous rooms not supported';
-
-                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
-                logger.error(errmsg);
+                logger.error('non-anonymous rooms not supported');
 
                 return;
             }
             this.connection.sendIQ(formSubmit);
 
         }, error => {
-            GlobalOnErrorHandler.callErrorHandler(error);
             logger.error('Error getting room configuration form: ', error);
         });
     }
                 });
             }
         } catch (e) {
-            GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(`Error processing:${node.tagName} node.`, e);
         }
     }

modules/xmpp/JingleSessionPC.js

 import SDPUtil from '../sdp/SDPUtil';
 import Statistics from '../statistics/statistics';
 import AsyncQueue, { ClearedQueueError } from '../util/AsyncQueue';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 import browser from './../browser';
 import JingleSession from './JingleSession';
             const jcand = SDPUtil.candidateToJingle(candidate.candidate);
 
             if (!(ice && jcand)) {
-                const errorMesssage = 'failed to get ice && jcand';
-
-                GlobalOnErrorHandler.callErrorHandler(new Error(errorMesssage));
-                logger.error(errorMesssage);
+                logger.error('failed to get ice && jcand');
 
                 return;
             }
                 // We don't want to have that logged on error level.
                 logger.debug(`${this} Jingle error: ${JSON.stringify(error)}`);
             } else {
-                GlobalOnErrorHandler.callErrorHandler(
-                    new Error(
-                        `Jingle error: ${JSON.stringify(error)}`));
+                logger.error(`Jingle error: ${JSON.stringify(error)}`);
             }
         };
     }

modules/xmpp/moderator.js

 const AuthenticationEvents
     = require('../../service/authentication/AuthenticationEvents');
 const { XMPPEvents } = require('../../service/xmpp/XMPPEvents');
-const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
 const logger = getLogger(__filename);
 
             window.setTimeout(() => this.sendConferenceRequest(roomJid)
                 .then(callback), waitMs);
         } else {
-            const errmsg = 'Failed to get a successful response, giving up.';
-            const error = new Error(errmsg);
-
-            logger.error(errmsg, error);
-            GlobalOnErrorHandler.callErrorHandler(error);
+            logger.error('Failed to get a successful response, giving up.');
 
             // This is a "fatal" error and the user of the lib should handle it accordingly.
             // TODO: change the event name to something accurate.
                 callback();
             },
             error => {
-                const errmsg = 'Logout error';
-
-                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
-                logger.error(errmsg, error);
+                logger.error('Logout error', error);
             }
         );
     }

modules/xmpp/strophe.jingle.js

 } from '../../service/statistics/AnalyticsEvents';
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import Statistics from '../statistics/statistics';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import RandomUtil from '../util/RandomUtil';
 
 import ConnectionPlugin from './ConnectionPlugin';
                         value: successTime
                     }));
             }, error => {
-                GlobalOnErrorHandler.callErrorHandler(error);
                 logger.error('Transport replace failed', error);
                 sess.sendTransportReject();
             });

modules/xmpp/strophe.ping.js

 import { getLogger } from '@jitsi/logger';
 import { $iq, Strophe } from 'strophe.js';
 
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
-
 import ConnectionPlugin from './ConnectionPlugin';
 
 
                 const errmsg = `Ping ${error ? 'error' : 'timeout'}`;
 
                 if (this.failedPings >= this.pingThreshold) {
-                    GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
                     logger.error(errmsg, error);
                     this._onPingThresholdExceeded && this._onPingThresholdExceeded();
                 } else {

modules/xmpp/strophe.util.js

 import { getLogger } from '@jitsi/logger';
 import { Strophe } from 'strophe.js';
 
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
-
 const logger = getLogger(__filename);
 
 /**
             break;
         case Strophe.LogLevel.ERROR:
         case Strophe.LogLevel.FATAL:
-            // eslint-disable-next-line no-param-reassign
-            msg = `Strophe: ${msg}`;
-            GlobalOnErrorHandler.callErrorHandler(new Error(msg));
-            logger.error(msg);
+            logger.error(`Strophe: ${msg}`, msg);
             break;
         }
 

modules/xmpp/xmpp.js

 import { E2EEncryption } from '../e2ee/E2EEncryption';
 import FeatureFlags from '../flags/FeatureFlags';
 import Statistics from '../statistics/statistics';
-import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
 import RandomUtil from '../util/RandomUtil';
 
                         identities, undefined /* when querying we will query for features */);
                 })
                 .catch(error => {
-                    const errmsg = 'Feature discovery error';
-
-                    GlobalOnErrorHandler.callErrorHandler(
-                        new Error(`${errmsg}: ${error}`));
-                    logger.error(errmsg, error);
+                    logger.error('Feature discovery error', error);
 
                     this._maybeSendDeploymentInfoStat(true);
                 });