Merge pull request #124 from jitsi/tsareg-handle_create_local_tracks_errors_better

Tsareg handle create local tracks errors better

JitsiConference.js

 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
+var JitsiTrackError = require("./JitsiTrackError");
 var Settings = require("./modules/settings/Settings");
 var ComponentsVersions = require("./modules/version/ComponentsVersions");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
 JitsiConference.prototype.addTrack = function (track) {
     if(track.disposed)
     {
-        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+        throw new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED);
     }
 
     if (track.isVideoTrack() && this.rtc.getLocalVideoTrack()) {
                         "Failed to accept incoming Jingle session", error);
                 }
             );
-            conference.statistics.startRemoteStats(
-                    jingleSession.peerconnection);
+            // Start callstats as soon as peerconnection is initialized,
+            // do not wait for XMPPEvents.PEERCONNECTION_READY, as it may never
+            // happen in case if user doesn't have or denied permission to
+            // both camera and microphone.
+            conference.statistics.startCallStats(jingleSession, conference.settings);
+            conference.statistics.startRemoteStats(jingleSession.peerconnection);
         } else {
             // Error cause this should never happen unless something is wrong!
             var errmsg
                 conference.statistics.dispose();
             });
 
-        conference.room.addListener(XMPPEvents.PEERCONNECTION_READY,
-            function (session) {
-                conference.statistics.startCallStats(
-                    session, conference.settings);
-            });
-
         conference.room.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
             function (pc) {
                 conference.statistics.sendIceConnectionFailedEvent(pc);

JitsiMeetJS.js

 var JitsiConferenceErrors = require("./JitsiConferenceErrors");
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
+var JitsiTrackError = require("./JitsiTrackError");
 var JitsiRecorderErrors = require("./JitsiRecorderErrors");
 var Logger = require("jitsi-meet-logger");
 var MediaType = require("./service/RTC/MediaType");
                 this._gumFailedHandler.forEach(function (handler) {
                     handler(error);
                 });
-                if(!this._gumFailedHandler.length)
+
+                if(!this._gumFailedHandler.length) {
                     Statistics.sendGetUserMediaFailed(error);
-                if(error === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {
-                    var oldResolution = options.resolution || '360';
-                    var newResolution = getLowerResolution(oldResolution);
-                    if(newResolution === null)
+                }
+
+                if(error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {
+                    var oldResolution = options.resolution || '360',
+                        newResolution = getLowerResolution(oldResolution);
+
+                    if (newResolution === null) {
                         return Promise.reject(error);
+                    }
+
                     options.resolution = newResolution;
+
                     logger.debug("Retry createLocalTracks with resolution",
                                 newResolution);
+
                     return LibJitsiMeet.createLocalTracks(options);
                 }
+
                 return Promise.reject(error);
             }.bind(this));
     },
 // JitsiConnection.
 LibJitsiMeet.JitsiConnection = JitsiConnection.bind(null, LibJitsiMeet);
 
+// expose JitsiTrackError this way to give library consumers to do checks like
+// if (error instanceof JitsiMeetJS.JitsiTrackError) { }
+LibJitsiMeet.JitsiTrackError = JitsiTrackError;
+
 //Setups the promise object.
 window.Promise = window.Promise || require("es6-promise").Promise;
 

JitsiTrackError.js

+var JitsiTrackErrors = require("./JitsiTrackErrors");
+
+var TRACK_ERROR_TO_MESSAGE_MAP = {};
+
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.UNSUPPORTED_RESOLUTION]
+    = "Video resolution is not supported: ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED]
+    = "Firefox extension is not installed";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR]
+    = "Failed to install Chrome extension";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED]
+    = "User canceled Chrome's screen sharing prompt";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR]
+    = "Unknown error from Chrome extension";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.GENERAL]
+    = "Generic getUserMedia error";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.PERMISSION_DENIED]
+    = "User denied permission to use device(s): ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.NOT_FOUND]
+    = "Requested device(s) was/were not found: ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CONSTRAINT_FAILED]
+    = "Constraint could not be satisfied: ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_IS_DISPOSED]
+    = "Track has been already disposed";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS]
+    = "Track mute/unmute process is currently in progress";
+
+/**
+ * Object representing error that happened to a JitsiTrack. Can represent
+ * various types of errors. For error descriptions (@see JitsiTrackErrors).
+ * @constructor
+ * @extends Error
+ * @param {Object|string} error - error object or error name
+ * @param {Object|string} (options) - getUserMedia constraints object or error
+ *      message
+ * @param {('audio'|'video'|'desktop'|'screen')[]} (devices) - list of
+ *      getUserMedia requested devices
+ */
+function JitsiTrackError(error, options, devices) {
+    if (typeof error === "object" && typeof error.name !== "undefined") {
+        /**
+         * Additional information about original getUserMedia error
+         * and constraints.
+         * @type {{
+         *          error: Object,
+         *          constraints: Object,
+         *          devices: Array.<'audio'|'video'|'desktop'|'screen'>
+         *      }}
+         */
+        this.gum = {
+            error: error,
+            constraints: options,
+            devices: devices && Array.isArray(devices)
+                ? devices.slice(0)
+                : undefined
+        };
+
+        switch (error.name) {
+            case "PermissionDeniedError":
+            case "SecurityError":
+                this.name = JitsiTrackErrors.PERMISSION_DENIED;
+                this.message = TRACK_ERROR_TO_MESSAGE_MAP[
+                        JitsiTrackErrors.PERMISSION_DENIED]
+                        + (this.gum.devices || []).join(", ");
+                break;
+            case "NotFoundError":
+                this.name = JitsiTrackErrors.NOT_FOUND;
+                this.message = TRACK_ERROR_TO_MESSAGE_MAP[
+                        JitsiTrackErrors.NOT_FOUND]
+                        + (this.gum.devices || []).join(", ");
+                break;
+            case "ConstraintNotSatisfiedError":
+            case "OverconstrainedError":
+                var constraintName = error.constraintName;
+
+                if (options && options.video
+                    && (devices || []).indexOf('video') > -1
+                    &&
+                    (constraintName === "minWidth" ||
+                        constraintName === "maxWidth" ||
+                        constraintName === "minHeight" ||
+                        constraintName === "maxHeight" ||
+                        constraintName === "width" ||
+                        constraintName === "height")) {
+                    this.name = JitsiTrackErrors.UNSUPPORTED_RESOLUTION;
+                    this.message = TRACK_ERROR_TO_MESSAGE_MAP[
+                            JitsiTrackErrors.UNSUPPORTED_RESOLUTION] +
+                        getResolutionFromFailedConstraint(constraintName,
+                            options);
+                } else {
+                    this.name = JitsiTrackErrors.CONSTRAINT_FAILED;
+                    this.message = TRACK_ERROR_TO_MESSAGE_MAP[
+                            JitsiTrackErrors.CONSTRAINT_FAILED] +
+                        error.constraintName;
+                }
+                break;
+            default:
+                this.name = JitsiTrackErrors.GENERAL;
+                this.message = error.message ||
+                    TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.GENERAL];
+                break;
+        }
+    } else if (typeof error === "string") {
+        if (TRACK_ERROR_TO_MESSAGE_MAP[error]) {
+            this.name = error;
+            this.message = options || TRACK_ERROR_TO_MESSAGE_MAP[error];
+        } else {
+            // this is some generic error that do not fit any of our pre-defined
+            // errors, so don't give it any specific name, just store message
+            this.message = error;
+        }
+    } else {
+        throw new Error("Invalid arguments");
+    }
+
+    this.stack = error.stack || (new Error()).stack;
+}
+
+JitsiTrackError.prototype = Object.create(Error.prototype);
+JitsiTrackError.prototype.constructor = JitsiTrackError;
+
+/**
+ * Gets failed resolution constraint from corresponding object.
+ * @param {string} failedConstraintName
+ * @param {Object} constraints
+ * @returns {string|number}
+ */
+function getResolutionFromFailedConstraint(failedConstraintName, constraints) {
+    if (constraints && constraints.video && constraints.video.mandatory) {
+        if (failedConstraintName === "width") {
+            return constraints.video.mandatory.minWidth;
+        } else if (failedConstraintName === "height") {
+            return constraints.video.mandatory.minHeight;
+        } else {
+            return constraints.video.mandatory[failedConstraintName] || "";
+        }
+    }
+
+    return "";
+}
+
+module.exports = JitsiTrackError;

