Makes sure we add/remove all onended events for media streams in one central place.

modules/RTC/LocalStream.js

         };
     }
 
-    this.stream.onended = function () {
-        self.streamEnded();
-    };
+    APP.RTC.addMediaStreamInactiveHandler(
+        this.stream,
+        function () {
+            self.streamEnded();
+        });
+
     if (RTCBrowserType.isFirefox()) {
         implementOnEndedHandling(this.stream);
     }

modules/RTC/RTC.js

     /**
      * A method to handle stopping of the stream.
      * One point to handle the differences in various implementations.
+     * @param mediaStream MediaStream object to stop.
      */
     stopMediaStream: function (mediaStream) {
         mediaStream.getAudioTracks().forEach(function (track) {
         if (mediaStream.stop) {
             mediaStream.stop();
         }
+    },
+    /**
+     * Adds onended handler to a MediaStream.
+     * @param mediaStream a MediaStream to attach onended handler
+     * @param handler the handler
+     */
+    addMediaStreamInactiveHandler: function (mediaStream, handler) {
+        if (mediaStream.addEventListener) {
+            // chrome
+            mediaStream.onended = handler;
+        } else {
+            // themasys
+            mediaStream.attachEvent('ended', function () {
+                handler(mediaStream);
+            });
+        }
+    },
+    /**
+     * Removes onended handler.
+     * @param mediaStream the MediaStream to remove the handler from.
+     * @param handler the handler to remove.
+     */
+    removeMediaStreamInactiveHandler: function (mediaStream, handler) {
+        if (mediaStream.removeEventListener) {
+            // chrome
+            mediaStream.onended = null;
+        } else {
+            // themasys
+            mediaStream.detachEvent('ended', handler);
+        }
     }
 };
 

modules/UI/videolayout/LocalVideo.js

     APP.RTC.attachMediaStream(localVideoSelector, stream.getOriginalStream());
 
     // Add stream ended handler
-    stream.getOriginalStream().onended = function () {
+    APP.RTC.addMediaStreamInactiveHandler(
+        stream.getOriginalStream(), function () {
         // We have to re-select after attach when Temasys plugin is used,
         // because <video> element is replaced with <object>
         localVideo = $('#' + localVideo.id)[0];
         localVideoContainer.removeChild(localVideo);
         self.VideoLayout.updateRemovedVideo(APP.xmpp.myResource());
-    };
+    });
 };
 
 LocalVideo.prototype.joined = function (jid) {

modules/UI/videolayout/RemoteVideo.js

         APP.RTC.attachMediaStream(sel, stream);
     }
 
-    stream.onended = function () {
-        console.log('stream ended', this);
+    APP.RTC.addMediaStreamInactiveHandler(
+        stream, function () {
+            console.log('stream ended', this);
 
-        self.removeRemoteStreamElement(stream, isVideo, newElementId);
-
-    };
+            self.removeRemoteStreamElement(stream, isVideo, newElementId);
+    });
 
     // Add click handler.
     var onClickHandler = function (event) {

modules/desktopsharing/desktopsharing.js

     if (!switchInProgress && isUsingScreenStream) {
         APP.desktopsharing.toggleScreenSharing();
     }
-    //FIXME: to be verified
-    if (stream.removeEventListener) {
-        stream.removeEventListener('ended', onEndedHandler);
-    } else {
-        stream.detachEvent('ended', onEndedHandler);
-    }
+
+    APP.RTC.removeMediaStreamInactiveHandler(stream, onEndedHandler);
 }
 
 module.exports = {
                     isUsingScreenStream = true;
                     // Hook 'ended' event to restore camera
                     // when screen stream stops
-                    //FIXME: to be verified
-                    if (stream.addEventListener) {
-                        stream.addEventListener('ended', function () {
-                            onEndedHandler(stream);
-                        });
-                    } else {
-                        stream.attachEvent('ended', function () {
-                            onEndedHandler(stream);
-                        });
-                    }
+                    APP.RTC.addMediaStreamInactiveHandler(
+                        stream, onEndedHandler);
                     newStreamCreated(stream);
                 },
                 getDesktopStreamFailed);