Renames JitsiTrack.stop method and TRACK_STOPPED event. Fixes minor issues with TRACK_REMOVED event.

JitsiConference.js

 var Statistics = require("./modules/statistics/statistics");
 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
+var JitsiTrackErrors = require("./JitsiTrackErrors");
 var Settings = require("./modules/settings/Settings");
 
 /**
  * and there is already another video track in the conference.
  */
 JitsiConference.prototype.addTrack = function (track) {
+    if(track.disposed)
+    {
+        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+    }
     if (track.isVideoTrack()) {
         if (this.rtc.getLocalVideoStream()) {
             throw new Error("cannot add second video track to the conference");
             }
 
             track.muteHandler = this._fireMuteChangeEvent.bind(this, track);
-            track.stopHandler = this.removeTrack.bind(this, track);
             track.audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
             track.addEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
                                    track.muteHandler);
-            track.addEventListener(JitsiTrackEvents.TRACK_STOPPED,
-                                   track.stopHandler);
             track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
                                    track.audioLevelHandler);
             //FIXME: This dependacy is not necessary. This is quick fix.
  * @returns {Promise}
  */
 JitsiConference.prototype.removeTrack = function (track) {
+    if(track.disposed)
+    {
+        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+    }
     if(!this.room){
         if(this.rtc) {
             this.rtc.removeLocalStream(track);
             this.rtc.removeLocalStream(track);
             track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
                 track.muteHandler);
-            track.removeEventListener(JitsiTrackEvents.TRACK_STOPPED,
-                track.stopHandler);
             track.removeEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
                 track.audioLevelHandler);
             this.room.removeListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
                 for(var i = 0; i < tracks.length; i++) {
                     if(tracks[i] && tracks[i].stream &&
                         RTC.getStreamID(tracks[i].stream) == streamId){
-                        var track = participant._tracks.splice(i, 1);
+                        var track = participant._tracks.splice(i, 1)[0];
                         conference.eventEmitter.emit(
                             JitsiConferenceEvents.TRACK_REMOVED, track);
                         return;

JitsiMeetJS.js

                             Statistics.startLocalStats(mStream,
                                 track.setAudioLevel.bind(track));
                             track.addEventListener(
-                                JitsiTrackEvents.TRACK_STOPPED,
+                                JitsiTrackEvents.LOCAL_TRACK_STOPPED,
                                 function(){
                                     Statistics.stopLocalStats(mStream);
                                 });

JitsiTrackErrors.js

     },
     UNSUPPORTED_RESOLUTION: "gum.unsupported_resolution",
     FIREFOX_EXTENSION_NEEDED: "gum.firefox_extension_needed",
-    GENERAL: "gum.general"
+    GENERAL: "gum.general",
+    TRACK_IS_DISPOSED: "track.track_is_disposed"
 };

JitsiTrackEvents.js

     /**
      * The media track was removed to the conference.
      */
-    TRACK_STOPPED: "track.stopped",
+    LOCAL_TRACK_STOPPED: "track.stopped",
     /**
      * The video type("camera" or "desktop") of the track was changed.
      */

doc/API.md

         - CONNECTION_DISCONNECTED - indicates that we are disconnected.
         - WRONG_STATE - indicates that the user has performed action that can't be executed because the connection is in wrong state.
 
+    3. tracks
+        - LOCAL_TRACK_STOPPED - indicates that a local track was stopped. This
+        event can be fired when ```dispose()``` method is called or for other reasons.
+
 * ```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>```.
     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```.
 
 6. detach(container) - removes the track from the container.
 
-7. stop() - stop sending the track to the other participants in the conference. Returns Promise.
+7. dispose() - disposes the track. If the track is added to a conference the track will be removed. Returns Promise.
 
    Note: This method is implemented only for the local tracks.
 

doc/example/example.js

             function () {
                 console.log("local track muted");
             });
-        localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+        localTracks[i].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
             function () {
                 console.log("local track stoped");
             });
         function () {
             console.log("remote track muted");
         });
-    track.addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+    track.addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
         function () {
             console.log("remote track stoped");
         });
 function switchVideo() {
     isVideo = !isVideo;
     if(localTracks[1]) {
-        localTracks[1].stop();
+        localTracks[1].dispose();
         localTracks.pop();
     }
     JitsiMeetJS.createLocalTracks({devices: isVideo? ["video"] : ["desktop"]}).
                 function () {
                     console.log("local track muted");
                 });
-            localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+            localTracks[1].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
                 function () {
                     console.log("local track stoped");
                 });

modules/RTC/JitsiLocalTrack.js

     this.deviceId = deviceId;
     this.startMuted = false;
     this.ssrc = null;
+    this.disposed = false;
     //FIXME: This dependacy is not necessary.
     this.conference = null;
     JitsiTrack.call(this, null, stream,
         function () {
             if(!this.dontFireRemoveEvent)
                 this.eventEmitter.emit(
-                    JitsiTrackEvents.TRACK_STOPPED);
+                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
             this.dontFireRemoveEvent = false;
         }.bind(this));
     this.initialMSID = this.getMSID();
  * NOTE: Works for local tracks only.
  * @returns {Promise}
  */
-JitsiLocalTrack.prototype.stop = function () {
+JitsiLocalTrack.prototype.dispose = function () {
     var promise = Promise.resolve();
 
     if (this.conference){
         RTCUtils.stopMediaStream(this.stream);
         this.detach();
     }
+    this.disposed = true;
 
     return promise;
 };

modules/RTC/JitsiRemoteTrack.js

  */
 function JitsiRemoteTrack(RTC, data, sid, ssrc) {
     JitsiTrack.call(this, RTC, data.stream,
-        function () {
-            this.eventEmitter.emit(JitsiTrackEvents.TRACK_STOPPED);
-        }.bind(this), data.jitsiTrackType);
+        function () {}, data.jitsiTrackType);
     this.rtc = RTC;
     this.sid = sid;
     this.stream = data.stream;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 }
 
-delete JitsiRemoteTrack.prototype.stop;
+delete JitsiRemoteTrack.prototype.dispose;
 
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

 }
 
 /**
- * Stops sending the media track. And removes it from the HTML.
+ * Dispose sending the media track. And removes it from the HTML.
  * NOTE: Works for local tracks only.
  */
-JitsiTrack.prototype.stop = function () {
+JitsiTrack.prototype.dispose = function () {
 }
 
 /**