JitsiTrackErrors.js

-var logger = require("jitsi-meet-logger").getLogger(__filename);
-
+/**
+ * Enumeration with the errors for the JitsiTrack objects.
+ * @type {{string: string}}
+ */
 module.exports = {
     /**
-     * Returns JitsiTrackErrors based on the error object passed by GUM
-     * @param error the error
-     * @param {Array} devices Array with the requested devices
-     */
-    parseError: function (error, devices) {
-        if (typeof error === "object") {
-          var constraintName = error.constraintName;
-          var name;
-          if (constraintName
-                  && (name = error.name)
-                  && (name == "ConstraintNotSatisfiedError"
-                      || name == "OverconstrainedError")
-                  && (constraintName == "minWidth"
-                      || constraintName == "maxWidth"
-                      || constraintName == "minHeight"
-                      || constraintName == "maxHeight"
-                      || constraintName == "width"
-                      || constraintName == "height")
-                  && (devices || []).indexOf("video") !== -1) {
-              return this.UNSUPPORTED_RESOLUTION;
-          }
-          if (error.type === "jitsiError") {
-              return error.errorObject;
-          }
-        }
-        // XXX We're about to lose the details represented by error and devices
-        // (because we're about to generalize them to GENERAL). At the very
-        // least log the details.
-        logger.error('Parsing error into ' + this.GENERAL + ': ' + error);
-        return this.GENERAL;
-    },
+     * An error which indicates that requested video resolution is not supported
+     * by a webcam.
+     */
     UNSUPPORTED_RESOLUTION: "gum.unsupported_resolution",
     /**
-     * An event which indicates that the jidesha extension for Firefox is
+     * An error which indicates that the jidesha extension for Firefox is
      * needed to proceed with screen sharing, and that it is not installed.
      */
     FIREFOX_EXTENSION_NEEDED: "gum.firefox_extension_needed",
+    /**
+     * An error which indicates that the jidesha extension for Chrome is
+     * failed to install.
+     */
     CHROME_EXTENSION_INSTALLATION_ERROR:
         "gum.chrome_extension_installation_error",
+    /**
+     * An error which indicates that user canceled screen sharing window
+     * selection dialog in jidesha extension for Chrome.
+     */
     CHROME_EXTENSION_USER_CANCELED:
         "gum.chrome_extension_user_canceled",
+    /**
+     * Generic error for jidesha extension for Chrome.
+     */
+    CHROME_EXTENSION_GENERIC_ERROR:
+        "gum.chrome_extension_generic_error",
+    /**
+     * Generic getUserMedia error.
+     */
     GENERAL: "gum.general",
+    /**
+     * An error which indicates that user denied permission to share requested
+     * device.
+     */
+    PERMISSION_DENIED: "gum.permission_denied",
+    /**
+     * An error which indicates that requested device was not found.
+     */
+    NOT_FOUND: "gum.not_found",
+    /**
+     * An error which indicates that some of requested constraints in
+     * getUserMedia call were not satisfied.
+     */
+    CONSTRAINT_FAILED: "gum.constraint_failed",
+    /**
+     * An error which indicates that track has been already disposed and cannot
+     * be longer used.
+     */
     TRACK_IS_DISPOSED: "track.track_is_disposed",
+    /**
+     * An error which indicates that track is currently in progress of muting or
+     * unmuting itself.
+     */
     TRACK_MUTE_UNMUTE_IN_PROGRESS: "track.mute_unmute_inprogress"
 };

