Remove duplications of error messages

JitsiConference.js

  */
 function JitsiConference(options) {
     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)!");
-        throw new Error("Invalid conference name (no conference name passed or "
-            + "it contains invalid characters like capital letters)!");
+        var errmsg
+            = "Invalid conference name (no conference name passed or it "
+                + "contains invalid characters like capital letters)!";
+        logger.error(errmsg);
+        throw new Error(errmsg);
     }
     this.options = options;
     this.connection = this.options.connection;
             conference.statistics.startRemoteStats(
                     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);
+            // Error cause this should never happen unless something is wrong!
+            var errmsg
+                = "Rejecting session-initiate from non-focus user: "
+                    + jingleSession.peerjid;
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg);
         }
     });
 

JitsiMeetJS.js

     _gumFailedHandler: [],
     init: function (options) {
         Statistics.audioLevelsEnabled = !options.disableAudioLevels;
-        
+
         if (options.enableWindowOnErrorHandler) {
             GlobalOnErrorHandler.addHandler(
                 this.getGlobalOnErrorHandler.bind(this));

modules/RTC/DataChannels.js

             logger.error(
                 "Failed to parse data channel message as JSON: ",
                 data,
-                dataChannel, e);
+                dataChannel,
+                e);
         }
         if (('undefined' !== typeof(obj)) && (null !== obj)) {
             var colibriClass = obj.colibriClass;

modules/RTC/RTCUtils.js

             };
 
         } 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");
+            var errmsg
+                = "'screen' WebRTC media source is supported only in Chrome"
+                    + " and with Temasys plugin";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg);
         }
     }
     if (um.indexOf('desktop') >= 0) {
                     resolve();
                 });
             } else {
+                var errmsg = 'Browser does not appear to be WebRTC-capable';
                 try {
-                    logger.error(
-                        'Browser does not appear to be WebRTC-capable');
+                    logger.error(errmsg);
                 } catch (e) {
                 }
-                reject(
-                    new Error('Browser does not appear to be WebRTC-capable'));
+                reject(new Error(errmsg));
                 return;
             }
 

modules/util/GlobalOnErrorHandler.js

 /**
- * This utility class defines custom onerror and onunhandledrejection functions
- * The custom error handlers are respecting the previous defined error handlers
+ * This utility class defines custom onerror and onunhandledrejection functions.
+ * The custom error handlers respect the previously-defined error handlers.
  * GlobalOnErrorHandler class provides utilities to add many custom error
  * handlers and to execute the error handlers directly.
  */
  */
 var handlers = [];
 
-// if an old handler exists also fire its events
+// If an old handler exists, also fire its events.
 var oldOnErrorHandler = window.onerror;
 
 /**
         oldOnErrorHandler(message, source, lineno, colno, error);
 }
 
-// if an old handler exists also fire its events
+// 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.
+ * Custom handler that calls the old global handler and executes all handlers
+ * that were previously added. This handler handles rejected Promises.
  */
 function JitsiGlobalUnhandledRejection(event) {
     handlers.forEach(function (handler) {
         oldOnUnhandledRejection(event);
 }
 
-//Setting the custom error handlers.
+// Setting the custom error handlers.
 window.onerror = JitsiGlobalErrorHandler;
 window.onunhandledrejection = JitsiGlobalUnhandledRejection;
 
     },
     /**
      * Calls the global error handler if there is one.
-     * @param error the error that is going to be passed to the error handler
+     * @param error the error to pass to the error handler
      */
     callErrorHandler: function (error) {
         var errHandler = window.onerror;
     },
     /**
      * Calls the global rejection handler if there is one.
-     * @param error the error that is going to be passed to the rejection
-     * handler.
+     * @param error the error to pass to the rejection handler.
      */
     callUnhandledRejectionHandler: function (error) {
         var errHandler = window.onunhandledrejection;

modules/xmpp/ChatRoom.js

         if (!$(form).find(
                 '>query>x[xmlns="jabber:x:data"]' +
                 '>field[var="muc#roomconfig_whois"]').length) {
-            GlobalOnErrorHandler.callErrorHandler(
-                new Error("non-anonymous rooms not supported"));
-            logger.error("non-anonymous rooms not supported");
+            var errmsg = "non-anonymous rooms not supported";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg);
             return;
         }
 
 
     }, function (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
-        logger.error("Error getting room configuration form");
+        logger.error("Error getting room configuration form: ", error);
     });
 };
 
     // make sure we catch all errors coming from any handler
     // otherwise we can remove the presence handler from strophe
     try {
-        if(this.presHandlers[node.tagName])
-            this.presHandlers[node.tagName](
-                node, Strophe.getResourceFromJid(from), from);
+        var tagHandler = this.presHandlers[node.tagName];
+        if(tagHandler)
+            tagHandler(node, Strophe.getResourceFromJid(from), from);
     } catch (e) {
         GlobalOnErrorHandler.callErrorHandler(e);
-        logger.error('Error processing:' + node.tagName
-            + ' node.', 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);
-        throw new Error('attempt to initiate on session ' + this.sid +
-            'in state ' + this.state);
+        var errmsg
+            = 'attempt to initiate on session ' + this.sid + 'in state '
+                + this.state;
+        logger.error(errmsg);
+        throw new Error(errmsg);
     }
     this.room = room;
     this.state = 'pending';

