Remove support for useCapture

src/ol/events.js

@@ -96,8 +96,7 @@ ol.events.ListenerFunctionType;
  *     callOnce: boolean,
  *     listener: ol.events.ListenerFunctionType,
  *     target: (EventTarget|ol.events.EventTarget),
- *     type: (ol.events.EventType|string),
- *     useCapture: boolean}}
+ *     type: (ol.events.EventType|string)}}
  */
 ol.events.ListenerObjType;
 
@@ -127,19 +126,16 @@ ol.events.bindListener_ = function(listenerObj) {
  * @param {!Function} listener The listener function.
  * @param {Object=} opt_this The `this` value inside the listener.
  * @param {boolean=} opt_remove Remove the found listener from the array.
- * @param {boolean=} opt_useCapture The capture flag for the listener.
  * @return {ol.events.ListenerObjType|undefined} The matching listener.
  * @private
  */
 ol.events.findListener_ = function(
-    listenerArray, listener, opt_this, opt_remove, opt_useCapture) {
+    listenerArray, listener, opt_this, opt_remove) {
   var listenerObj;
-  var useCapture = !!opt_useCapture;
   for (var i = 0, ii = listenerArray.length; i < ii; ++i) {
     listenerObj = listenerArray[i];
     if (listenerObj.listener === listener &&
-        listenerObj.bindTo === opt_this &&
-        listenerObj.useCapture === useCapture) {
+        listenerObj.bindTo === opt_this) {
       if (opt_remove) {
         listenerArray.splice(i, 1);
       }
@@ -177,23 +173,17 @@ ol.events.getListeners = function(target, type) {
  * @param {Object=} opt_this Object referenced by the `this` keyword in the
  *     listener. Default is the `target`.
  * @param {boolean=} opt_once If true, add the listener as one-off listener.
- * @param {boolean=} opt_useCapture Use capture. For listeners on an
- *     {@link ol.events.EventTarget}, `true` simply means that the listener will
- *     be called before already registered listeners. Default is false.
  * @return {ol.events.Key} Unique key for the listener.
  */
-ol.events.listen = function(
-    target, type, listener, opt_this, opt_once, opt_useCapture) {
+ol.events.listen = function(target, type, listener, opt_this, opt_once) {
   if (Array.isArray(type)) {
     var keys = [];
     type.forEach(function(t) {
-      keys.push(ol.events.listen(target, t, listener, opt_this, opt_once,
-          opt_useCapture));
+      keys.push(ol.events.listen(target, t, listener, opt_this, opt_once));
     });
     return keys;
   }
 
-  var useCapture = !!opt_useCapture;
   var listenerMap = target[ol.events.LISTENER_MAP_PROP_];
   if (!listenerMap) {
     target[ol.events.LISTENER_MAP_PROP_] = listenerMap = {};
@@ -203,7 +193,7 @@ ol.events.listen = function(
     listenerArray = listenerMap[type] = [];
   }
   var listenerObj = ol.events.findListener_(listenerArray, listener, opt_this,
-      false, useCapture);
+      false);
   if (listenerObj) {
     if (!opt_once) {
       // Turn one-off listener into a permanent one.
@@ -215,11 +205,9 @@ ol.events.listen = function(
       callOnce: !!opt_once,
       listener: listener,
       target: target,
-      type: type,
-      useCapture: useCapture
+      type: type
     });
-    target.addEventListener(type, ol.events.bindListener_(listenerObj),
-        useCapture);
+    target.addEventListener(type, ol.events.bindListener_(listenerObj));
     listenerArray.push(listenerObj);
   }
 
@@ -246,15 +234,11 @@ ol.events.listen = function(
  * @param {ol.events.ListenerFunctionType} listener Listener.
  * @param {Object=} opt_this Object referenced by the `this` keyword in the
  *     listener. Default is the `target`.
- * @param {boolean=} opt_useCapture Use capture. For listeners on an
- *     {@link ol.events.EventTarget}, `true` simply means that the listener will
- *     be called before already registered listeners. Default is false.
  * @return {ol.events.Key} Key for unlistenByKey.
  */
 ol.events.listenOnce = function(
-    target, type, listener, opt_this, opt_useCapture) {
-  return ol.events.listen(target, type, listener, opt_this, true,
-      opt_useCapture);
+    target, type, listener, opt_this) {
+  return ol.events.listen(target, type, listener, opt_this, true);
 };
 
 
@@ -271,15 +255,11 @@ ol.events.listenOnce = function(
  * @param {ol.events.ListenerFunctionType} listener Listener.
  * @param {Object=} opt_this Object referenced by the `this` keyword in the
  *     listener. Default is the `target`.
- * @param {boolean=} opt_useCapture Use capture. For listeners on an
- *     {@link ol.events.EventTarget}, `true` simply means that the listener will
- *     be called before already registered listeners. Default is false.
  */
-ol.events.unlisten = function(
-    target, type, listener, opt_this, opt_useCapture) {
+ol.events.unlisten = function(target, type, listener, opt_this) {
   if (Array.isArray(type)) {
     type.forEach(function(t) {
-      ol.events.unlisten(target, t, listener, opt_this, opt_useCapture);
+      ol.events.unlisten(target, t, listener, opt_this);
     });
     return;
   }
@@ -287,7 +267,7 @@ ol.events.unlisten = function(
   var listenerArray = ol.events.getListeners(target, type);
   if (listenerArray) {
     var listenerObj = ol.events.findListener_(listenerArray, listener,
-        opt_this, false, !!opt_useCapture);
+        opt_this, false);
     if (listenerObj) {
       ol.events.unlistenByKey(listenerObj);
     }
@@ -311,11 +291,10 @@ ol.events.unlistenByKey = function(key) {
   }
 
   if (key && key.target) {
-    key.target.removeEventListener(key.type, key.boundListener, key.useCapture);
+    key.target.removeEventListener(key.type, key.boundListener);
     var listenerArray = ol.events.getListeners(key.target, key.type);
     if (listenerArray) {
-      ol.events.findListener_(listenerArray, key.listener,
-          key.bindTo, true, key.useCapture);
+      ol.events.findListener_(listenerArray, key.listener, key.bindTo, true);
       if (listenerArray.length === 0) {
         var listenerMap = key.target[ol.events.LISTENER_MAP_PROP_];
         delete listenerMap[key.type];

src/ol/events/eventtarget.js

@@ -12,12 +12,7 @@ goog.require('ol.events.Event');
  * There are two important simplifications compared to the specification:
  *
  * 1. The handling of `useCapture` in `addEventListener` and
- *    `removeEventListener`. There is no real capture model. Instead, when
- *    adding a listener, `useCapture` means that it will be added as first
- *    listener, causing it to be called before other listeners. When removing a
- *    listener, the `useCapture` argument will be ignored, and the listener will
- *    be removed regardless of whether it was added with `useCapture` set to
- *    true or false.
+ *    `removeEventListener`. There is no real capture model.
  * 2. The handling of `stopPropagation` and `preventDefault` on `dispatchEvent`.
  *    There is no event target hierarchy. When a listener calls
  *    `stopPropagation` or `preventDefault` on an event object, it means that no
@@ -44,21 +39,15 @@ goog.inherits(ol.events.EventTarget, goog.Disposable);
 /**
  * @param {ol.events.EventType|string} type Type.
  * @param {ol.events.ListenerFunctionType} listener Listener.
- * @param {boolean=} opt_capture Call listener before already registered
- *     listeners. Default is false.
  */
 ol.events.EventTarget.prototype.addEventListener = function(
-    type, listener, opt_capture) {
+    type, listener) {
   var listeners = this.listeners_[type];
   if (!listeners) {
     listeners = this.listeners_[type] = [];
   }
   if (listeners.indexOf(listener) === -1) {
-    if (opt_capture) {
-      listeners.push(listener);
-    } else {
-      listeners.unshift(listener);
-    }
+    listeners.unshift(listener);
   }
 };
 
@@ -122,10 +111,8 @@ ol.events.EventTarget.prototype.hasListener = function(opt_type) {
 /**
  * @param {ol.events.EventType|string} type Type.
  * @param {ol.events.ListenerFunctionType} listener Listener.
- * @param {boolean=} opt_capture Ignored. For W3C compatibility only.
  */
-ol.events.EventTarget.prototype.removeEventListener = function(
-    type, listener, opt_capture) {
+ol.events.EventTarget.prototype.removeEventListener = function(type, listener) {
   var listeners = this.listeners_[type];
   if (listeners) {
     var index = listeners.indexOf(listener);