doc/API.md

 
 * JitsiTrack
 
+* JitsiTrackError
+
 Usage
 ======
 JitsiMeetJS
 JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
 ```
 
-* ```JitsiMeetJS.createLocalTracks(options)``` - Creates the media tracks and returns them trough ```Promise``` object.
+* ```JitsiMeetJS.createLocalTracks(options)``` - Creates the media tracks and returns them trough ```Promise``` object. If rejected, passes ```JitsiTrackError``` instance to catch block.
     - options - JS object with configuration options for the local media tracks. You can change the following properties there:
         1. devices - array with the devices - "desktop", "video" and "audio" that will be passed to GUM. If that property is not set GUM will try to get all available devices.
         2. resolution - the prefered resolution for the local video.
 
 
 * ```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>```.
+    We have three error types - connection, conference and track. You can access the events with the following code ```JitsiMeetJS.errors.<error_type>.<error_name>```.
     For example if you want to use the conference event that is fired when somebody leave conference you can use the following code - ```JitsiMeetJS.errors.conference.PASSWORD_REQUIRED```.
     We support the following errors:
     1. conference
         - PASSWORD_REQUIRED - passed when the connection to the server failed. You should try to authenticate with password.
         - CONNECTION_ERROR - indicates connection failures.
         - OTHER_ERROR - all other errors
+    3. track
+        - GENERAL - generic getUserMedia-related error.
+        - UNSUPPORTED_RESOLUTION - getUserMedia-related error, indicates that requested video resolution is not supported by camera.
+        - PERMISSION_DENIED - getUserMedia-related error, indicates that user denied permission to share requested device.
+        - NOT_FOUND - getUserMedia-related error, indicates that requested device was not found.
+        - CONSTRAINT_FAILED - getUserMedia-related error, indicates that some of requested constraints in getUserMedia call were not satisfied.
+        - TRACK_IS_DISPOSED - an error which indicates that track has been already disposed and cannot be longer used.
+        - TRACK_MUTE_UNMUTE_IN_PROGRESS - an error which indicates that track is currently in progress of muting or unmuting itself.
+        - CHROME_EXTENSION_GENERIC_ERROR - generic error for jidesha extension for Chrome.
+        - CHROME_EXTENSION_USER_CANCELED - an error which indicates that user canceled screen sharing window selection dialog in jidesha extension for Chrome.
+        - CHROME_EXTENSION_INSTALLATION_ERROR - an error which indicates that the jidesha extension for Chrome is failed to install.
+        - FIREFOX_EXTENSION_NEEDED - An error which indicates that the jidesha extension for Firefox is needed to proceed with screen sharing, and that it is not installed.
+        
 * ```JitsiMeetJS.logLevels``` - object with the log levels:
     1. TRACE
     2. DEBUG
 
 12. isEnded() - returns true if track is ended
 
+JitsiTrackError
+======
+The object represents error that happened to a JitsiTrack. Is inherited from JavaScript base ```Error``` object, 
+so ```"name"```, ```"message"``` and ```"stack"``` properties are available. For GUM-related errors,
+exposes additional ```"gum"``` property, which is an object with following properties:
+ - error - original GUM error
+ - constraints - GUM constraints object used for the call
+ - devices - array of devices requested in GUM call (possible values - "audio", "video", "screen", "desktop")
 
 Getting Started
 ==============

modules/RTC/JitsiLocalTrack.js

 var RTCBrowserType = require("./RTCBrowserType");
 var JitsiTrackEvents = require('../../JitsiTrackEvents');
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCUtils = require("./RTCUtils");
 var VideoType = require('../../service/RTC/VideoType');
     return new Promise(function (resolve, reject) {
 
         if(this.inMuteOrUnmuteProgress) {
-            reject(new Error(JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
+            reject(new JitsiTrackError(
+                JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
             return;
         }
         this.inMuteOrUnmuteProgress = true;

modules/RTC/RTCUtils.js

 var EventEmitter = require("events");
 var screenObtainer = require("./ScreenObtainer");
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
             });
             logger.error(
                 "failed to obtain " + device + " stream - stop", error);
-            options.errorCallback(JitsiTrackErrors.parseError(error, devices));
+
+            options.errorCallback(error);
         });
 }
 
                     setAvailableDevices(um, false);
                     logger.warn('Failed to get access to local media. Error ',
                         error, constraints);
+
                     if (failure_callback) {
-                        failure_callback(error, resolution);
+                        failure_callback(
+                            new JitsiTrackError(error, constraints, um));
                     }
                 });
         } catch (e) {
             logger.error('GUM failed: ', e);
+
             if (failure_callback) {
-                failure_callback(e);
+                failure_callback(new JitsiTrackError(e, constraints, um));
             }
         }
     },
                     this.getUserMediaWithConstraints(
                         options.devices,
                         function (stream) {
-                            if((options.devices.indexOf("audio") !== -1 &&
-                                !stream.getAudioTracks().length) ||
-                                (options.devices.indexOf("video") !== -1 &&
-                                !stream.getVideoTracks().length))
+                            var audioDeviceRequested = options.devices.indexOf("audio") !== -1;
+                            var videoDeviceRequested = options.devices.indexOf("video") !== -1;
+                            var audioTracksReceived = !!stream.getAudioTracks().length;
+                            var videoTracksReceived = !!stream.getVideoTracks().length;
+
+                            if((audioDeviceRequested && !audioTracksReceived) ||
+                                (videoDeviceRequested && !videoTracksReceived))
                             {
                                 self.stopMediaStream(stream);
-                                reject(JitsiTrackErrors.parseError(
-                                    new Error("Unable to get the audio and " +
-                                        "video tracks."),
-                                    options.devices));
+
+                                // We are getting here in case if we requested
+                                // 'audio' or 'video' devices or both, but
+                                // didn't get corresponding MediaStreamTrack in
+                                // response stream. We don't know the reason why
+                                // this happened, so reject with general error.
+                                var devices = [];
+
+                                if (audioDeviceRequested && !audioTracksReceived) {
+                                    devices.push("audio");
+                                }
+
+                                if (videoDeviceRequested && !videoTracksReceived) {
+                                    devices.push("video");
+                                }
+
+                                reject(new JitsiTrackError(
+                                    { name: "UnknownError" },
+                                    getConstraints(options.devices, options),
+                                    devices)
+                                );
                                 return;
                             }
                             if(hasDesktop) {
                                             desktopStream: desktopStream});
                                     }, function (error) {
                                         self.stopMediaStream(stream);
-                                        reject(
-                                            JitsiTrackErrors.parseError(error,
-                                                options.devices));
+
+                                        reject(error);
                                     });
                             } else {
                                 successCallback({audioVideo: stream});
                             }
                         },
                         function (error) {
-                            reject(JitsiTrackErrors.parseError(error,
-                                options.devices));
+                            reject(error);
                         },
                         options);
                 } else if (hasDesktop) {
                         function (stream) {
                             successCallback({desktopStream: stream});
                         }, function (error) {
-                            reject(
-                                JitsiTrackErrors.parseError(error,
-                                    ["desktop"]));
+                            reject(error);
                         });
                 }
             }

modules/RTC/ScreenObtainer.js

 var RTCBrowserType = require("./RTCBrowserType");
 var AdapterJS = require("./adapter.screenshare");
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 /**
 
         if (RTCBrowserType.isNWJS()) {
             obtainDesktopStream = function (onSuccess, onFailure) {
-                window.JitsiMeetNW.obtainDesktopStream (onSuccess, onFailure);
+                window.JitsiMeetNW.obtainDesktopStream (
+                    onSuccess, function (error, constraints) {
+                        onFailure && onFailure(new JitsiTrackError(
+                            error, constraints, ["desktop"]));
+                    });
             };
         } else if (RTCBrowserType.isTemasysPluginUsed()) {
             if (!AdapterJS.WebRTCPlugin.plugin.HasScreensharingFeature) {
 
         // Make sure desktopsharing knows that we failed, so that it doesn't get
         // stuck in 'switching' mode.
-        errorCallback({
-            type: "jitsiError",
-            errorObject: JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED
-        });
+        errorCallback(
+            new JitsiTrackError(JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED));
     },
     /**
      * Asks Chrome extension to call chooseDesktopMedia and gets chrome
                                 streamCallback, failCallback);
                         }, 500);
                     },
-                    function (arg) {
-                        logger.log("Failed to install the extension from:"
-                            + getWebStoreInstallUrl(self.options), arg);
-                        failCallback({
-                            type: "jitsiError",
-                            errorObject: JitsiTrackErrors
-                                .CHROME_EXTENSION_INSTALLATION_ERROR
-                        });
-                    }
+                    handleExtensionInstallationError
                 );
             } catch(e) {
-                logger.log("Failed to install the extension from:"
-                    + self.getWebStoreInstallUrl(this.options), e);
-                failCallback({
-                    type: "jitsiError",
-                    errorObject:
-                        JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR
-                });
+                handleExtensionInstallationError(e);
             }
         }
+
+        function handleExtensionInstallationError(e) {
+            var msg = "Failed to install the extension from "
+                + getWebStoreInstallUrl(self.options);
+
+            logger.log(msg, e);
+
+            failCallback(new JitsiTrackError(
+                JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR,
+                msg
+            ));
+        }
     }
 };
 
         },
         function (response) {
             if (!response) {
-                failCallback(chrome.runtime.lastError);
+                // possibly re-wraping error message to make code consistent
+                var lastError = chrome.runtime.lastError;
+                failCallback(lastError instanceof Error
+                    ? lastError
+                    : new JitsiTrackError(
+                        JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
+                        lastError));
                 return;
             }
             logger.log("Response from extension: ", response);
                 // then the callback is called with an empty streamId.
                 if(response.streamId === "")
                 {
-                    failCallback({
-                        type: "jitsiError",
-                        errorObject:
-                            JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED
-                    });
+                    failCallback(new JitsiTrackError(
+                        JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED));
                     return;
                 }
 
-                failCallback("Extension failed to get the stream");
+                failCallback(new JitsiTrackError(
+                    JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
+                    response.error));
             }
         }
     );

modules/statistics/statistics.js

 var StatisticsEvents = require("../../service/statistics/Events");
 var CallStats = require("./CallStats");
 var ScriptUtil = require('../util/ScriptUtil');
+var JitsiTrackError = require("../../JitsiTrackError");
 
 // Since callstats.io is a third party, we cannot guarantee the quality of their
 // service. More specifically, their server may take noticeably long time to
  */
 var LOG_INTERVAL = 60000;
 
+/**
+ * callstats strips any additional fields from Error except for "name", "stack",
+ * "message" and "constraintName". So we need to bundle additional information
+ * from JitsiTrackError into error passed to callstats to preserve valuable
+ * information about error.
+ * @param {JitsiTrackError} error
+ */
+function formatJitsiTrackErrorForCallStats(error) {
+    var err = new Error();
+
+    // Just copy original stack from error
+    err.stack = error.stack;
+
+    // Combine name from error's name plus (possibly) name of original GUM error
+    err.name = (error.name || "Unknown error") + (error.gum && error.gum.error
+        && error.gum.error.name ? " - " + error.gum.error.name : "");
+
+    // Put all constraints into this field. For constraint failed errors we will
+    // still know which exactly constraint failed as it will be a part of
+    // message.
+    err.constraintName = error.gum && error.gum.constraints
+        ? JSON.stringify(error.gum.constraints) : "";
+
+    // Just copy error's message.
+    err.message = error.message;
+
+    return err;
+}
+
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();
  * @param {Error} e error to send
  */
 Statistics.prototype.sendGetUserMediaFailed = function (e) {
-    if(this.callstats)
-        CallStats.sendGetUserMediaFailed(e, this.callstats);
+    if(this.callstats) {
+        CallStats.sendGetUserMediaFailed(
+            e instanceof JitsiTrackError
+                ? formatJitsiTrackErrorForCallStats(e)
+                : e,
+            this.callstats);
+    }
 };
 
 /**
  * @param {Error} e error to send
  */
 Statistics.sendGetUserMediaFailed = function (e) {
-    CallStats.sendGetUserMediaFailed(e, null);
+    CallStats.sendGetUserMediaFailed(
+        e instanceof JitsiTrackError
+            ? formatJitsiTrackErrorForCallStats(e)
+            : e,
+        null);
 };
 
 /**