modules/xmpp/JingleSessionPC.js

         var ice = SDPUtil.iceparams(this.localSDP.media[candidate.sdpMLineIndex], this.localSDP.session);
         var jcand = SDPUtil.candidateToJingle(candidate.candidate);
         if (!(ice && jcand)) {
-            //FIxed
-            GlobalOnErrorHandler.callErrorHandler(
-                new Error("failed to get ice && jcand"));
-            logger.error("failed to get ice && jcand");
+            var errorMesssage = "failed to get ice && jcand";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errorMesssage));
+            logger.error(errorMesssage);
             return;
         }
         ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
             logger.error('setLocalDescription failed', error);
             if (failure)
                 failure(error);
-            self.room.eventEmitter.emit(XMPPEvents.CONFERENCE_SETUP_FAILED,
-                error);
+            self.room.eventEmitter.emit(
+                    XMPPEvents.CONFERENCE_SETUP_FAILED, error);
         }
     );
     // Some checks for STUN and TURN candiates present in local SDP
             var ssrc = $(this).attr('ssrc');
             // This should never happen, but can be useful for bug detection
             if(mySdp.containsSSRC(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);
+                var errmsg
+                    = "Got remove stream request for my own ssrc: " + ssrc;
+                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                logger.error(errmsg);
                 return;
             }
             ssrcs.push(ssrc);
         function() {
 
             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");
+                var errmsg = "createAnswer attempt on closed state";
+                logger.error(errmsg);
+                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                queueCallback(errmsg);
                 return;
             }
 
                             queueCallback();
                         },
                         function(error) {
+                            var errmsg = "modified setLocalDescription failed";
                             GlobalOnErrorHandler.callErrorHandler(new Error(
-                                "modified setLocalDescription failed" +
-                                error));
-                            logger.error("modified setLocalDescription failed",
-                                error);
+                                errmsg + ": " + error));
+                            logger.error(errmsg, error);
                             queueCallback(error);
                         }
                     );
                 },
                 function(error) {
+                    var errmsg = "modified answer failed";
                     GlobalOnErrorHandler.callErrorHandler(new Error(
-                        "modified answer failed" + error));
-                    logger.error('modified answer failed', error);
+                        errmsg + ": " + error));
+                    logger.error(errmsg, error);
                     queueCallback(error);
                 }
             );
         },
         function(error) {
+            var errmsg = 'modify failed';
             GlobalOnErrorHandler.callErrorHandler(new Error(
-                'modify failed' + error));
-            logger.error('modify failed', error);
+                errmsg + ": " + error));
+            logger.error(errmsg, error);
             queueCallback(error);
         }
     );
             this.fixSourceRemoveJingle(jingle);
             break;
         default:
-            GlobalOnErrorHandler.callErrorHandler("Unknown jingle action!");
-            logger.error("Unknown jingle action!");
+            var errmsg = "Unknown jingle action!";
+            GlobalOnErrorHandler.callErrorHandler(errmsg);
+            logger.error(errmsg);
             return false;
     }
 

modules/xmpp/moderator.js

         return;
     }
     var waitMs = self.getNextErrorTimeout();
-    GlobalOnErrorHandler.callErrorHandler(
-        new Error("Focus error, retry after "+ waitMs));
-    logger.error("Focus error, retry after " + waitMs, error);
+    var errmsg = "Focus error, retry after "+ waitMs;
+    GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+    logger.error(errmsg, error);
     // Show message
     var focusComponent = self.getFocusComponent();
     var retrySec = waitMs / 1000;
                 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);
+                var errmsg = "Failed to get auth url from the focus";
+                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                logger.error(errmsg, result);
                 failureCallback(result);
             }
         },
         function (error) {
-            GlobalOnErrorHandler.callErrorHandler(
-                new Error("Get auth url error"));
-            logger.error("Get auth url error", error);
+            var errmsg = "Get auth url error";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg, 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);
+                var errmsg = "Failed to get POPUP auth url from the focus";
+                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                logger.error(errmsg, result);
+                failureCallback(result);
             }
         },
         function (error) {
-            GlobalOnErrorHandler.callErrorHandler(
-                new Error("Get POPUP auth url error"));
-            logger.error('Get POPUP auth url error', error);
+            var errmsg = "Get POPUP auth url error";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg, error);
             failureCallback(error);
         }
     );
             callback(logoutUrl);
         }.bind(this),
         function (error) {
-            GlobalOnErrorHandler.callErrorHandler(new Error("Logout error"));
-            logger.error("Logout error", error);
+            var errmsg = "Logout error";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg, error);
         }
     );
 };

modules/xmpp/recording.js

             this.setRecordingJibri(state, callback, errCallback, options);
             break;
         default:
-            GlobalOnErrorHandler.callErrorHandler(
-                new Error("Unknown recording type!"));
-            logger.error("Unknown recording type!");
+            var errmsg = "Unknown recording type!";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg);
             return;
     }
 };

modules/xmpp/strophe.emuc.js

         createRoom: function (jid, password, options, settings) {
             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!");
+                var errmsg = "You are already in the room!";
+                logger.error(errmsg);
+                throw new Error(errmsg);
                 return;
             }
             this.rooms[roomJid] = new ChatRoom(this.connection, jid,

modules/xmpp/strophe.ping.js

                         callback(ping.length > 0);
                     },
                     function (error) {
-                        GlobalOnErrorHandler.callErrorHandler(
-                            new Error("Ping feature discovery error" + error));
-                        logger.error("Ping feature discovery error", error);
+                        var errmsg = "Ping feature discovery error";
+                        GlobalOnErrorHandler.callErrorHandler(new Error(
+                            errmsg + ": " + error));
+                        logger.error(errmsg, error);
                         callback(false);
                     }
                 );
          */
         startInterval: function (remoteJid, interval) {
             if (this.intervalId) {
-                GlobalOnErrorHandler.callErrorHandler(
-                    new Error("Ping task scheduled already"));
-                logger.error("Ping task scheduled already");
+                var errmsg = "Ping task scheduled already";
+                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                logger.error(errmsg);
                 return;
             }
             if (!interval)
                 },
                 function (error) {
                     self.failedPings += 1;
-                    GlobalOnErrorHandler.callErrorHandler(
-                        new Error("Ping " + (error ? "error" : "timeout")));
-                    logger.error(
-                        "Ping " + (error ? "error" : "timeout"), error);
+                    var errmsg = "Ping " + (error ? "error" : "timeout");
+                    GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                    logger.error(errmsg, error);
                     if (self.failedPings >= PING_THRESHOLD) {
                         self.connection.disconnect();
                     }

modules/xmpp/strophe.util.js

                 break;
             case Strophe.LogLevel.ERROR:
             case Strophe.LogLevel.FATAL:
-                GlobalOnErrorHandler.callErrorHandler(
-                    new Error("Strophe: " + msg));
-                logger.error("Strophe: " + msg);
+                msg = "Strophe: " + msg;
+                GlobalOnErrorHandler.callErrorHandler(new Error(msg));
+                logger.error(msg);
                 break;
         }
     };