Merge pull request #4711 from ahocevar/no-goog-events

Removal of goog.events.*
2016-02-03 14:05:32 +01:00
parent a848321842 7a8d15fe47
commit 00116b7c74
126 changed files with 2761 additions and 1202 deletions
--- a/2
+++ b/2
@@ -181,7 +181,7 @@ build/timestamps/check-%-timestamp: $(BUILD_HOSTED)/examples/%.html \
                                    $(BUILD_HOSTED)/build/ol.js \
                                    $(BUILD_HOSTED)/css/ol.css
 	@mkdir -p $(@D)
-	./node_modules/.bin/phantomjs --ssl-protocol=any --ignore-ssl-errors=true bin/check-example.js $<
+	./node_modules/.bin/phantomjs --local-to-remote-url-access=true --ssl-protocol=any --ignore-ssl-errors=true bin/check-example.js $<
 	@touch $@

 build/timestamps/check-requires-timestamp: $(SRC_JS) $(EXAMPLES_JS) \
--- a/externs/closure-compiler.js
+++ b/externs/closure-compiler.js
@@ -15,3 +15,13 @@
 * @see http://www.w3.org/TR/pointerevents/#the-touch-action-css-property
 */
 CSSProperties.prototype.touchAction;
+
+/**
+ * @type {number}
+ */
+WheelEvent.DOM_DELTA_LINE;
+
+/**
+ * @type {number}
+ */
+WheelEvent.DOM_DELTA_PIXEL;
--- a/externs/readme.md
+++ b/externs/readme.md
@@ -28,7 +28,7 @@ In the source file (`src/ol/MapBrowserEvent.js`), the class needs to implement t
 * @constructor
 * @implements {oli.MapBrowserEvent}
 */
-ol.MapBrowserEvent = function(type, map, browserEvent, opt_frameState) {
+ol.MapBrowserEvent = function(type, map, originalEvent, opt_frameState) {

  // ...

--- a/src/ol/collection.js
+++ b/src/ol/collection.js
@@ -7,7 +7,7 @@ goog.provide('ol.Collection');
 goog.provide('ol.CollectionEvent');
 goog.provide('ol.CollectionEventType');

-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.Object');


@@ -36,7 +36,7 @@ ol.CollectionEventType = {
 * type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.CollectionEvent}
 * @param {ol.CollectionEventType} type Type.
 * @param {*=} opt_element Element.
@@ -54,7 +54,7 @@ ol.CollectionEvent = function(type, opt_element, opt_target) {
  this.element = opt_element;

 };
-goog.inherits(ol.CollectionEvent, goog.events.Event);
+goog.inherits(ol.CollectionEvent, ol.events.Event);


 /**
--- a/src/ol/control/attributioncontrol.js
+++ b/src/ol/control/attributioncontrol.js
@@ -5,8 +5,8 @@ goog.provide('ol.control.Attribution');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.style');
 goog.require('ol');
@@ -95,8 +95,7 @@ ol.control.Attribution = function(opt_options) {
    'title': tipLabel
  }, activeLabel);

-  goog.events.listen(button, goog.events.EventType.CLICK,
-      this.handleClick_, false, this);
+  ol.events.listen(button, ol.events.EventType.CLICK, this.handleClick_, this);

  var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
      ol.css.CLASS_CONTROL +
@@ -328,7 +327,7 @@ ol.control.Attribution.prototype.insertLogos_ = function(frameState) {


 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
 * @private
 */
 ol.control.Attribution.prototype.handleClick_ = function(event) {
--- a/src/ol/control/control.js
+++ b/src/ol/control/control.js
@@ -1,7 +1,7 @@
 goog.provide('ol.control.Control');

 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol');
 goog.require('ol.MapEventType');
 goog.require('ol.Object');
@@ -60,7 +60,7 @@ ol.control.Control = function(options) {

  /**
   * @protected
-   * @type {!Array.<?number>}
+   * @type {!Array.<ol.events.Key>}
   */
  this.listenerKeys = [];

@@ -107,18 +107,18 @@ ol.control.Control.prototype.setMap = function(map) {
  if (this.map_) {
    goog.dom.removeNode(this.element);
  }
-  if (this.listenerKeys.length > 0) {
-    this.listenerKeys.forEach(goog.events.unlistenByKey);
-    this.listenerKeys.length = 0;
+  for (var i = 0, ii = this.listenerKeys.length; i < ii; ++i) {
+    ol.events.unlistenByKey(this.listenerKeys[i]);
  }
+  this.listenerKeys.length = 0;
  this.map_ = map;
  if (this.map_) {
    var target = this.target_ ?
        this.target_ : map.getOverlayContainerStopEvent();
    target.appendChild(this.element);
    if (this.render !== ol.nullFunction) {
-      this.listenerKeys.push(goog.events.listen(map,
-          ol.MapEventType.POSTRENDER, this.render, false, this));
+      this.listenerKeys.push(ol.events.listen(map,
+          ol.MapEventType.POSTRENDER, this.render, this));
    }
    map.render();
  }
--- a/src/ol/control/fullscreencontrol.js
+++ b/src/ol/control/fullscreencontrol.js
@@ -5,8 +5,8 @@ goog.require('goog.dom');
 goog.require('goog.dom.classlist');
 goog.require('goog.dom.fullscreen');
 goog.require('goog.dom.fullscreen.EventType');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol');
 goog.require('ol.control.Control');
 goog.require('ol.css');
@@ -64,12 +64,12 @@ ol.control.FullScreen = function(opt_options) {
    'title': tipLabel
  }, this.labelNode_);

-  goog.events.listen(button, goog.events.EventType.CLICK,
-      this.handleClick_, false, this);
+  ol.events.listen(button, ol.events.EventType.CLICK,
+      this.handleClick_, this);

-  goog.events.listen(goog.global.document,
+  ol.events.listen(goog.global.document,
      goog.dom.fullscreen.EventType.CHANGE,
-      this.handleFullScreenChange_, false, this);
+      this.handleFullScreenChange_, this);

  var cssClasses = this.cssClassName_ + ' ' + ol.css.CLASS_UNSELECTABLE +
      ' ' + ol.css.CLASS_CONTROL + ' ' +
@@ -98,7 +98,7 @@ goog.inherits(ol.control.FullScreen, ol.control.Control);


 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
 * @private
 */
 ol.control.FullScreen.prototype.handleClick_ = function(event) {
--- a/src/ol/control/mousepositioncontrol.js
+++ b/src/ol/control/mousepositioncontrol.js
@@ -3,8 +3,8 @@
 goog.provide('ol.control.MousePosition');

 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.CoordinateFormatType');
 goog.require('ol.Object');
 goog.require('ol.Pixel');
@@ -53,9 +53,9 @@ ol.control.MousePosition = function(opt_options) {
    target: options.target
  });

-  goog.events.listen(this,
+  ol.events.listen(this,
      ol.Object.getChangeEventType(ol.control.MousePositionProperty.PROJECTION),
-      this.handleProjectionChanged_, false, this);
+      this.handleProjectionChanged_, this);

  if (options.coordinateFormat) {
    this.setCoordinateFormat(options.coordinateFormat);
@@ -154,21 +154,21 @@ ol.control.MousePosition.prototype.getProjection = function() {


 /**
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} event Browser event.
 * @protected
 */
-ol.control.MousePosition.prototype.handleMouseMove = function(browserEvent) {
+ol.control.MousePosition.prototype.handleMouseMove = function(event) {
  var map = this.getMap();
-  this.lastMouseMovePixel_ = map.getEventPixel(browserEvent.getBrowserEvent());
+  this.lastMouseMovePixel_ = map.getEventPixel(event);
  this.updateHTML_(this.lastMouseMovePixel_);
 };


 /**
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} event Browser event.
 * @protected
 */
-ol.control.MousePosition.prototype.handleMouseOut = function(browserEvent) {
+ol.control.MousePosition.prototype.handleMouseOut = function(event) {
  this.updateHTML_(null);
  this.lastMouseMovePixel_ = null;
 };
@@ -183,10 +183,10 @@ ol.control.MousePosition.prototype.setMap = function(map) {
  if (map) {
    var viewport = map.getViewport();
    this.listenerKeys.push(
-        goog.events.listen(viewport, goog.events.EventType.MOUSEMOVE,
-            this.handleMouseMove, false, this),
-        goog.events.listen(viewport, goog.events.EventType.MOUSEOUT,
-            this.handleMouseOut, false, this)
+        ol.events.listen(viewport, ol.events.EventType.MOUSEMOVE,
+            this.handleMouseMove, this),
+        ol.events.listen(viewport, ol.events.EventType.MOUSEOUT,
+            this.handleMouseOut, this)
    );
  }
 };
--- a/src/ol/control/overviewmapcontrol.js
+++ b/src/ol/control/overviewmapcontrol.js
@@ -3,8 +3,8 @@ goog.provide('ol.control.OverviewMap');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.math.Size');
 goog.require('goog.style');
 goog.require('ol');
@@ -83,8 +83,8 @@ ol.control.OverviewMap = function(opt_options) {
    'title': tipLabel
  }, activeLabel);

-  goog.events.listen(button, goog.events.EventType.CLICK,
-      this.handleClick_, false, this);
+  ol.events.listen(button, ol.events.EventType.CLICK,
+      this.handleClick_, this);

  var ovmapDiv = goog.dom.createDom('DIV', 'ol-overviewmap-map');

@@ -159,9 +159,9 @@ ol.control.OverviewMap.prototype.setMap = function(map) {
  goog.base(this, 'setMap', map);

  if (map) {
-    this.listenerKeys.push(goog.events.listen(
+    this.listenerKeys.push(ol.events.listen(
        map, ol.ObjectEventType.PROPERTYCHANGE,
-        this.handleMapPropertyChange_, false, this));
+        this.handleMapPropertyChange_, this));

    // TODO: to really support map switching, this would need to be reworked
    if (this.ovmap_.getLayers().getLength() === 0) {
@@ -203,9 +203,9 @@ ol.control.OverviewMap.prototype.handleMapPropertyChange_ = function(event) {
 * @private
 */
 ol.control.OverviewMap.prototype.bindView_ = function(view) {
-  goog.events.listen(view,
+  ol.events.listen(view,
      ol.Object.getChangeEventType(ol.ViewProperty.ROTATION),
-      this.handleRotationChanged_, false, this);
+      this.handleRotationChanged_, this);
 };


@@ -215,9 +215,9 @@ ol.control.OverviewMap.prototype.bindView_ = function(view) {
 * @private
 */
 ol.control.OverviewMap.prototype.unbindView_ = function(view) {
-  goog.events.unlisten(view,
+  ol.events.unlisten(view,
      ol.Object.getChangeEventType(ol.ViewProperty.ROTATION),
-      this.handleRotationChanged_, false, this);
+      this.handleRotationChanged_, this);
 };


@@ -432,7 +432,7 @@ ol.control.OverviewMap.prototype.calculateCoordinateRotate_ = function(


 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
 * @private
 */
 ol.control.OverviewMap.prototype.handleClick_ = function(event) {
@@ -459,11 +459,11 @@ ol.control.OverviewMap.prototype.handleToggle_ = function() {
  if (!this.collapsed_ && !ovmap.isRendered()) {
    ovmap.updateSize();
    this.resetExtent_();
-    goog.events.listenOnce(ovmap, ol.MapEventType.POSTRENDER,
+    ol.events.listenOnce(ovmap, ol.MapEventType.POSTRENDER,
        function(event) {
          this.updateBox_();
        },
-        false, this);
+        this);
  }
 };

--- a/src/ol/control/rotatecontrol.js
+++ b/src/ol/control/rotatecontrol.js
@@ -2,8 +2,8 @@ goog.provide('ol.control.Rotate');

 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol');
 goog.require('ol.animation');
 goog.require('ol.control.Control');
@@ -53,8 +53,8 @@ ol.control.Rotate = function(opt_options) {
    'title': tipLabel
  }, this.label_);

-  goog.events.listen(button, goog.events.EventType.CLICK,
-      ol.control.Rotate.prototype.handleClick_, false, this);
+  ol.events.listen(button, ol.events.EventType.CLICK,
+      ol.control.Rotate.prototype.handleClick_, this);

  var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
      ol.css.CLASS_CONTROL;
@@ -97,7 +97,7 @@ goog.inherits(ol.control.Rotate, ol.control.Control);


 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
 * @private
 */
 ol.control.Rotate.prototype.handleClick_ = function(event) {
--- a/src/ol/control/scalelinecontrol.js
+++ b/src/ol/control/scalelinecontrol.js
@@ -4,7 +4,7 @@ goog.provide('ol.control.ScaleLineUnits');

 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.style');
 goog.require('ol');
 goog.require('ol.Object');
@@ -109,9 +109,9 @@ ol.control.ScaleLine = function(opt_options) {
    target: options.target
  });

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.control.ScaleLineProperty.UNITS),
-      this.handleUnitsChanged_, false, this);
+      this.handleUnitsChanged_, this);

  this.setUnits(/** @type {ol.control.ScaleLineUnits} */ (options.units) ||
      ol.control.ScaleLineUnits.METRIC);
--- a/src/ol/control/zoomcontrol.js
+++ b/src/ol/control/zoomcontrol.js
@@ -1,8 +1,8 @@
 goog.provide('ol.control.Zoom');

 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.animation');
 goog.require('ol.control.Control');
 goog.require('ol.css');
@@ -42,9 +42,9 @@ ol.control.Zoom = function(opt_options) {
    'title': zoomInTipLabel
  }, zoomInLabel);

-  goog.events.listen(inElement,
-      goog.events.EventType.CLICK, goog.partial(
-          ol.control.Zoom.prototype.handleClick_, delta), false, this);
+  ol.events.listen(inElement,
+      ol.events.EventType.CLICK, goog.partial(
+          ol.control.Zoom.prototype.handleClick_, delta), this);

  var outElement = goog.dom.createDom('BUTTON', {
    'class': className + '-out',
@@ -52,9 +52,9 @@ ol.control.Zoom = function(opt_options) {
    'title': zoomOutTipLabel
  }, zoomOutLabel);

-  goog.events.listen(outElement,
-      goog.events.EventType.CLICK, goog.partial(
-          ol.control.Zoom.prototype.handleClick_, -delta), false, this);
+  ol.events.listen(outElement,
+      ol.events.EventType.CLICK, goog.partial(
+          ol.control.Zoom.prototype.handleClick_, -delta), this);

  var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
      ol.css.CLASS_CONTROL;
@@ -78,7 +78,7 @@ goog.inherits(ol.control.Zoom, ol.control.Control);

 /**
 * @param {number} delta Zoom delta.
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
 * @private
 */
 ol.control.Zoom.prototype.handleClick_ = function(delta, event) {
--- a/src/ol/control/zoomslidercontrol.js
+++ b/src/ol/control/zoomslidercontrol.js
@@ -4,14 +4,12 @@ goog.provide('ol.control.ZoomSlider');

 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.Event');
-goog.require('goog.events.EventType');
-goog.require('goog.fx.DragEvent');
-goog.require('goog.fx.Dragger');
-goog.require('goog.fx.Dragger.EventType');
 goog.require('goog.math.Rect');
 goog.require('goog.style');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
+goog.require('ol.pointer.PointerEventHandler');
 goog.require('ol.Size');
 goog.require('ol.ViewHint');
 goog.require('ol.animation');
@@ -55,6 +53,30 @@ ol.control.ZoomSlider = function(opt_options) {
   */
  this.direction_ = ol.control.ZoomSlider.direction.VERTICAL;

+  /**
+   * @type {boolean}
+   */
+  this.dragging_;
+  /**
+   * @type {Array.<ol.events.Key>}
+   */
+  this.dragListenerKeys_;
+
+  /**
+   * @type {goog.math.Rect}
+   */
+  this.limits_;
+
+  /**
+   * @type {number|undefined}
+   */
+  this.previousX_;
+
+  /**
+   * @type {number|undefined}
+   */
+  this.previousY_;
+
  /**
   * The calculated thumb size (border box plus margins).  Set when initSlider_
   * is called.
@@ -85,24 +107,20 @@ ol.control.ZoomSlider = function(opt_options) {
      [className, ol.css.CLASS_UNSELECTABLE, ol.css.CLASS_CONTROL],
      thumbElement);

-  /**
-   * @type {goog.fx.Dragger}
-   * @private
-   */
-  this.dragger_ = new goog.fx.Dragger(thumbElement);
-  this.registerDisposable(this.dragger_);
+  var dragger = new ol.pointer.PointerEventHandler(containerElement);
+  this.registerDisposable(dragger);

-  goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.START,
-      this.handleDraggerStart_, false, this);
-  goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.DRAG,
-      this.handleDraggerDrag_, false, this);
-  goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.END,
-      this.handleDraggerEnd_, false, this);
+  ol.events.listen(dragger, ol.pointer.EventType.POINTERDOWN,
+      this.handleDraggerStart_, this);
+  ol.events.listen(dragger, ol.pointer.EventType.POINTERMOVE,
+      this.handleDraggerDrag_, this);
+  ol.events.listen(dragger, ol.pointer.EventType.POINTERUP,
+      this.handleDraggerEnd_, this);

-  goog.events.listen(containerElement, goog.events.EventType.CLICK,
-      this.handleContainerClick_, false, this);
-  goog.events.listen(thumbElement, goog.events.EventType.CLICK,
-      goog.events.Event.stopPropagation);
+  ol.events.listen(containerElement, ol.events.EventType.CLICK,
+      this.handleContainerClick_, this);
+  ol.events.listen(thumbElement, ol.events.EventType.CLICK,
+      ol.events.Event.stopPropagation);

  var render = options.render ? options.render : ol.control.ZoomSlider.render;

@@ -167,7 +185,7 @@ ol.control.ZoomSlider.prototype.initSlider_ = function() {
    this.direction_ = ol.control.ZoomSlider.direction.VERTICAL;
    limits = new goog.math.Rect(0, 0, 0, height);
  }
-  this.dragger_.setLimits(limits);
+  this.limits_ = limits;
  this.sliderInitialized_ = true;
 };

@@ -196,10 +214,10 @@ ol.control.ZoomSlider.render = function(mapEvent) {


 /**
- * @param {goog.events.BrowserEvent} browserEvent The browser event to handle.
+ * @param {Event} event The browser event to handle.
 * @private
 */
-ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) {
+ol.control.ZoomSlider.prototype.handleContainerClick_ = function(event) {
  var map = this.getMap();
  var view = map.getView();
  var currentResolution = view.getResolution();
@@ -211,8 +229,8 @@ ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) {
    easing: ol.easing.easeOut
  }));
  var relativePosition = this.getRelativePosition_(
-      browserEvent.offsetX - this.thumbSize_[0] / 2,
-      browserEvent.offsetY - this.thumbSize_[1] / 2);
+      event.offsetX - this.thumbSize_[0] / 2,
+      event.offsetY - this.thumbSize_[1] / 2);
  var resolution = this.getResolutionForPosition_(relativePosition);
  view.setResolution(view.constrainResolution(resolution));
 };
@@ -220,45 +238,79 @@ ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) {

 /**
 * Handle dragger start events.
- * @param {goog.fx.DragEvent} event The drag event.
+ * @param {ol.pointer.PointerEvent} event The drag event.
 * @private
 */
 ol.control.ZoomSlider.prototype.handleDraggerStart_ = function(event) {
-  this.getMap().getView().setHint(ol.ViewHint.INTERACTING, 1);
+  if (!this.dragging_ &&
+      event.originalEvent.target === this.element.firstElementChild) {
+    this.getMap().getView().setHint(ol.ViewHint.INTERACTING, 1);
+    this.previousX_ = event.clientX;
+    this.previousY_ = event.clientY;
+    this.dragging_ = true;
+
+    if (!this.dragListenerKeys_) {
+      var drag = this.handleDraggerDrag_;
+      var end = this.handleDraggerEnd_;
+      this.dragListenerKeys_ = [
+        ol.events.listen(document, ol.events.EventType.MOUSEMOVE, drag, this),
+        ol.events.listen(document, ol.events.EventType.TOUCHMOVE, drag, this),
+        ol.events.listen(document, ol.pointer.EventType.POINTERMOVE, drag, this),
+        ol.events.listen(document, ol.events.EventType.MOUSEUP, end, this),
+        ol.events.listen(document, ol.events.EventType.TOUCHEND, end, this),
+        ol.events.listen(document, ol.pointer.EventType.POINTERUP, end, this)
+      ];
+    }
+  }
 };


 /**
 * Handle dragger drag events.
 *
- * @param {goog.fx.DragEvent} event The drag event.
+ * @param {ol.pointer.PointerEvent|Event} event The drag event.
 * @private
 */
 ol.control.ZoomSlider.prototype.handleDraggerDrag_ = function(event) {
-  var relativePosition = this.getRelativePosition_(event.left, event.top);
-  this.currentResolution_ = this.getResolutionForPosition_(relativePosition);
-  this.getMap().getView().setResolution(this.currentResolution_);
+  if (this.dragging_) {
+    var element = this.element.firstElementChild;
+    var deltaX = event.clientX - this.previousX_ + parseInt(element.style.left, 10);
+    var deltaY = event.clientY - this.previousY_ + parseInt(element.style.top, 10);
+    var relativePosition = this.getRelativePosition_(deltaX, deltaY);
+    this.currentResolution_ = this.getResolutionForPosition_(relativePosition);
+    this.getMap().getView().setResolution(this.currentResolution_);
+    this.setThumbPosition_(this.currentResolution_);
+    this.previousX_ = event.clientX;
+    this.previousY_ = event.clientY;
+  }
 };


 /**
 * Handle dragger end events.
- * @param {goog.fx.DragEvent} event The drag event.
+ * @param {ol.pointer.PointerEvent|Event} event The drag event.
 * @private
 */
 ol.control.ZoomSlider.prototype.handleDraggerEnd_ = function(event) {
-  var map = this.getMap();
-  var view = map.getView();
-  view.setHint(ol.ViewHint.INTERACTING, -1);
-  goog.asserts.assert(this.currentResolution_,
-      'this.currentResolution_ should be defined');
-  map.beforeRender(ol.animation.zoom({
-    resolution: this.currentResolution_,
-    duration: this.duration_,
-    easing: ol.easing.easeOut
-  }));
-  var resolution = view.constrainResolution(this.currentResolution_);
-  view.setResolution(resolution);
+  if (this.dragging_) {
+    var map = this.getMap();
+    var view = map.getView();
+    view.setHint(ol.ViewHint.INTERACTING, -1);
+    goog.asserts.assert(this.currentResolution_,
+        'this.currentResolution_ should be defined');
+    map.beforeRender(ol.animation.zoom({
+      resolution: this.currentResolution_,
+      duration: this.duration_,
+      easing: ol.easing.easeOut
+    }));
+    var resolution = view.constrainResolution(this.currentResolution_);
+    view.setResolution(resolution);
+    this.dragging_ = false;
+    this.previousX_ = undefined;
+    this.previousY_ = undefined;
+    this.dragListenerKeys_.forEach(ol.events.unlistenByKey);
+    this.dragListenerKeys_ = null;
+  }
 };


@@ -270,15 +322,14 @@ ol.control.ZoomSlider.prototype.handleDraggerEnd_ = function(event) {
 */
 ol.control.ZoomSlider.prototype.setThumbPosition_ = function(res) {
  var position = this.getPositionForResolution_(res);
-  var dragger = this.dragger_;
  var thumb = goog.dom.getFirstElementChild(this.element);

  if (this.direction_ == ol.control.ZoomSlider.direction.HORIZONTAL) {
-    var left = dragger.limits.left + dragger.limits.width * position;
+    var left = this.limits_.left + this.limits_.width * position;
    goog.style.setPosition(thumb, left);
  } else {
-    var top = dragger.limits.top + dragger.limits.height * position;
-    goog.style.setPosition(thumb, dragger.limits.left, top);
+    var top = this.limits_.top + this.limits_.height * position;
+    goog.style.setPosition(thumb, this.limits_.left, top);
  }
 };

@@ -294,7 +345,7 @@ ol.control.ZoomSlider.prototype.setThumbPosition_ = function(res) {
 * @private
 */
 ol.control.ZoomSlider.prototype.getRelativePosition_ = function(x, y) {
-  var draggerLimits = this.dragger_.limits;
+  var draggerLimits = this.limits_;
  var amount;
  if (this.direction_ === ol.control.ZoomSlider.direction.HORIZONTAL) {
    amount = (x - draggerLimits.left) / draggerLimits.width;
--- a/src/ol/control/zoomtoextentcontrol.js
+++ b/src/ol/control/zoomtoextentcontrol.js
@@ -2,8 +2,8 @@ goog.provide('ol.control.ZoomToExtent');

 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.control.Control');
 goog.require('ol.css');

@@ -38,8 +38,8 @@ ol.control.ZoomToExtent = function(opt_options) {
    'title': tipLabel
  }, label);

-  goog.events.listen(button, goog.events.EventType.CLICK,
-      this.handleClick_, false, this);
+  ol.events.listen(button, ol.events.EventType.CLICK,
+      this.handleClick_, this);

  var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
      ol.css.CLASS_CONTROL;
@@ -54,7 +54,7 @@ goog.inherits(ol.control.ZoomToExtent, ol.control.Control);


 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
 * @private
 */
 ol.control.ZoomToExtent.prototype.handleClick_ = function(event) {
--- a/src/ol/deviceorientation.js
+++ b/src/ol/deviceorientation.js
@@ -1,7 +1,7 @@
 goog.provide('ol.DeviceOrientation');
 goog.provide('ol.DeviceOrientationProperty');

-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol');
 goog.require('ol.Object');
 goog.require('ol.has');
@@ -83,13 +83,13 @@ ol.DeviceOrientation = function(opt_options) {

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.listenerKey_ = null;

-  goog.events.listen(this,
+  ol.events.listen(this,
      ol.Object.getChangeEventType(ol.DeviceOrientationProperty.TRACKING),
-      this.handleTrackingChanged_, false, this);
+      this.handleTrackingChanged_, this);

  this.setTracking(options.tracking !== undefined ? options.tracking : false);

@@ -108,11 +108,10 @@ ol.DeviceOrientation.prototype.disposeInternal = function() {

 /**
 * @private
- * @param {goog.events.BrowserEvent} browserEvent Event.
+ * @param {Event} originalEvent Event.
 */
-ol.DeviceOrientation.prototype.orientationChange_ = function(browserEvent) {
-  var event = /** @type {DeviceOrientationEvent} */
-      (browserEvent.getBrowserEvent());
+ol.DeviceOrientation.prototype.orientationChange_ = function(originalEvent) {
+  var event = /** @type {DeviceOrientationEvent} */ (originalEvent);
  if (event.alpha !== null) {
    var alpha = ol.math.toRadians(event.alpha);
    this.set(ol.DeviceOrientationProperty.ALPHA, alpha);
@@ -208,10 +207,10 @@ ol.DeviceOrientation.prototype.handleTrackingChanged_ = function() {
  if (ol.has.DEVICE_ORIENTATION) {
    var tracking = this.getTracking();
    if (tracking && !this.listenerKey_) {
-      this.listenerKey_ = goog.events.listen(goog.global, 'deviceorientation',
-          this.orientationChange_, false, this);
-    } else if (!tracking && this.listenerKey_) {
-      goog.events.unlistenByKey(this.listenerKey_);
+      this.listenerKey_ = ol.events.listen(goog.global, 'deviceorientation',
+          this.orientationChange_, this);
+    } else if (!tracking && this.listenerKey_ !== null) {
+      ol.events.unlistenByKey(this.listenerKey_);
      this.listenerKey_ = null;
    }
  }
--- a/src/ol/events.js
+++ b/src/ol/events.js
@@ -0,0 +1,338 @@
+goog.provide('ol.events');
+goog.provide('ol.events.EventType');
+goog.provide('ol.events.KeyCode');
+
+goog.require('goog.object');
+
+
+/**
+ * @enum {string}
+ * @const
+ */
+ol.events.EventType = {
+  /**
+   * Generic change event.
+   * @event ol.events.Event#change
+   * @api
+   */
+  CHANGE: 'change',
+
+  CLICK: 'click',
+  DBLCLICK: 'dblclick',
+  DRAGENTER: 'dragenter',
+  DRAGOVER: 'dragover',
+  DROP: 'drop',
+  ERROR: 'error',
+  KEYDOWN: 'keydown',
+  KEYPRESS: 'keypress',
+  LOAD: 'load',
+  MOUSEDOWN: 'mousedown',
+  MOUSEMOVE: 'mousemove',
+  MOUSEOUT: 'mouseout',
+  MOUSEUP: 'mouseup',
+  MOUSEWHEEL: 'mousewheel',
+  MSPOINTERDOWN: 'mspointerdown',
+  RESIZE: 'resize',
+  TOUCHSTART: 'touchstart',
+  TOUCHMOVE: 'touchmove',
+  TOUCHEND: 'touchend',
+  WHEEL: 'wheel'
+};
+
+
+/**
+ * @enum {number}
+ * @const
+ */
+ol.events.KeyCode = {
+  LEFT: 37,
+  UP: 38,
+  RIGHT: 39,
+  DOWN: 40
+};
+
+
+/**
+ * Property name on an event target for the listener map associated with the
+ * event target.
+ * @const {string}
+ * @private
+ */
+ol.events.LISTENER_MAP_PROP_ = 'olm_' + ((Math.random() * 1e4) | 0);
+
+
+/**
+ * @typedef {EventTarget|ol.events.EventTarget|
+ *     {addEventListener: function(string, Function, boolean=),
+ *     removeEventListener: function(string, Function, boolean=),
+ *     dispatchEvent: function(string)}}
+ */
+ol.events.EventTargetLike;
+
+
+/**
+ * Key to use with {@link ol.Observable#unByKey}.
+ *
+ * @typedef {ol.events.ListenerObjType}
+ * @api
+ */
+ol.events.Key;
+
+
+/**
+ * Listener function. This function is called with an event object as argument.
+ * When the function returns `false`, event propagation will stop.
+ *
+ * @typedef {function(ol.events.Event)|function(ol.events.Event): boolean}
+ * @api
+ */
+ol.events.ListenerFunctionType;
+
+
+/**
+ * @typedef {{bindTo: (Object|undefined),
+ *     boundListener: (ol.events.ListenerFunctionType|undefined),
+ *     callOnce: boolean,
+ *     deleteIndex: (number|undefined),
+ *     listener: ol.events.ListenerFunctionType,
+ *     target: (EventTarget|ol.events.EventTarget),
+ *     type: string}}
+ */
+ol.events.ListenerObjType;
+
+
+/**
+ * @param {ol.events.ListenerObjType} listenerObj Listener object.
+ * @return {ol.events.ListenerFunctionType} Bound listener.
+ */
+ol.events.bindListener_ = function(listenerObj) {
+  var boundListener = function(evt) {
+    var rv = listenerObj.listener.call(listenerObj.bindTo, evt);
+    if (listenerObj.callOnce) {
+      ol.events.unlistenByKey(listenerObj);
+    }
+    return rv;
+  }
+  listenerObj.boundListener = boundListener;
+  return boundListener;
+};
+
+
+/**
+ * Finds the matching {@link ol.events.ListenerObjType} in the given listener
+ * array.
+ *
+ * @param {!Array<!ol.events.ListenerObjType>} listeners Array of listeners.
+ * @param {!Function} listener The listener function.
+ * @param {Object=} opt_this The `this` value inside the listener.
+ * @param {boolean=} opt_setDeleteIndex Set the deleteIndex on the matching
+ *     listener, for {@link ol.events.unlistenByKey}.
+ * @return {ol.events.ListenerObjType|undefined} The matching listener object.
+ * @private
+ */
+ol.events.findListener_ = function(listeners, listener, opt_this,
+    opt_setDeleteIndex) {
+  var listenerObj;
+  for (var i = 0, ii = listeners.length; i < ii; ++i) {
+    listenerObj = listeners[i];
+    if (listenerObj.listener === listener &&
+        listenerObj.bindTo === opt_this) {
+      if (opt_setDeleteIndex) {
+        listenerObj.deleteIndex = i;
+      }
+      return listenerObj;
+    }
+  }
+  return undefined;
+};
+
+
+/**
+ * @param {ol.events.EventTargetLike} target Target.
+ * @param {string} type Type.
+ * @return {Array.<ol.events.ListenerObjType>|undefined} Listeners.
+ */
+ol.events.getListeners = function(target, type) {
+  var listenerMap = target[ol.events.LISTENER_MAP_PROP_];
+  return listenerMap ? listenerMap[type] : undefined;
+};
+
+
+/**
+ * Get the lookup of listeners.  If one does not exist on the target, it is
+ * created.
+ * @param {ol.events.EventTargetLike} target Target.
+ * @return {!Object.<string, Array.<ol.events.ListenerObjType>>} Map of
+ *     listeners by event type.
+ * @private
+ */
+ol.events.getListenerMap_ = function(target) {
+  var listenerMap = target[ol.events.LISTENER_MAP_PROP_];
+  if (!listenerMap) {
+    listenerMap = target[ol.events.LISTENER_MAP_PROP_] = {};
+  }
+  return listenerMap;
+};
+
+
+/**
+ * Clean up all listener objects of the given type.  All properties on the
+ * listener objects will be removed, and if no listeners remain in the listener
+ * map, it will be removed from the target.
+ * @param {ol.events.EventTargetLike} target Target.
+ * @param {string} type Type.
+ * @private
+ */
+ol.events.removeListeners_ = function(target, type) {
+  var listeners = ol.events.getListeners(target, type);
+  if (listeners) {
+    for (var i = 0, ii = listeners.length; i < ii; ++i) {
+      target.removeEventListener(type, listeners[i].boundListener);
+      goog.object.clear(listeners[i])
+    }
+    listeners.length = 0;
+    var listenerMap = target[ol.events.LISTENER_MAP_PROP_];
+    if (listenerMap) {
+      delete listenerMap[type];
+      if (Object.keys(listenerMap).length === 0) {
+        delete target[ol.events.LISTENER_MAP_PROP_];
+      }
+    }
+  }
+};
+
+
+/**
+ * Registers an event listener on an event target. Inspired by
+ * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html}
+ *
+ * This function efficiently binds a `listener` to a `this` object, and returns
+ * a key for use with {@link ol.events.unlistenByKey}.
+ *
+ * @param {ol.events.EventTargetLike} target Event target.
+ * @param {string} type Event type.
+ * @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_once If true, add the listener as one-off listener.
+ * @return {ol.events.Key} Unique key for the listener.
+ */
+ol.events.listen = function(target, type, listener, opt_this, opt_once) {
+  var listenerMap = ol.events.getListenerMap_(target);
+  var listeners = listenerMap[type];
+  if (!listeners) {
+    listeners = listenerMap[type] = [];
+  }
+  var listenerObj = ol.events.findListener_(listeners, listener, opt_this,
+      false);
+  if (listenerObj) {
+    if (!opt_once) {
+      // Turn one-off listener into a permanent one.
+      listenerObj.callOnce = false;
+    }
+  } else {
+    listenerObj = /** @type {ol.events.ListenerObjType} */ ({
+      bindTo: opt_this,
+      callOnce: !!opt_once,
+      listener: listener,
+      target: target,
+      type: type
+    });
+    target.addEventListener(type, ol.events.bindListener_(listenerObj));
+    listeners.push(listenerObj);
+  }
+
+  return listenerObj;
+};
+
+
+/**
+ * Registers a one-off event listener on an event target. Inspired by
+ * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html}
+ *
+ * This function efficiently binds a `listener` as self-unregistering listener
+ * to a `this` object, and returns a key for use with
+ * {@link ol.events.unlistenByKey} in case the listener needs to be unregistered
+ * before it is called.
+ *
+ * When {@link ol.events.listen} is called with the same arguments after this
+ * function, the self-unregistering listener will be turned into a permanent
+ * listener.
+ *
+ * @param {ol.events.EventTargetLike} target Event target.
+ * @param {string} type Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ * @return {ol.events.Key} Key for unlistenByKey.
+ */
+ol.events.listenOnce = function(
+    target, type, listener, opt_this) {
+  return ol.events.listen(target, type, listener, opt_this, true);
+};
+
+
+/**
+ * Unregisters an event listener on an event target. Inspired by
+ * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html}
+ *
+ * To return a listener, this function needs to be called with the exact same
+ * arguments that were used for a previous {@link ol.events.listen} call.
+ *
+ * @param {ol.events.EventTargetLike} target Event target.
+ * @param {string} type Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ */
+ol.events.unlisten = function(target, type, listener, opt_this) {
+  var listeners = ol.events.getListeners(target, type);
+  if (listeners) {
+    var listenerObj = ol.events.findListener_(listeners, listener, opt_this,
+        true);
+    if (listenerObj) {
+      ol.events.unlistenByKey(listenerObj);
+    }
+  }
+};
+
+
+/**
+ * Unregisters event listeners on an event target. Inspired by
+ * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html}
+ *
+ * The argument passed to this function is the key returned from
+ * {@link ol.events.listen} or {@link ol.events.listenOnce}.
+ *
+ * @param {ol.events.Key} key The key.
+ */
+ol.events.unlistenByKey = function(key) {
+  if (key && key.target) {
+    key.target.removeEventListener(key.type, key.boundListener);
+    var listeners = ol.events.getListeners(key.target, key.type);
+    if (listeners) {
+      var i = 'deleteIndex' in key ? key.deleteIndex : listeners.indexOf(key);
+      if (i !== -1) {
+        listeners.splice(i, 1);
+      }
+      if (listeners.length === 0) {
+        ol.events.removeListeners_(key.target, key.type);
+      }
+    }
+    goog.object.clear(key);
+  }
+};
+
+
+/**
+ * Unregisters all event listeners on an event target. Inspired by
+ * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html}
+ *
+ * @param {ol.events.EventTargetLike} target Target.
+ */
+ol.events.unlistenAll = function(target) {
+  var listenerMap = ol.events.getListenerMap_(target);
+  for (var type in listenerMap) {
+    ol.events.removeListeners_(target, type);
+  }
+};
--- a/src/ol/events/condition.js
+++ b/src/ol/events/condition.js
@@ -26,11 +26,11 @@ ol.events.ConditionType;
 * @api stable
 */
 ol.events.condition.altKeyOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var originalEvent = mapBrowserEvent.originalEvent;
  return (
-      browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
-      !browserEvent.shiftKey);
+      originalEvent.altKey &&
+      !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+      !originalEvent.shiftKey);
 };


@@ -43,11 +43,11 @@ ol.events.condition.altKeyOnly = function(mapBrowserEvent) {
 * @api stable
 */
 ol.events.condition.altShiftKeysOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var originalEvent = mapBrowserEvent.originalEvent;
  return (
-      browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
-      browserEvent.shiftKey);
+      originalEvent.altKey &&
+      !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+      originalEvent.shiftKey);
 };


@@ -74,6 +74,22 @@ ol.events.condition.click = function(mapBrowserEvent) {
 };


+/**
+ * Return `true` if the event has an "action"-producing mouse button.
+ *
+ * By definition, this includes left-click on windows/linux, and left-click
+ * without the ctrl key on Macs.
+ *
+ * @param {ol.MapBrowserEvent} mapBrowserEvent Map browser event.
+ * @return {boolean} The result.
+ */
+ol.events.condition.mouseActionButton = function(mapBrowserEvent) {
+  var originalEvent = mapBrowserEvent.originalEvent;
+  return originalEvent.button == 0 &&
+      !(goog.userAgent.WEBKIT && ol.has.MAC && originalEvent.ctrlKey);
+};
+
+
 /**
 * Return always false.
 *
@@ -131,11 +147,11 @@ ol.events.condition.doubleClick = function(mapBrowserEvent) {
 * @api stable
 */
 ol.events.condition.noModifierKeys = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var originalEvent = mapBrowserEvent.originalEvent;
  return (
-      !browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
-      !browserEvent.shiftKey);
+      !originalEvent.altKey &&
+      !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+      !originalEvent.shiftKey);
 };


@@ -149,11 +165,11 @@ ol.events.condition.noModifierKeys = function(mapBrowserEvent) {
 * @api stable
 */
 ol.events.condition.platformModifierKeyOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var originalEvent = mapBrowserEvent.originalEvent;
  return (
-      !browserEvent.altKey &&
-      browserEvent.platformModifierKey &&
-      !browserEvent.shiftKey);
+      !originalEvent.altKey &&
+      (ol.has.MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&
+      !originalEvent.shiftKey);
 };


@@ -166,11 +182,11 @@ ol.events.condition.platformModifierKeyOnly = function(mapBrowserEvent) {
 * @api stable
 */
 ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var originalEvent = mapBrowserEvent.originalEvent;
  return (
-      !browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
-      browserEvent.shiftKey);
+      !originalEvent.altKey &&
+      !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+      originalEvent.shiftKey);
 };


@@ -183,7 +199,7 @@ ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) {
 * @api
 */
 ol.events.condition.targetNotEditable = function(mapBrowserEvent) {
-  var target = mapBrowserEvent.browserEvent.target;
+  var target = mapBrowserEvent.originalEvent.target;
  goog.asserts.assertInstanceof(target, Element,
      'target should be an Element');
  var tagName = target.tagName;
--- a/src/ol/events/event.js
+++ b/src/ol/events/event.js
@@ -0,0 +1,60 @@
+goog.provide('ol.events.Event');
+
+
+/**
+ * @classdesc
+ * Stripped down implementation of the W3C DOM Level 2 Event interface.
+ * @see {@link https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-interface}
+ *
+ * This implementation only provides `type` and `target` properties, and
+ * `stopPropagation` and `preventDefault` methods. It is meant as base class
+ * for higher level events defined in the library, and works with
+ * {@link ol.events.EventTarget}.
+ *
+ * @constructor
+ * @param {string} type Type.
+ * @param {Object=} opt_target Target.
+ */
+ol.events.Event = function(type, opt_target) {
+
+  /**
+   * @type {boolean}
+   */
+  this.propagationStopped;
+
+  /**
+   * @type {string}
+   */
+  this.type = type;
+
+  /**
+   * @type {Object|undefined}
+   */
+  this.target = opt_target;
+
+};
+
+
+/**
+ * Stop event propagation
+ */
+ol.events.Event.prototype.preventDefault =
+ol.events.Event.prototype.stopPropagation = function() {
+  this.propagationStopped = true;
+};
+
+
+/**
+ * @param {Event|ol.events.Event} evt Event
+ */
+ol.events.Event.stopPropagation = function(evt) {
+  evt.stopPropagation();
+};
+
+
+/**
+ * @param {Event|ol.events.Event} evt Event
+ */
+ol.events.Event.preventDefault = function(evt) {
+  evt.preventDefault();
+};
--- a/src/ol/events/eventtarget.js
+++ b/src/ol/events/eventtarget.js
@@ -0,0 +1,123 @@
+goog.provide('ol.events.EventTarget');
+
+goog.require('goog.Disposable');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+
+/**
+ * @classdesc
+ * A simplified implementation of the W3C DOM Level 2 EventTarget interface.
+ * @see {@link https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget}
+ *
+ * There are two important simplifications compared to the specification:
+ *
+ * 1. The handling of `useCapture` in `addEventListener` and
+ *    `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
+ *    more listeners after this one will be called. Same as when the listener
+ *    returns false.
+ *
+ * @constructor
+ * @extends {goog.Disposable}
+ */
+ol.events.EventTarget = function() {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {!Object.<string, Array.<ol.events.ListenerFunctionType>>}
+   */
+  this.listeners_ = {};
+
+};
+goog.inherits(ol.events.EventTarget, goog.Disposable);
+
+
+/**
+ * @param {string} type Type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ */
+ol.events.EventTarget.prototype.addEventListener = function(type, listener) {
+  var listeners = this.listeners_[type];
+  if (!listeners) {
+    listeners = this.listeners_[type] = [];
+  }
+  if (listeners.indexOf(listener) === -1) {
+    listeners.unshift(listener);
+  }
+};
+
+
+/**
+ * @param {{type: string,
+ *     target: (EventTarget|ol.events.EventTarget|undefined)}|ol.events.Event|
+ *     string} event Event or event type.
+ * @return {boolean|undefined} `false` if anyone called preventDefault on the
+ *     event object or if any of the listeners returned false.
+ */
+ol.events.EventTarget.prototype.dispatchEvent = function(event) {
+  var evt = goog.isString(event) ? new ol.events.Event(event) : event;
+  var type = evt.type;
+  evt.target = this;
+  var listeners = this.listeners_[type];
+  if (listeners) {
+    for (var i = listeners.length - 1; i >= 0; --i) {
+      if (listeners[i].call(this, evt) === false ||
+          evt.propagationStopped) {
+        return false;
+      }
+    }
+  }
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.events.EventTarget.prototype.disposeInternal = function() {
+  ol.events.unlistenAll(this);
+  goog.base(this, 'disposeInternal');
+};
+
+
+/**
+ * Get the listeners for a specified event type. Listeners are returned in the
+ * opposite order that they will be called in.
+ *
+ * @param {string} type Type.
+ * @return {Array.<ol.events.ListenerFunctionType>} Listeners.
+ */
+ol.events.EventTarget.prototype.getListeners = function(type) {
+  return this.listeners_[type];
+};
+
+
+/**
+ * @param {string=} opt_type Type. If not provided,
+ *     `true` will be returned if this EventTarget has any listeners.
+ * @return {boolean} Has listeners.
+ */
+ol.events.EventTarget.prototype.hasListener = function(opt_type) {
+  return opt_type ?
+      opt_type in this.listeners_ :
+      Object.keys(this.listeners_).length > 0;
+};
+
+
+/**
+ * @param {string} type Type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ */
+ol.events.EventTarget.prototype.removeEventListener = function(type, listener) {
+  var listeners = this.listeners_[type];
+  if (listeners) {
+    var index = listeners.indexOf(listener);
+    listeners.splice(index, 1);
+    if (listeners.length === 0) {
+      delete this.listeners_[type];
+    }
+  }
+};
--- a/src/ol/feature.js
+++ b/src/ol/feature.js
@@ -2,8 +2,8 @@ goog.provide('ol.Feature');
 goog.provide('ol.FeatureStyleFunction');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol');
 goog.require('ol.Object');
 goog.require('ol.geom.Geometry');
@@ -87,13 +87,13 @@ ol.Feature = function(opt_geometryOrProperties) {

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.geometryChangeKey_ = null;

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(this.geometryName_),
-      this.handleGeometryChanged_, false, this);
+      this.handleGeometryChanged_, this);

  if (opt_geometryOrProperties !== undefined) {
    if (opt_geometryOrProperties instanceof ol.geom.Geometry ||
@@ -209,13 +209,13 @@ ol.Feature.prototype.handleGeometryChange_ = function() {
 */
 ol.Feature.prototype.handleGeometryChanged_ = function() {
  if (this.geometryChangeKey_) {
-    goog.events.unlistenByKey(this.geometryChangeKey_);
+    ol.events.unlistenByKey(this.geometryChangeKey_);
    this.geometryChangeKey_ = null;
  }
  var geometry = this.getGeometry();
  if (geometry) {
-    this.geometryChangeKey_ = goog.events.listen(geometry,
-        goog.events.EventType.CHANGE, this.handleGeometryChange_, false, this);
+    this.geometryChangeKey_ = ol.events.listen(geometry,
+        ol.events.EventType.CHANGE, this.handleGeometryChange_, this);
  }
  this.changed();
 };
@@ -273,13 +273,13 @@ ol.Feature.prototype.setId = function(id) {
 * @api stable
 */
 ol.Feature.prototype.setGeometryName = function(name) {
-  goog.events.unlisten(
+  ol.events.unlisten(
      this, ol.Object.getChangeEventType(this.geometryName_),
-      this.handleGeometryChanged_, false, this);
+      this.handleGeometryChanged_, this);
  this.geometryName_ = name;
-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(this.geometryName_),
-      this.handleGeometryChanged_, false, this);
+      this.handleGeometryChanged_, this);
  this.handleGeometryChanged_();
 };

--- a/src/ol/featureloader.js
+++ b/src/ol/featureloader.js
@@ -3,10 +3,6 @@ goog.provide('ol.FeatureUrlFunction');
 goog.provide('ol.featureloader');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.net.EventType');
-goog.require('goog.net.XhrIo');
-goog.require('goog.net.XhrIo.ResponseType');
 goog.require('ol.TileState');
 goog.require('ol.VectorTile');
 goog.require('ol.format.FormatType');
@@ -67,59 +63,47 @@ ol.featureloader.loadFeaturesXhr = function(url, format, success, failure) {
       * @this {ol.source.Vector|ol.VectorTile}
       */
      function(extent, resolution, projection) {
-        var xhrIo = new goog.net.XhrIo();
-        xhrIo.setResponseType(
-            format.getType() == ol.format.FormatType.ARRAY_BUFFER ?
-                goog.net.XhrIo.ResponseType.ARRAY_BUFFER :
-                goog.net.XhrIo.ResponseType.TEXT);
-        goog.events.listen(xhrIo, goog.net.EventType.COMPLETE,
-            /**
-             * @param {Event} event Event.
-             * @private
-             * @this {ol.source.Vector}
-             */
-            function(event) {
-              var xhrIo = event.target;
-              goog.asserts.assertInstanceof(xhrIo, goog.net.XhrIo,
-                  'event.target/xhrIo is an instance of goog.net.XhrIo');
-              if (xhrIo.isSuccess()) {
-                var type = format.getType();
-                /** @type {Document|Node|Object|string|undefined} */
-                var source;
-                if (type == ol.format.FormatType.JSON) {
-                  source = xhrIo.getResponseText();
-                } else if (type == ol.format.FormatType.TEXT) {
-                  source = xhrIo.getResponseText();
-                } else if (type == ol.format.FormatType.XML) {
-                  if (!goog.userAgent.IE) {
-                    source = xhrIo.getResponseXml();
-                  }
-                  if (!source) {
-                    source = ol.xml.parse(xhrIo.getResponseText());
-                  }
-                } else if (type == ol.format.FormatType.ARRAY_BUFFER) {
-                  source = xhrIo.getResponse();
-                } else {
-                  goog.asserts.fail('unexpected format type');
-                }
-                if (source) {
-                  success.call(this, format.readFeatures(source,
-                      {featureProjection: projection}),
-                      format.readProjection(source));
-                } else {
-                  goog.asserts.fail('undefined or null source');
-                }
-              } else {
-                failure.call(this);
-              }
-              goog.dispose(xhrIo);
-            }, false, this);
-        if (goog.isFunction(url)) {
-          xhrIo.send(url(extent, resolution, projection));
-        } else {
-          xhrIo.send(url);
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET',
+            goog.isFunction(url) ? url(extent, resolution, projection) : url,
+            true);
+        if (format.getType() == ol.format.FormatType.ARRAY_BUFFER) {
+          xhr.responseType = 'arraybuffer';
        }
-
+        /**
+         * @param {Event} event Event.
+         * @private
+         */
+        xhr.onload = function(event) {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            var type = format.getType();
+            /** @type {Document|Node|Object|string|undefined} */
+            var source;
+            if (type == ol.format.FormatType.JSON ||
+                type == ol.format.FormatType.TEXT) {
+              source = /** @type {string} */ (xhr.responseText);
+            } else if (type == ol.format.FormatType.XML) {
+              source = xhr.responseXML;
+              if (!source) {
+                source = ol.xml.parse(xhr.responseText);
+              }
+            } else if (type == ol.format.FormatType.ARRAY_BUFFER) {
+              source = /** @type {ArrayBuffer} */ (xhr.response);
+            } else {
+              goog.asserts.fail('unexpected format type');
+            }
+            if (source) {
+              success.call(this, format.readFeatures(source,
+                  {featureProjection: projection}),
+                  format.readProjection(source));
+            } else {
+              goog.asserts.fail('undefined or null source');
+            }
+          } else {
+            failure.call(this);
+          }
+        }.bind(this);
+        xhr.send();
      });
 };

--- a/src/ol/geolocation.js
+++ b/src/ol/geolocation.js
@@ -3,8 +3,8 @@
 goog.provide('ol.Geolocation');
 goog.provide('ol.GeolocationProperty');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.Coordinate');
 goog.require('ol.Object');
 goog.require('ol.geom.Geometry');
@@ -83,12 +83,12 @@ ol.Geolocation = function(opt_options) {
   */
  this.watchId_ = undefined;

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.GeolocationProperty.PROJECTION),
-      this.handleProjectionChanged_, false, this);
-  goog.events.listen(
+      this.handleProjectionChanged_, this);
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.GeolocationProperty.TRACKING),
-      this.handleTrackingChanged_, false, this);
+      this.handleTrackingChanged_, this);

  if (options.projection !== undefined) {
    this.setProjection(ol.proj.get(options.projection));
@@ -189,9 +189,9 @@ ol.Geolocation.prototype.positionChange_ = function(position) {
 * @param {GeolocationPositionError} error error object.
 */
 ol.Geolocation.prototype.positionError_ = function(error) {
-  error.type = goog.events.EventType.ERROR;
+  error.type = ol.events.EventType.ERROR;
  this.setTracking(false);
-  this.dispatchEvent(error);
+  this.dispatchEvent(/** @type {{type: string}} */ (error));
 };


--- a/src/ol/geom/geometrycollection.js
+++ b/src/ol/geom/geometrycollection.js
@@ -1,7 +1,7 @@
 goog.provide('ol.geom.GeometryCollection');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.extent');
 goog.require('ol.geom.Geometry');
@@ -56,9 +56,9 @@ ol.geom.GeometryCollection.prototype.unlistenGeometriesChange_ = function() {
    return;
  }
  for (i = 0, ii = this.geometries_.length; i < ii; ++i) {
-    goog.events.unlisten(
-        this.geometries_[i], goog.events.EventType.CHANGE,
-        this.changed, false, this);
+    ol.events.unlisten(
+        this.geometries_[i], ol.events.EventType.CHANGE,
+        this.changed, this);
  }
 };

@@ -72,9 +72,9 @@ ol.geom.GeometryCollection.prototype.listenGeometriesChange_ = function() {
    return;
  }
  for (i = 0, ii = this.geometries_.length; i < ii; ++i) {
-    goog.events.listen(
-        this.geometries_[i], goog.events.EventType.CHANGE,
-        this.changed, false, this);
+    ol.events.listen(
+        this.geometries_[i], ol.events.EventType.CHANGE,
+        this.changed, this);
  }
 };

--- a/src/ol/has.js
+++ b/src/ol/has.js
@@ -5,6 +5,28 @@ goog.require('ol.dom');
 goog.require('ol.webgl');


+var ua = typeof navigator !== 'undefined' ?
+    navigator.userAgent.toLowerCase() : '';
+
+/**
+ * User agent string says we are dealing with Firefox as browser.
+ * @type {boolean}
+ */
+ol.has.FIREFOX = ua.indexOf('firefox') !== -1;
+
+/**
+ * User agent string says we are dealing with Safari as browser.
+ * @type {boolean}
+ */
+ol.has.SAFARI = ua.indexOf('safari') !== -1 && ua.indexOf('chrom') === -1;
+
+/**
+ * User agent string says we are dealing with a Mac as platform.
+ * @type {boolean}
+ */
+ol.has.MAC = ua.indexOf('Macintosh') !== -1;
+
+
 /**
 * The ratio between physical pixels and device-independent pixels
 * (dips) on the device (`window.devicePixelRatio`).
--- a/src/ol/image.js
+++ b/src/ol/image.js
@@ -1,8 +1,8 @@
 goog.provide('ol.Image');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.ImageBase');
 goog.require('ol.ImageState');
@@ -49,7 +49,7 @@ ol.Image = function(extent, resolution, pixelRatio, attributions, src,

  /**
   * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   */
  this.imageListenerKeys_ = null;

@@ -131,10 +131,10 @@ ol.Image.prototype.load = function() {
    goog.asserts.assert(!this.imageListenerKeys_,
        'this.imageListenerKeys_ should be null');
    this.imageListenerKeys_ = [
-      goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
-          this.handleImageError_, false, this),
-      goog.events.listenOnce(this.image_, goog.events.EventType.LOAD,
-          this.handleImageLoad_, false, this)
+      ol.events.listenOnce(this.image_, ol.events.EventType.ERROR,
+          this.handleImageError_, this),
+      ol.events.listenOnce(this.image_, ol.events.EventType.LOAD,
+          this.handleImageLoad_, this)
    ];
    this.imageLoadFunction_(this, this.src_);
  }
@@ -157,6 +157,6 @@ ol.Image.prototype.setImage = function(image) {
 ol.Image.prototype.unlistenImage_ = function() {
  goog.asserts.assert(this.imageListenerKeys_,
      'this.imageListenerKeys_ should not be null');
-  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(ol.events.unlistenByKey);
  this.imageListenerKeys_ = null;
 };
--- a/src/ol/imagebase.js
+++ b/src/ol/imagebase.js
@@ -2,8 +2,8 @@ goog.provide('ol.ImageBase');
 goog.provide('ol.ImageState');

 goog.require('goog.asserts');
-goog.require('goog.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventTarget');
+goog.require('ol.events.EventType');
 goog.require('ol.Attribution');
 goog.require('ol.Extent');

@@ -21,7 +21,7 @@ ol.ImageState = {

 /**
 * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 * @param {ol.Extent} extent Extent.
 * @param {number|undefined} resolution Resolution.
 * @param {number} pixelRatio Pixel ratio.
@@ -63,14 +63,14 @@ ol.ImageBase = function(extent, resolution, pixelRatio, state, attributions) {
  this.state = state;

 };
-goog.inherits(ol.ImageBase, goog.events.EventTarget);
+goog.inherits(ol.ImageBase, ol.events.EventTarget);


 /**
 * @protected
 */
 ol.ImageBase.prototype.changed = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };


--- a/src/ol/imagetile.js
+++ b/src/ol/imagetile.js
@@ -1,8 +1,8 @@
 goog.provide('ol.ImageTile');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Tile');
 goog.require('ol.TileCoord');
@@ -48,7 +48,7 @@ ol.ImageTile = function(tileCoord, state, src, crossOrigin, tileLoadFunction) {

  /**
   * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   */
  this.imageListenerKeys_ = null;

@@ -146,10 +146,10 @@ ol.ImageTile.prototype.load = function() {
    goog.asserts.assert(!this.imageListenerKeys_,
        'this.imageListenerKeys_ should be null');
    this.imageListenerKeys_ = [
-      goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
-          this.handleImageError_, false, this),
-      goog.events.listenOnce(this.image_, goog.events.EventType.LOAD,
-          this.handleImageLoad_, false, this)
+      ol.events.listenOnce(this.image_, ol.events.EventType.ERROR,
+          this.handleImageError_, this),
+      ol.events.listenOnce(this.image_, ol.events.EventType.LOAD,
+          this.handleImageLoad_, this)
    ];
    this.tileLoadFunction_(this, this.src_);
  }
@@ -164,6 +164,6 @@ ol.ImageTile.prototype.load = function() {
 ol.ImageTile.prototype.unlistenImage_ = function() {
  goog.asserts.assert(this.imageListenerKeys_,
      'this.imageListenerKeys_ should not be null');
-  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(ol.events.unlistenByKey);
  this.imageListenerKeys_ = null;
 };
--- a/src/ol/interaction/doubleclickzoominteraction.js
+++ b/src/ol/interaction/doubleclickzoominteraction.js
@@ -49,7 +49,7 @@ goog.inherits(ol.interaction.DoubleClickZoom, ol.interaction.Interaction);
 */
 ol.interaction.DoubleClickZoom.handleEvent = function(mapBrowserEvent) {
  var stopEvent = false;
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
  if (mapBrowserEvent.type == ol.MapBrowserEvent.EventType.DBLCLICK) {
    var map = mapBrowserEvent.map;
    var anchor = mapBrowserEvent.coordinate;
--- a/src/ol/interaction/draganddropinteraction.js
+++ b/src/ol/interaction/draganddropinteraction.js
@@ -4,12 +4,10 @@ goog.provide('ol.interaction.DragAndDrop');
 goog.provide('ol.interaction.DragAndDropEvent');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.Event');
-goog.require('goog.events.FileDropHandler');
-goog.require('goog.events.FileDropHandler.EventType');
-goog.require('goog.fs.FileReader');
 goog.require('goog.functions');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('ol.interaction.Interaction');
 goog.require('ol.proj');

@@ -48,54 +46,50 @@ ol.interaction.DragAndDrop = function(opt_options) {

  /**
   * @private
-   * @type {goog.events.FileDropHandler}
+   * @type {Array.<ol.events.Key>}
   */
-  this.fileDropHandler_ = null;
-
-  /**
-   * @private
-   * @type {goog.events.Key|undefined}
-   */
-  this.dropListenKey_ = undefined;
+  this.dropListenKeys_ = null;

 };
 goog.inherits(ol.interaction.DragAndDrop, ol.interaction.Interaction);


 /**
- * @inheritDoc
+ * @param {Event} event Event.
+ * @this {ol.interaction.DragAndDrop}
+ * @private
 */
-ol.interaction.DragAndDrop.prototype.disposeInternal = function() {
-  if (this.dropListenKey_) {
-    goog.events.unlistenByKey(this.dropListenKey_);
+ol.interaction.DragAndDrop.handleDrop_ = function(event) {
+  var files = event.dataTransfer.files;
+  var i, ii, file;
+  for (i = 0, ii = files.length; i < ii; ++i) {
+    file = files.item(i);
+    var reader = new FileReader();
+    reader.addEventListener(ol.events.EventType.LOAD,
+        goog.partial(this.handleResult_, file).bind(this));
+    reader.readAsText(file);
  }
-  goog.base(this, 'disposeInternal');
 };


 /**
- * @param {goog.events.BrowserEvent} event Event.
+ * @param {Event} event Event.
 * @private
 */
-ol.interaction.DragAndDrop.prototype.handleDrop_ = function(event) {
-  var files = event.getBrowserEvent().dataTransfer.files;
-  var i, ii, file;
-  for (i = 0, ii = files.length; i < ii; ++i) {
-    file = files[i];
-    // The empty string param is a workaround for
-    // https://code.google.com/p/closure-library/issues/detail?id=524
-    var reader = goog.fs.FileReader.readAsText(file, '');
-    reader.addCallback(goog.partial(this.handleResult_, file), this);
-  }
+ol.interaction.DragAndDrop.handleStop_ = function(event) {
+  event.stopPropagation();
+  event.preventDefault();
+  event.dataTransfer.dropEffect = 'copy';
 };


 /**
 * @param {File} file File.
- * @param {string} result Result.
+ * @param {Event} event Load event.
 * @private
 */
-ol.interaction.DragAndDrop.prototype.handleResult_ = function(file, result) {
+ol.interaction.DragAndDrop.prototype.handleResult_ = function(file, event) {
+  var result = event.target.result;
  var map = this.getMap();
  goog.asserts.assert(map, 'map must be set');
  var projection = this.projection_;
@@ -149,22 +143,23 @@ ol.interaction.DragAndDrop.handleEvent = goog.functions.TRUE;
 * @inheritDoc
 */
 ol.interaction.DragAndDrop.prototype.setMap = function(map) {
-  if (this.dropListenKey_) {
-    goog.events.unlistenByKey(this.dropListenKey_);
-    this.dropListenKey_ = undefined;
+  if (this.dropListenKeys_) {
+    this.dropListenKeys_.forEach(ol.events.unlistenByKey);
+    this.dropListenKeys_ = null;
  }
-  if (this.fileDropHandler_) {
-    goog.dispose(this.fileDropHandler_);
-    this.fileDropHandler_ = null;
-  }
-  goog.asserts.assert(this.dropListenKey_ === undefined,
-      'this.dropListenKey_ should be undefined');
  goog.base(this, 'setMap', map);
  if (map) {
-    this.fileDropHandler_ = new goog.events.FileDropHandler(map.getViewport());
-    this.dropListenKey_ = goog.events.listen(
-        this.fileDropHandler_, goog.events.FileDropHandler.EventType.DROP,
-        this.handleDrop_, false, this);
+    var dropArea = map.getViewport();
+    this.dropListenKeys_ = [
+      ol.events.listen(dropArea, ol.events.EventType.DROP,
+          ol.interaction.DragAndDrop.handleDrop_, this),
+      ol.events.listen(dropArea, ol.events.EventType.DRAGENTER,
+          ol.interaction.DragAndDrop.handleStop_, this),
+      ol.events.listen(dropArea, ol.events.EventType.DRAGOVER,
+          ol.interaction.DragAndDrop.handleStop_, this),
+      ol.events.listen(dropArea, ol.events.EventType.DROP,
+          ol.interaction.DragAndDrop.handleStop_, this)
+    ]
  }
 };

@@ -203,7 +198,7 @@ ol.interaction.DragAndDropEventType = {
 * of this type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.interaction.DragAndDropEvent}
 * @param {ol.interaction.DragAndDropEventType} type Type.
 * @param {Object} target Target.
@@ -237,4 +232,4 @@ ol.interaction.DragAndDropEvent = function(type, target, file, opt_features, opt
  this.projection = opt_projection;

 };
-goog.inherits(ol.interaction.DragAndDropEvent, goog.events.Event);
+goog.inherits(ol.interaction.DragAndDropEvent, ol.events.Event);
--- a/src/ol/interaction/dragboxinteraction.js
+++ b/src/ol/interaction/dragboxinteraction.js
@@ -2,7 +2,7 @@
 goog.provide('ol.DragBoxEvent');
 goog.provide('ol.interaction.DragBox');

-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol');
 goog.require('ol.events.ConditionType');
 goog.require('ol.events.condition');
@@ -54,7 +54,7 @@ ol.DragBoxEventType = {
 * @param {string} type The event type.
 * @param {ol.Coordinate} coordinate The event coordinate.
 * @param {ol.MapBrowserEvent} mapBrowserEvent Originating event.
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @constructor
 * @implements {oli.DragBoxEvent}
 */
@@ -77,7 +77,7 @@ ol.DragBoxEvent = function(type, coordinate, mapBrowserEvent) {
  this.mapBrowserEvent = mapBrowserEvent;

 };
-goog.inherits(ol.DragBoxEvent, goog.events.Event);
+goog.inherits(ol.DragBoxEvent, ol.events.Event);


 /**
@@ -234,8 +234,8 @@ ol.interaction.DragBox.handleDownEvent_ = function(mapBrowserEvent) {
    return false;
  }

-  var browserEvent = mapBrowserEvent.browserEvent;
-  if (browserEvent.isMouseActionButton() && this.condition_(mapBrowserEvent)) {
+  if (ol.events.condition.mouseActionButton(mapBrowserEvent) &&
+      this.condition_(mapBrowserEvent)) {
    this.startPixel_ = mapBrowserEvent.pixel;
    this.box_.setMap(mapBrowserEvent.map);
    this.box_.setPixels(this.startPixel_, this.startPixel_);
--- a/src/ol/interaction/dragrotateinteraction.js
+++ b/src/ol/interaction/dragrotateinteraction.js
@@ -112,8 +112,8 @@ ol.interaction.DragRotate.handleDownEvent_ = function(mapBrowserEvent) {
    return false;
  }

-  var browserEvent = mapBrowserEvent.browserEvent;
-  if (browserEvent.isMouseActionButton() && this.condition_(mapBrowserEvent)) {
+  if (ol.events.condition.mouseActionButton(mapBrowserEvent) &&
+      this.condition_(mapBrowserEvent)) {
    var map = mapBrowserEvent.map;
    map.getView().setHint(ol.ViewHint.INTERACTING, 1);
    map.render();
--- a/src/ol/interaction/drawinteraction.js
+++ b/src/ol/interaction/drawinteraction.js
@@ -5,8 +5,8 @@ goog.provide('ol.interaction.DrawGeometryFunctionType');
 goog.provide('ol.interaction.DrawMode');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.Event');
+goog.require('ol.events');
+goog.require('ol.events.Event');
 goog.require('ol.Collection');
 goog.require('ol.Coordinate');
 goog.require('ol.Feature');
@@ -55,7 +55,7 @@ ol.interaction.DrawEventType = {
 * this type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.DrawEvent}
 * @param {ol.interaction.DrawEventType} type Type.
 * @param {ol.Feature} feature The feature drawn.
@@ -72,7 +72,7 @@ ol.interaction.DrawEvent = function(type, feature) {
  this.feature = feature;

 };
-goog.inherits(ol.interaction.DrawEvent, goog.events.Event);
+goog.inherits(ol.interaction.DrawEvent, ol.events.Event);


 /**
@@ -300,9 +300,9 @@ ol.interaction.Draw = function(options) {
  this.freehandCondition_ = options.freehandCondition ?
      options.freehandCondition : ol.events.condition.shiftKeyOnly;

-  goog.events.listen(this,
+  ol.events.listen(this,
      ol.Object.getChangeEventType(ol.interaction.InteractionProperty.ACTIVE),
-      this.updateState_, false, this);
+      this.updateState_, this);

 };
 goog.inherits(ol.interaction.Draw, ol.interaction.Pointer);
--- a/src/ol/interaction/keyboardpaninteraction.js
+++ b/src/ol/interaction/keyboardpaninteraction.js
@@ -1,12 +1,12 @@
 goog.provide('ol.interaction.KeyboardPan');

 goog.require('goog.asserts');
-goog.require('goog.events.KeyCodes');
-goog.require('goog.events.KeyHandler.EventType');
 goog.require('goog.functions');
 goog.require('ol');
 goog.require('ol.coordinate');
 goog.require('ol.events.ConditionType');
+goog.require('ol.events.EventType');
+goog.require('ol.events.KeyCode');
 goog.require('ol.events.condition');
 goog.require('ol.interaction.Interaction');

@@ -73,25 +73,24 @@ goog.inherits(ol.interaction.KeyboardPan, ol.interaction.Interaction);
 */
 ol.interaction.KeyboardPan.handleEvent = function(mapBrowserEvent) {
  var stopEvent = false;
-  if (mapBrowserEvent.type == goog.events.KeyHandler.EventType.KEY) {
-    var keyEvent = /** @type {goog.events.KeyEvent} */
-        (mapBrowserEvent.browserEvent);
+  if (mapBrowserEvent.type == ol.events.EventType.KEYDOWN) {
+    var keyEvent = mapBrowserEvent.originalEvent;
    var keyCode = keyEvent.keyCode;
    if (this.condition_(mapBrowserEvent) &&
-        (keyCode == goog.events.KeyCodes.DOWN ||
-        keyCode == goog.events.KeyCodes.LEFT ||
-        keyCode == goog.events.KeyCodes.RIGHT ||
-        keyCode == goog.events.KeyCodes.UP)) {
+        (keyCode == ol.events.KeyCode.DOWN ||
+        keyCode == ol.events.KeyCode.LEFT ||
+        keyCode == ol.events.KeyCode.RIGHT ||
+        keyCode == ol.events.KeyCode.UP)) {
      var map = mapBrowserEvent.map;
      var view = map.getView();
      goog.asserts.assert(view, 'map must have view');
      var mapUnitsDelta = view.getResolution() * this.pixelDelta_;
      var deltaX = 0, deltaY = 0;
-      if (keyCode == goog.events.KeyCodes.DOWN) {
+      if (keyCode == ol.events.KeyCode.DOWN) {
        deltaY = -mapUnitsDelta;
-      } else if (keyCode == goog.events.KeyCodes.LEFT) {
+      } else if (keyCode == ol.events.KeyCode.LEFT) {
        deltaX = -mapUnitsDelta;
-      } else if (keyCode == goog.events.KeyCodes.RIGHT) {
+      } else if (keyCode == ol.events.KeyCode.RIGHT) {
        deltaX = mapUnitsDelta;
      } else {
        deltaY = mapUnitsDelta;
--- a/src/ol/interaction/keyboardzoominteraction.js
+++ b/src/ol/interaction/keyboardzoominteraction.js
@@ -1,8 +1,8 @@
 goog.provide('ol.interaction.KeyboardZoom');

 goog.require('goog.asserts');
-goog.require('goog.events.KeyHandler.EventType');
 goog.require('ol.events.ConditionType');
+goog.require('ol.events.EventType');
 goog.require('ol.events.condition');
 goog.require('ol.interaction.Interaction');

@@ -66,9 +66,9 @@ goog.inherits(ol.interaction.KeyboardZoom, ol.interaction.Interaction);
 */
 ol.interaction.KeyboardZoom.handleEvent = function(mapBrowserEvent) {
  var stopEvent = false;
-  if (mapBrowserEvent.type == goog.events.KeyHandler.EventType.KEY) {
-    var keyEvent = /** @type {goog.events.KeyEvent} */
-        (mapBrowserEvent.browserEvent);
+  if (mapBrowserEvent.type == ol.events.EventType.KEYDOWN ||
+      mapBrowserEvent.type == ol.events.EventType.KEYPRESS) {
+    var keyEvent = mapBrowserEvent.originalEvent;
    var charCode = keyEvent.charCode;
    if (this.condition_(mapBrowserEvent) &&
        (charCode == '+'.charCodeAt(0) || charCode == '-'.charCodeAt(0))) {
--- a/src/ol/interaction/modifyinteraction.js
+++ b/src/ol/interaction/modifyinteraction.js
@@ -2,9 +2,9 @@ goog.provide('ol.interaction.Modify');
 goog.provide('ol.interaction.ModifyEvent');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('goog.functions');
 goog.require('ol');
 goog.require('ol.Collection');
@@ -55,7 +55,7 @@ ol.ModifyEventType = {
 * this type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.ModifyEvent}
 * @param {ol.ModifyEventType} type Type.
 * @param {ol.Collection.<ol.Feature>} features The features modified.
@@ -80,7 +80,7 @@ ol.interaction.ModifyEvent = function(type, features, mapBrowserPointerEvent) {
   */
  this.mapBrowserPointerEvent = mapBrowserPointerEvent;
 };
-goog.inherits(ol.interaction.ModifyEvent, goog.events.Event);
+goog.inherits(ol.interaction.ModifyEvent, ol.events.Event);


 /**
@@ -229,10 +229,10 @@ ol.interaction.Modify = function(options) {
  this.features_ = options.features;

  this.features_.forEach(this.addFeature_, this);
-  goog.events.listen(this.features_, ol.CollectionEventType.ADD,
-      this.handleFeatureAdd_, false, this);
-  goog.events.listen(this.features_, ol.CollectionEventType.REMOVE,
-      this.handleFeatureRemove_, false, this);
+  ol.events.listen(this.features_, ol.CollectionEventType.ADD,
+      this.handleFeatureAdd_, this);
+  ol.events.listen(this.features_, ol.CollectionEventType.REMOVE,
+      this.handleFeatureRemove_, this);

 };
 goog.inherits(ol.interaction.Modify, ol.interaction.Pointer);
@@ -251,8 +251,8 @@ ol.interaction.Modify.prototype.addFeature_ = function(feature) {
  if (map) {
    this.handlePointerAtPixel_(this.lastPixel_, map);
  }
-  goog.events.listen(feature, goog.events.EventType.CHANGE,
-      this.handleFeatureChange_, false, this);
+  ol.events.listen(feature, ol.events.EventType.CHANGE,
+      this.handleFeatureChange_, this);
 };


@@ -281,8 +281,8 @@ ol.interaction.Modify.prototype.removeFeature_ = function(feature) {
    this.overlay_.getSource().removeFeature(this.vertexFeature_);
    this.vertexFeature_ = null;
  }
-  goog.events.unlisten(feature, goog.events.EventType.CHANGE,
-      this.handleFeatureChange_, false, this);
+  ol.events.unlisten(feature, ol.events.EventType.CHANGE,
+      this.handleFeatureChange_, this);
 };


@@ -330,7 +330,7 @@ ol.interaction.Modify.prototype.handleFeatureAdd_ = function(evt) {


 /**
- * @param {goog.events.Event} evt Event.
+ * @param {ol.events.Event} evt Event.
 * @private
 */
 ol.interaction.Modify.prototype.handleFeatureChange_ = function(evt) {
--- a/src/ol/interaction/mousewheelzoominteraction.js
+++ b/src/ol/interaction/mousewheelzoominteraction.js
@@ -1,10 +1,9 @@
 goog.provide('ol.interaction.MouseWheelZoom');

 goog.require('goog.asserts');
-goog.require('goog.events.MouseWheelEvent');
-goog.require('goog.events.MouseWheelHandler.EventType');
 goog.require('ol');
 goog.require('ol.Coordinate');
+goog.require('ol.events.EventType');
 goog.require('ol.interaction.Interaction');
 goog.require('ol.math');

@@ -76,18 +75,36 @@ goog.inherits(ol.interaction.MouseWheelZoom, ol.interaction.Interaction);
 */
 ol.interaction.MouseWheelZoom.handleEvent = function(mapBrowserEvent) {
  var stopEvent = false;
-  if (mapBrowserEvent.type ==
-      goog.events.MouseWheelHandler.EventType.MOUSEWHEEL) {
+  if (mapBrowserEvent.type == ol.events.EventType.WHEEL ||
+      mapBrowserEvent.type == ol.events.EventType.MOUSEWHEEL) {
    var map = mapBrowserEvent.map;
-    var mouseWheelEvent = mapBrowserEvent.browserEvent;
-    goog.asserts.assertInstanceof(mouseWheelEvent, goog.events.MouseWheelEvent,
-        'mouseWheelEvent should be of type MouseWheelEvent');
+    var wheelEvent = /** @type {WheelEvent} */ (mapBrowserEvent.originalEvent);

    if (this.useAnchor_) {
      this.lastAnchor_ = mapBrowserEvent.coordinate;
    }

-    this.delta_ += mouseWheelEvent.deltaY;
+    // Delta normalisation inspired by
+    // https://github.com/mapbox/mapbox-gl-js/blob/001c7b9/js/ui/handler/scroll_zoom.js
+    //TODO There's more good stuff in there for inspiration to improve this interaction.
+    var delta;
+    if (mapBrowserEvent.type == ol.events.EventType.WHEEL) {
+      delta = wheelEvent.deltaY;
+      if (ol.has.FIREFOX &&
+          wheelEvent.deltaMode === goog.global.WheelEvent.DOM_DELTA_PIXEL) {
+        delta /= ol.has.DEVICE_PIXEL_RATIO;
+      }
+      if (wheelEvent.deltaMode === goog.global.WheelEvent.DOM_DELTA_LINE) {
+        delta *= 40;
+      }
+    } else if (mapBrowserEvent.type == ol.events.EventType.MOUSEWHEEL) {
+      delta = -wheelEvent.wheelDeltaY;
+      if (ol.has.SAFARI) {
+        delta /= 3;
+      }
+    }
+
+    this.delta_ += delta;

    if (this.startTime_ === undefined) {
      this.startTime_ = Date.now();
--- a/src/ol/interaction/selectinteraction.js
+++ b/src/ol/interaction/selectinteraction.js
@@ -4,8 +4,8 @@ goog.provide('ol.interaction.SelectEventType');
 goog.provide('ol.interaction.SelectFilterFunction');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.Event');
+goog.require('ol.events');
+goog.require('ol.events.Event');
 goog.require('goog.functions');
 goog.require('goog.object');
 goog.require('ol.CollectionEventType');
@@ -53,7 +53,7 @@ ol.interaction.SelectFilterFunction;
 * @param {ol.MapBrowserEvent} mapBrowserEvent Associated
 *     {@link ol.MapBrowserEvent}.
 * @implements {oli.SelectEvent}
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @constructor
 */
 ol.interaction.SelectEvent = function(type, selected, deselected, mapBrowserEvent) {
@@ -80,7 +80,7 @@ ol.interaction.SelectEvent = function(type, selected, deselected, mapBrowserEven
   */
  this.mapBrowserEvent = mapBrowserEvent;
 };
-goog.inherits(ol.interaction.SelectEvent, goog.events.Event);
+goog.inherits(ol.interaction.SelectEvent, ol.events.Event);


 /**
@@ -208,10 +208,10 @@ ol.interaction.Select = function(opt_options) {
  this.featureLayerAssociation_ = {};

  var features = this.featureOverlay_.getSource().getFeaturesCollection();
-  goog.events.listen(features, ol.CollectionEventType.ADD,
-      this.addFeature_, false, this);
-  goog.events.listen(features, ol.CollectionEventType.REMOVE,
-      this.removeFeature_, false, this);
+  ol.events.listen(features, ol.CollectionEventType.ADD,
+      this.addFeature_, this);
+  ol.events.listen(features, ol.CollectionEventType.REMOVE,
+      this.removeFeature_, this);

 };
 goog.inherits(ol.interaction.Select, ol.interaction.Interaction);
--- a/src/ol/interaction/snapinteraction.js
+++ b/src/ol/interaction/snapinteraction.js
@@ -2,8 +2,8 @@ goog.provide('ol.interaction.Snap');
 goog.provide('ol.interaction.SnapProperty');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Collection');
@@ -68,19 +68,19 @@ ol.interaction.Snap = function(opt_options) {
  this.features_ = options.features ? options.features : null;

  /**
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   * @private
   */
  this.featuresListenerKeys_ = [];

  /**
-   * @type {Object.<number, goog.events.Key>}
+   * @type {Object.<number, ol.events.Key>}
   * @private
   */
  this.geometryChangeListenerKeys_ = {};

  /**
-   * @type {Object.<number, goog.events.Key>}
+   * @type {Object.<number, ol.events.Key>}
   * @private
   */
  this.geometryModifyListenerKeys_ = {};
@@ -168,11 +168,13 @@ ol.interaction.Snap.prototype.addFeature = function(feature, opt_listen) {
    segmentWriter.call(this, feature, geometry);

    if (listen) {
-      this.geometryModifyListenerKeys_[feature_uid] = geometry.on(
-          goog.events.EventType.CHANGE,
+      this.geometryModifyListenerKeys_[feature_uid] = ol.events.listen(
+          geometry,
+          ol.events.EventType.CHANGE,
          this.handleGeometryModify_.bind(this, feature),
          this);
-      this.geometryChangeListenerKeys_[feature_uid] = feature.on(
+      this.geometryChangeListenerKeys_[feature_uid] = ol.events.listen(
+          feature,
          ol.Object.getChangeEventType(feature.getGeometryName()),
          this.handleGeometryChange_, this);
    }
@@ -249,11 +251,11 @@ ol.interaction.Snap.prototype.handleFeatureRemove_ = function(evt) {


 /**
- * @param {goog.events.Event} evt Event.
+ * @param {ol.events.Event} evt Event.
 * @private
 */
 ol.interaction.Snap.prototype.handleGeometryChange_ = function(evt) {
-  var feature = evt.currentTarget;
+  var feature = evt.target;
  goog.asserts.assertInstanceof(feature, ol.Feature);
  this.removeFeature(feature, true);
  this.addFeature(feature, true);
@@ -262,7 +264,7 @@ ol.interaction.Snap.prototype.handleGeometryChange_ = function(evt) {

 /**
 * @param {ol.Feature} feature Feature which geometry was modified.
- * @param {goog.events.Event} evt Event.
+ * @param {ol.events.Event} evt Event.
 * @private
 */
 ol.interaction.Snap.prototype.handleGeometryModify_ = function(feature, evt) {
--- a/src/ol/interaction/translateinteraction.js
+++ b/src/ol/interaction/translateinteraction.js
@@ -1,8 +1,8 @@
 goog.provide('ol.interaction.Translate');
 goog.provide('ol.interaction.TranslateEvent');

-goog.require('goog.events');
-goog.require('goog.events.Event');
+goog.require('ol.events');
+goog.require('ol.events.Event');
 goog.require('ol.array');
 goog.require('ol.interaction.Pointer');

@@ -38,7 +38,7 @@ ol.interaction.TranslateEventType = {
 * this type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.interaction.TranslateEvent}
 * @param {ol.interaction.TranslateEventType} type Type.
 * @param {ol.Collection.<ol.Feature>} features The features translated.
@@ -63,7 +63,7 @@ ol.interaction.TranslateEvent = function(type, features, coordinate) {
   */
  this.coordinate = coordinate;
 };
-goog.inherits(ol.interaction.TranslateEvent, goog.events.Event);
+goog.inherits(ol.interaction.TranslateEvent, ol.events.Event);


 /**
--- a/src/ol/layer/heatmaplayer.js
+++ b/src/ol/layer/heatmaplayer.js
@@ -1,7 +1,7 @@
 goog.provide('ol.layer.Heatmap');

 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Object');
@@ -72,9 +72,9 @@ ol.layer.Heatmap = function(opt_options) {
   */
  this.styleCache_ = null;

-  goog.events.listen(this,
+  ol.events.listen(this,
      ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.GRADIENT),
-      this.handleGradientChanged_, false, this);
+      this.handleGradientChanged_, this);

  this.setGradient(options.gradient ?
      options.gradient : ol.layer.Heatmap.DEFAULT_GRADIENT);
@@ -83,10 +83,12 @@ ol.layer.Heatmap = function(opt_options) {

  this.setRadius(options.radius !== undefined ? options.radius : 8);

-  goog.events.listen(this, [
-    ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.BLUR),
-    ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.RADIUS)
-  ], this.handleStyleChanged_, false, this);
+  ol.events.listen(this,
+      ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.BLUR),
+      this.handleStyleChanged_, this);
+  ol.events.listen(this,
+      ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.RADIUS),
+      this.handleStyleChanged_, this);

  this.handleStyleChanged_();

@@ -129,8 +131,7 @@ ol.layer.Heatmap = function(opt_options) {
  // The render order is not relevant for a heatmap representation.
  this.setRenderOrder(null);

-  goog.events.listen(this, ol.render.EventType.RENDER,
-      this.handleRender_, false, this);
+  ol.events.listen(this, ol.render.EventType.RENDER, this.handleRender_, this);

 };
 goog.inherits(ol.layer.Heatmap, ol.layer.Vector);
--- a/src/ol/layer/layer.js
+++ b/src/ol/layer/layer.js
@@ -1,7 +1,7 @@
 goog.provide('ol.layer.Layer');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Object');
@@ -41,19 +41,19 @@ ol.layer.Layer = function(options) {

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.mapPrecomposeKey_ = null;

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.mapRenderKey_ = null;

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.sourceChangeKey_ = null;

@@ -61,9 +61,9 @@ ol.layer.Layer = function(options) {
    this.setMap(options.map);
  }

-  goog.events.listen(this,
+  ol.events.listen(this,
      ol.Object.getChangeEventType(ol.layer.LayerProperty.SOURCE),
-      this.handleSourcePropertyChange_, false, this);
+      this.handleSourcePropertyChange_, this);

  var source = options.source ? options.source : null;
  this.setSource(source);
@@ -139,13 +139,13 @@ ol.layer.Layer.prototype.handleSourceChange_ = function() {
 */
 ol.layer.Layer.prototype.handleSourcePropertyChange_ = function() {
  if (this.sourceChangeKey_) {
-    goog.events.unlistenByKey(this.sourceChangeKey_);
+    ol.events.unlistenByKey(this.sourceChangeKey_);
    this.sourceChangeKey_ = null;
  }
  var source = this.getSource();
  if (source) {
-    this.sourceChangeKey_ = goog.events.listen(source,
-        goog.events.EventType.CHANGE, this.handleSourceChange_, false, this);
+    this.sourceChangeKey_ = ol.events.listen(source,
+        ol.events.EventType.CHANGE, this.handleSourceChange_, this);
  }
  this.changed();
 };
@@ -164,24 +164,28 @@ ol.layer.Layer.prototype.handleSourcePropertyChange_ = function() {
 * @api
 */
 ol.layer.Layer.prototype.setMap = function(map) {
-  goog.events.unlistenByKey(this.mapPrecomposeKey_);
-  this.mapPrecomposeKey_ = null;
+  if (this.mapPrecomposeKey_) {
+    ol.events.unlistenByKey(this.mapPrecomposeKey_);
+    this.mapPrecomposeKey_ = null;
+  }
  if (!map) {
    this.changed();
  }
-  goog.events.unlistenByKey(this.mapRenderKey_);
-  this.mapRenderKey_ = null;
+  if (this.mapRenderKey_) {
+    ol.events.unlistenByKey(this.mapRenderKey_);
+    this.mapRenderKey_ = null;
+  }
  if (map) {
-    this.mapPrecomposeKey_ = goog.events.listen(
+    this.mapPrecomposeKey_ = ol.events.listen(
        map, ol.render.EventType.PRECOMPOSE, function(evt) {
          var layerState = this.getLayerState();
          layerState.managed = false;
          layerState.zIndex = Infinity;
          evt.frameState.layerStatesArray.push(layerState);
          evt.frameState.layerStates[goog.getUid(this)] = layerState;
-        }, false, this);
-    this.mapRenderKey_ = goog.events.listen(
-        this, goog.events.EventType.CHANGE, map.render, false, map);
+        }, this);
+    this.mapRenderKey_ = ol.events.listen(
+        this, ol.events.EventType.CHANGE, map.render, map);
    this.changed();
  }
 };
--- a/src/ol/layer/layergroup.js
+++ b/src/ol/layer/layergroup.js
@@ -1,8 +1,8 @@
 goog.provide('ol.layer.Group');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Collection');
 goog.require('ol.CollectionEvent');
@@ -46,19 +46,19 @@ ol.layer.Group = function(opt_options) {

  /**
   * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   */
  this.layersListenerKeys_ = [];

  /**
   * @private
-   * @type {Object.<string, Array.<goog.events.Key>>}
+   * @type {Object.<string, Array.<ol.events.Key>>}
   */
  this.listenerKeys_ = {};

-  goog.events.listen(this,
+  ol.events.listen(this,
      ol.Object.getChangeEventType(ol.layer.GroupProperty.LAYERS),
-      this.handleLayersChanged_, false, this);
+      this.handleLayersChanged_, this);

  if (layers) {
    if (goog.isArray(layers)) {
@@ -89,22 +89,22 @@ ol.layer.Group.prototype.handleLayerChange_ = function() {


 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @private
 */
 ol.layer.Group.prototype.handleLayersChanged_ = function(event) {
-  this.layersListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.layersListenerKeys_.forEach(ol.events.unlistenByKey);
  this.layersListenerKeys_.length = 0;

  var layers = this.getLayers();
  this.layersListenerKeys_.push(
-      goog.events.listen(layers, ol.CollectionEventType.ADD,
-          this.handleLayersAdd_, false, this),
-      goog.events.listen(layers, ol.CollectionEventType.REMOVE,
-          this.handleLayersRemove_, false, this));
+      ol.events.listen(layers, ol.CollectionEventType.ADD,
+          this.handleLayersAdd_, this),
+      ol.events.listen(layers, ol.CollectionEventType.REMOVE,
+          this.handleLayersRemove_, this));

  goog.object.forEach(this.listenerKeys_, function(keys) {
-    keys.forEach(goog.events.unlistenByKey);
+    keys.forEach(ol.events.unlistenByKey);
  });
  goog.object.clear(this.listenerKeys_);

@@ -113,10 +113,10 @@ ol.layer.Group.prototype.handleLayersChanged_ = function(event) {
  for (i = 0, ii = layersArray.length; i < ii; i++) {
    layer = layersArray[i];
    this.listenerKeys_[goog.getUid(layer).toString()] = [
-      goog.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
-          this.handleLayerChange_, false, this),
-      goog.events.listen(layer, goog.events.EventType.CHANGE,
-          this.handleLayerChange_, false, this)
+      ol.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
+          this.handleLayerChange_, this),
+      ol.events.listen(layer, ol.events.EventType.CHANGE,
+          this.handleLayerChange_, this)
    ];
  }

@@ -134,10 +134,10 @@ ol.layer.Group.prototype.handleLayersAdd_ = function(collectionEvent) {
  goog.asserts.assert(!(key in this.listenerKeys_),
      'listeners already registered');
  this.listenerKeys_[key] = [
-    goog.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
-        this.handleLayerChange_, false, this),
-    goog.events.listen(layer, goog.events.EventType.CHANGE,
-        this.handleLayerChange_, false, this)
+    ol.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
+        this.handleLayerChange_, this),
+    ol.events.listen(layer, ol.events.EventType.CHANGE,
+        this.handleLayerChange_, this)
  ];
  this.changed();
 };
@@ -151,7 +151,7 @@ ol.layer.Group.prototype.handleLayersRemove_ = function(collectionEvent) {
  var layer = /** @type {ol.layer.Base} */ (collectionEvent.element);
  var key = goog.getUid(layer).toString();
  goog.asserts.assert(key in this.listenerKeys_, 'no listeners to unregister');
-  this.listenerKeys_[key].forEach(goog.events.unlistenByKey);
+  this.listenerKeys_[key].forEach(ol.events.unlistenByKey);
  delete this.listenerKeys_[key];
  this.changed();
 };
--- a/src/ol/map.js
+++ b/src/ol/map.js
@@ -6,20 +6,10 @@ goog.provide('ol.Map');
 goog.provide('ol.MapProperty');

 goog.require('goog.asserts');
-goog.require('goog.async.AnimationDelay');
 goog.require('goog.async.nextTick');
 goog.require('goog.debug.Console');
 goog.require('goog.dom');
-goog.require('goog.dom.ViewportSizeMonitor');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
-goog.require('goog.events.BrowserEvent');
-goog.require('goog.events.Event');
-goog.require('goog.events.EventType');
-goog.require('goog.events.KeyHandler');
-goog.require('goog.events.KeyHandler.EventType');
-goog.require('goog.events.MouseWheelHandler');
-goog.require('goog.events.MouseWheelHandler.EventType');
 goog.require('goog.functions');
 goog.require('goog.log');
 goog.require('goog.log.Level');
@@ -46,6 +36,9 @@ goog.require('ol.View');
 goog.require('ol.ViewHint');
 goog.require('ol.array');
 goog.require('ol.control');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('ol.extent');
 goog.require('ol.has');
 goog.require('ol.interaction');
@@ -205,11 +198,17 @@ ol.Map = function(options) {

  /**
   * @private
-   * @type {goog.async.AnimationDelay}
+   * @type {number|undefined}
   */
-  this.animationDelay_ =
-      new goog.async.AnimationDelay(this.renderFrame_, undefined, this);
-  this.registerDisposable(this.animationDelay_);
+  this.animationDelayKey_;
+
+  /**
+   * @private
+   */
+  this.animationDelay_ = function() {
+    this.animationDelayKey_ = undefined;
+    this.renderFrame_.call(this, Date.now());
+  }.bind(this);

  /**
   * @private
@@ -244,13 +243,13 @@ ol.Map = function(options) {

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.viewPropertyListenerKey_ = null;

  /**
   * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   */
  this.layerGroupPropertyListenerKeys_ = null;

@@ -285,21 +284,26 @@ ol.Map = function(options) {
   */
  this.overlayContainerStopEvent_ = document.createElement('DIV');
  this.overlayContainerStopEvent_.className = 'ol-overlaycontainer-stopevent';
-  goog.events.listen(this.overlayContainerStopEvent_, [
-    goog.events.EventType.CLICK,
-    goog.events.EventType.DBLCLICK,
-    goog.events.EventType.MOUSEDOWN,
-    goog.events.EventType.TOUCHSTART,
-    goog.events.EventType.MSPOINTERDOWN,
+  var overlayEvents = [
+    ol.events.EventType.CLICK,
+    ol.events.EventType.DBLCLICK,
+    ol.events.EventType.MOUSEDOWN,
+    ol.events.EventType.TOUCHSTART,
+    ol.events.EventType.MSPOINTERDOWN,
    ol.MapBrowserEvent.EventType.POINTERDOWN,
-    goog.userAgent.GECKO ? 'DOMMouseScroll' : 'mousewheel'
-  ], goog.events.Event.stopPropagation);
+    goog.userAgent.GECKO ? 'DOMMouseScroll' : ol.events.EventType.MOUSEWHEEL
+  ];
+  for (var i = 0, ii = overlayEvents.length; i < ii; ++i) {
+    ol.events.listen(this.overlayContainerStopEvent_, overlayEvents[i],
+        ol.events.Event.stopPropagation);
+  }
  this.viewport_.appendChild(this.overlayContainerStopEvent_);

  var mapBrowserEventHandler = new ol.MapBrowserEventHandler(this);
-  goog.events.listen(mapBrowserEventHandler,
-      goog.object.getValues(ol.MapBrowserEvent.EventType),
-      this.handleMapBrowserEvent, false, this);
+  for (var key in ol.MapBrowserEvent.EventType) {
+    ol.events.listen(mapBrowserEventHandler, ol.MapBrowserEvent.EventType[key],
+        this.handleMapBrowserEvent, this);
+  }
  this.registerDisposable(mapBrowserEventHandler);

  /**
@@ -310,18 +314,14 @@ ol.Map = function(options) {

  /**
   * @private
-   * @type {goog.events.KeyHandler}
+   * @type {Array.<ol.events.Key>}
   */
-  this.keyHandler_ = new goog.events.KeyHandler();
-  goog.events.listen(this.keyHandler_, goog.events.KeyHandler.EventType.KEY,
-      this.handleBrowserEvent, false, this);
-  this.registerDisposable(this.keyHandler_);
+  this.keyHandlerKeys_ = null;

-  var mouseWheelHandler = new goog.events.MouseWheelHandler(this.viewport_);
-  goog.events.listen(mouseWheelHandler,
-      goog.events.MouseWheelHandler.EventType.MOUSEWHEEL,
-      this.handleBrowserEvent, false, this);
-  this.registerDisposable(mouseWheelHandler);
+  ol.events.listen(this.viewport_, ol.events.EventType.WHEEL,
+      this.handleBrowserEvent, this);
+  ol.events.listen(this.viewport_, ol.events.EventType.MOUSEWHEEL,
+      this.handleBrowserEvent, this);

  /**
   * @type {ol.Collection.<ol.control.Control>}
@@ -357,17 +357,10 @@ ol.Map = function(options) {
  this.registerDisposable(this.renderer_);

  /**
-   * @type {goog.dom.ViewportSizeMonitor}
+   * @type {function(Event)|undefined}
   * @private
   */
-  this.viewportSizeMonitor_ = new goog.dom.ViewportSizeMonitor();
-  this.registerDisposable(this.viewportSizeMonitor_);
-
-  /**
-   * @type {goog.events.Key}
-   * @private
-   */
-  this.viewportResizeListenerKey_ = null;
+  this.handleResize_;

  /**
   * @private
@@ -402,15 +395,15 @@ ol.Map = function(options) {
   */
  this.skippedFeatureUids_ = {};

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.MapProperty.LAYERGROUP),
-      this.handleLayerGroupChanged_, false, this);
-  goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.VIEW),
-      this.handleViewChanged_, false, this);
-  goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.SIZE),
-      this.handleSizeChanged_, false, this);
-  goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.TARGET),
-      this.handleTargetChanged_, false, this);
+      this.handleLayerGroupChanged_, this);
+  ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.VIEW),
+      this.handleViewChanged_, this);
+  ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.SIZE),
+      this.handleSizeChanged_, this);
+  ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.TARGET),
+      this.handleTargetChanged_, this);

  // setProperties will trigger the rendering of the map if the map
  // is "defined" already.
@@ -425,21 +418,21 @@ ol.Map = function(options) {
        control.setMap(this);
      }, this);

-  goog.events.listen(this.controls_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.controls_, ol.CollectionEventType.ADD,
      /**
       * @param {ol.CollectionEvent} event Collection event.
       */
      function(event) {
        event.element.setMap(this);
-      }, false, this);
+      }, this);

-  goog.events.listen(this.controls_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.controls_, ol.CollectionEventType.REMOVE,
      /**
       * @param {ol.CollectionEvent} event Collection event.
       */
      function(event) {
        event.element.setMap(null);
-      }, false, this);
+      }, this);

  this.interactions_.forEach(
      /**
@@ -450,33 +443,33 @@ ol.Map = function(options) {
        interaction.setMap(this);
      }, this);

-  goog.events.listen(this.interactions_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.interactions_, ol.CollectionEventType.ADD,
      /**
       * @param {ol.CollectionEvent} event Collection event.
       */
      function(event) {
        event.element.setMap(this);
-      }, false, this);
+      }, this);

-  goog.events.listen(this.interactions_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.interactions_, ol.CollectionEventType.REMOVE,
      /**
       * @param {ol.CollectionEvent} event Collection event.
       */
      function(event) {
        event.element.setMap(null);
-      }, false, this);
+      }, this);

  this.overlays_.forEach(this.addOverlayInternal_, this);

-  goog.events.listen(this.overlays_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.overlays_, ol.CollectionEventType.ADD,
      /**
       * @param {ol.CollectionEvent} event Collection event.
       */
      function(event) {
        this.addOverlayInternal_(/** @type {ol.Overlay} */ (event.element));
-      }, false, this);
+      }, this);

-  goog.events.listen(this.overlays_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.overlays_, ol.CollectionEventType.REMOVE,
      /**
       * @param {ol.CollectionEvent} event Collection event.
       */
@@ -486,7 +479,7 @@ ol.Map = function(options) {
          delete this.overlayIdIndex_[id.toString()];
        }
        event.element.setMap(null);
-      }, false, this);
+      }, this);

 };
 goog.inherits(ol.Map, ol.Object);
@@ -583,6 +576,19 @@ ol.Map.prototype.removePreRenderFunction = function(preRenderFunction) {
 * @inheritDoc
 */
 ol.Map.prototype.disposeInternal = function() {
+  ol.events.unlisten(this.viewport_, ol.events.EventType.WHEEL,
+      this.handleBrowserEvent, this);
+  ol.events.unlisten(this.viewport_, ol.events.EventType.MOUSEWHEEL,
+      this.handleBrowserEvent, this);
+  if (this.handleResize_ !== undefined) {
+    goog.global.removeEventListener(ol.events.EventType.RESIZE,
+        this.handleResize_, false);
+    this.handleResize_ = undefined;
+  }
+  if (this.animationDelayKey_) {
+    goog.global.cancelAnimationFrame(this.animationDelayKey_);
+    this.animationDelayKey_ = undefined;
+  }
  goog.dom.removeNode(this.viewport_);
  goog.base(this, 'disposeInternal');
 };
@@ -949,7 +955,7 @@ ol.Map.prototype.getTilePriority = function(tile, tileSourceKey, tileCenter, til


 /**
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
 * @param {string=} opt_type Type.
 */
 ol.Map.prototype.handleBrowserEvent = function(browserEvent, opt_type) {
@@ -1059,25 +1065,36 @@ ol.Map.prototype.handleTargetChanged_ = function() {

  var targetElement = this.getTargetElement();

-  this.keyHandler_.detach();
+  if (this.keyHandlerKeys_) {
+    for (var i = 0, ii = this.keyHandlerKeys_.length; i < ii; ++i) {
+      ol.events.unlistenByKey(this.keyHandlerKeys_[i]);
+    }
+    this.keyHandlerKeys_ = null;
+  }

  if (!targetElement) {
    goog.dom.removeNode(this.viewport_);
-    if (this.viewportResizeListenerKey_) {
-      goog.events.unlistenByKey(this.viewportResizeListenerKey_);
-      this.viewportResizeListenerKey_ = null;
+    if (this.handleResize_ !== undefined) {
+      goog.global.removeEventListener(ol.events.EventType.RESIZE,
+          this.handleResize_, false);
+      this.handleResize_ = undefined;
    }
  } else {
    targetElement.appendChild(this.viewport_);

    var keyboardEventTarget = !this.keyboardEventTarget_ ?
        targetElement : this.keyboardEventTarget_;
-    this.keyHandler_.attach(keyboardEventTarget);
+    this.keyHandlerKeys_ = [
+      ol.events.listen(keyboardEventTarget, ol.events.EventType.KEYDOWN,
+          this.handleBrowserEvent, this),
+      ol.events.listen(keyboardEventTarget, ol.events.EventType.KEYPRESS,
+          this.handleBrowserEvent, this)
+    ];

-    if (!this.viewportResizeListenerKey_) {
-      this.viewportResizeListenerKey_ = goog.events.listen(
-          this.viewportSizeMonitor_, goog.events.EventType.RESIZE,
-          this.updateSize, false, this);
+    if (!this.handleResize_) {
+      this.handleResize_ = this.updateSize.bind(this);
+      goog.global.addEventListener(ol.events.EventType.RESIZE,
+          this.handleResize_, false);
    }
  }

@@ -1108,25 +1125,25 @@ ol.Map.prototype.handleViewPropertyChanged_ = function() {
 */
 ol.Map.prototype.handleViewChanged_ = function() {
  if (this.viewPropertyListenerKey_) {
-    goog.events.unlistenByKey(this.viewPropertyListenerKey_);
+    ol.events.unlistenByKey(this.viewPropertyListenerKey_);
    this.viewPropertyListenerKey_ = null;
  }
  var view = this.getView();
  if (view) {
-    this.viewPropertyListenerKey_ = goog.events.listen(
+    this.viewPropertyListenerKey_ = ol.events.listen(
        view, ol.ObjectEventType.PROPERTYCHANGE,
-        this.handleViewPropertyChanged_, false, this);
+        this.handleViewPropertyChanged_, this);
  }
  this.render();
 };


 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @private
 */
 ol.Map.prototype.handleLayerGroupMemberChanged_ = function(event) {
-  goog.asserts.assertInstanceof(event, goog.events.Event,
+  goog.asserts.assertInstanceof(event, ol.events.Event,
      'event should be an Event');
  this.render();
 };
@@ -1148,18 +1165,18 @@ ol.Map.prototype.handleLayerGroupPropertyChanged_ = function(event) {
 */
 ol.Map.prototype.handleLayerGroupChanged_ = function() {
  if (this.layerGroupPropertyListenerKeys_) {
-    this.layerGroupPropertyListenerKeys_.forEach(goog.events.unlistenByKey);
+    this.layerGroupPropertyListenerKeys_.forEach(ol.events.unlistenByKey);
    this.layerGroupPropertyListenerKeys_ = null;
  }
  var layerGroup = this.getLayerGroup();
  if (layerGroup) {
    this.layerGroupPropertyListenerKeys_ = [
-      goog.events.listen(
+      ol.events.listen(
          layerGroup, ol.ObjectEventType.PROPERTYCHANGE,
-          this.handleLayerGroupPropertyChanged_, false, this),
-      goog.events.listen(
-          layerGroup, goog.events.EventType.CHANGE,
-          this.handleLayerGroupMemberChanged_, false, this)
+          this.handleLayerGroupPropertyChanged_, this),
+      ol.events.listen(
+          layerGroup, ol.events.EventType.CHANGE,
+          this.handleLayerGroupMemberChanged_, this)
    ];
  }
  this.render();
@@ -1204,7 +1221,10 @@ ol.Map.prototype.isRendered = function() {
 * @api stable
 */
 ol.Map.prototype.renderSync = function() {
-  this.animationDelay_.fire();
+  if (this.animationDelayKey_) {
+    goog.global.cancelAnimationFrame(this.animationDelayKey_);
+  }
+  this.animationDelay_();
 };


@@ -1213,8 +1233,9 @@ ol.Map.prototype.renderSync = function() {
 * @api stable
 */
 ol.Map.prototype.render = function() {
-  if (!this.animationDelay_.isActive()) {
-    this.animationDelay_.start();
+  if (this.animationDelayKey_ === undefined) {
+    this.animationDelayKey_ = goog.global.requestAnimationFrame(
+        this.animationDelay_);
  }
 };

--- a/src/ol/mapbrowserevent.js
+++ b/src/ol/mapbrowserevent.js
@@ -4,10 +4,9 @@ goog.provide('ol.MapBrowserEventHandler');
 goog.provide('ol.MapBrowserPointerEvent');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.BrowserEvent');
-goog.require('goog.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventTarget');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Coordinate');
@@ -27,7 +26,7 @@ goog.require('ol.pointer.PointerEventHandler');
 * @implements {oli.MapBrowserEvent}
 * @param {string} type Event type.
 * @param {ol.Map} map Map.
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
 * @param {boolean=} opt_dragging Is the map currently being dragged?
 * @param {?olx.FrameState=} opt_frameState Frame state.
 */
@@ -36,26 +35,20 @@ ol.MapBrowserEvent = function(type, map, browserEvent, opt_dragging,

  goog.base(this, type, map, opt_frameState);

-  /**
-   * @const
-   * @type {goog.events.BrowserEvent}
-   */
-  this.browserEvent = browserEvent;
-
  /**
   * The original browser event.
   * @const
   * @type {Event}
   * @api stable
   */
-  this.originalEvent = browserEvent.getBrowserEvent();
+  this.originalEvent = browserEvent;

  /**
   * The pixel of the original browser event.
   * @type {ol.Pixel}
   * @api stable
   */
-  this.pixel = map.getEventPixel(this.originalEvent);
+  this.pixel = map.getEventPixel(browserEvent);

  /**
   * The coordinate of the original browser event.
@@ -85,7 +78,7 @@ goog.inherits(ol.MapBrowserEvent, ol.MapEvent);
 */
 ol.MapBrowserEvent.prototype.preventDefault = function() {
  goog.base(this, 'preventDefault');
-  this.browserEvent.preventDefault();
+  this.originalEvent.preventDefault();
 };


@@ -97,7 +90,7 @@ ol.MapBrowserEvent.prototype.preventDefault = function() {
 */
 ol.MapBrowserEvent.prototype.stopPropagation = function() {
  goog.base(this, 'stopPropagation');
-  this.browserEvent.stopPropagation();
+  this.originalEvent.stopPropagation();
 };


@@ -113,7 +106,7 @@ ol.MapBrowserEvent.prototype.stopPropagation = function() {
 ol.MapBrowserPointerEvent = function(type, map, pointerEvent, opt_dragging,
    opt_frameState) {

-  goog.base(this, type, map, pointerEvent.browserEvent, opt_dragging,
+  goog.base(this, type, map, pointerEvent.originalEvent, opt_dragging,
      opt_frameState);

  /**
@@ -129,7 +122,7 @@ goog.inherits(ol.MapBrowserPointerEvent, ol.MapBrowserEvent);
 /**
 * @param {ol.Map} map The map with the viewport to listen to events on.
 * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 */
 ol.MapBrowserEventHandler = function(map) {

@@ -155,13 +148,13 @@ ol.MapBrowserEventHandler = function(map) {
  this.dragging_ = false;

  /**
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   * @private
   */
  this.dragListenerKeys_ = null;

  /**
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   * @private
   */
  this.pointerdownListenerKey_ = null;
@@ -206,16 +199,16 @@ ol.MapBrowserEventHandler = function(map) {
   */
  this.documentPointerEventHandler_ = null;

-  this.pointerdownListenerKey_ = goog.events.listen(this.pointerEventHandler_,
+  this.pointerdownListenerKey_ = ol.events.listen(this.pointerEventHandler_,
      ol.pointer.EventType.POINTERDOWN,
-      this.handlePointerDown_, false, this);
+      this.handlePointerDown_, this);

-  this.relayedListenerKey_ = goog.events.listen(this.pointerEventHandler_,
+  this.relayedListenerKey_ = ol.events.listen(this.pointerEventHandler_,
      ol.pointer.EventType.POINTERMOVE,
-      this.relayEvent_, false, this);
+      this.relayEvent_, this);

 };
-goog.inherits(ol.MapBrowserEventHandler, goog.events.EventTarget);
+goog.inherits(ol.MapBrowserEventHandler, ol.events.EventTarget);


 /**
@@ -287,7 +280,7 @@ ol.MapBrowserEventHandler.prototype.handlePointerUp_ = function(pointerEvent) {
  goog.asserts.assert(this.activePointers_ >= 0,
      'this.activePointers_ should be equal to or larger than 0');
  if (this.activePointers_ === 0) {
-    this.dragListenerKeys_.forEach(goog.events.unlistenByKey);
+    this.dragListenerKeys_.forEach(ol.events.unlistenByKey);
    this.dragListenerKeys_ = null;
    this.dragging_ = false;
    this.down_ = null;
@@ -328,12 +321,12 @@ ol.MapBrowserEventHandler.prototype.handlePointerDown_ = function(pointerEvent)
        new ol.pointer.PointerEventHandler(document);

    this.dragListenerKeys_ = [
-      goog.events.listen(this.documentPointerEventHandler_,
+      ol.events.listen(this.documentPointerEventHandler_,
          ol.MapBrowserEvent.EventType.POINTERMOVE,
-          this.handlePointerMove_, false, this),
-      goog.events.listen(this.documentPointerEventHandler_,
+          this.handlePointerMove_, this),
+      ol.events.listen(this.documentPointerEventHandler_,
          ol.MapBrowserEvent.EventType.POINTERUP,
-          this.handlePointerUp_, false, this),
+          this.handlePointerUp_, this),
      /* Note that the listener for `pointercancel is set up on
       * `pointerEventHandler_` and not `documentPointerEventHandler_` like
       * the `pointerup` and `pointermove` listeners.
@@ -347,9 +340,9 @@ ol.MapBrowserEventHandler.prototype.handlePointerDown_ = function(pointerEvent)
       * only receive a `touchcancel` from `pointerEventHandler_`, because it is
       * only registered there.
       */
-      goog.events.listen(this.pointerEventHandler_,
+      ol.events.listen(this.pointerEventHandler_,
          ol.MapBrowserEvent.EventType.POINTERCANCEL,
-          this.handlePointerUp_, false, this)
+          this.handlePointerUp_, this)
    ];
  }
 };
@@ -410,15 +403,15 @@ ol.MapBrowserEventHandler.prototype.isMoving_ = function(pointerEvent) {
 */
 ol.MapBrowserEventHandler.prototype.disposeInternal = function() {
  if (this.relayedListenerKey_) {
-    goog.events.unlistenByKey(this.relayedListenerKey_);
+    ol.events.unlistenByKey(this.relayedListenerKey_);
    this.relayedListenerKey_ = null;
  }
  if (this.pointerdownListenerKey_) {
-    goog.events.unlistenByKey(this.pointerdownListenerKey_);
+    ol.events.unlistenByKey(this.pointerdownListenerKey_);
    this.pointerdownListenerKey_ = null;
  }
  if (this.dragListenerKeys_) {
-    this.dragListenerKeys_.forEach(goog.events.unlistenByKey);
+    this.dragListenerKeys_.forEach(ol.events.unlistenByKey);
    this.dragListenerKeys_ = null;
  }
  if (this.documentPointerEventHandler_) {
@@ -452,14 +445,14 @@ ol.MapBrowserEvent.EventType = {
   * @event ol.MapBrowserEvent#click
   * @api stable
   */
-  CLICK: goog.events.EventType.CLICK,
+  CLICK: ol.events.EventType.CLICK,

  /**
   * A true double click, with no dragging.
   * @event ol.MapBrowserEvent#dblclick
   * @api stable
   */
-  DBLCLICK: goog.events.EventType.DBLCLICK,
+  DBLCLICK: ol.events.EventType.DBLCLICK,

  /**
   * Triggered when a pointer is dragged.
--- a/src/ol/mapevent.js
+++ b/src/ol/mapevent.js
@@ -1,7 +1,7 @@
 goog.provide('ol.MapEvent');
 goog.provide('ol.MapEventType');

-goog.require('goog.events.Event');
+goog.require('ol.events.Event');


 /**
@@ -32,7 +32,7 @@ ol.MapEventType = {
 * See {@link ol.Map} for which events trigger a map event.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.MapEvent}
 * @param {string} type Event type.
 * @param {ol.Map} map Map.
@@ -57,4 +57,4 @@ ol.MapEvent = function(type, map, opt_frameState) {
  this.frameState = opt_frameState !== undefined ? opt_frameState : null;

 };
-goog.inherits(ol.MapEvent, goog.events.Event);
+goog.inherits(ol.MapEvent, ol.events.Event);
--- a/src/ol/net.js
+++ b/src/ol/net.js
@@ -0,0 +1,37 @@
+goog.provide('ol.net');
+
+
+/**
+ * Simple JSONP helper. Supports error callbacks and a custom callback param.
+ * The error callback will be called when no JSONP is executed after 10 seconds.
+ *
+ * @param {string} url Request url. A 'callback' query parameter will be
+ *     appended.
+ * @param {Function} callback Callback on success.
+ * @param {function()=} opt_errback Callback on error.
+ * @param {string=} opt_callbackParam Custom qurey parameter for the JSONP
+ *     callback. Default is 'callback'.
+ */
+ol.net.jsonp = function(url, callback, opt_errback, opt_callbackParam) {
+  var script = goog.global.document.createElement('script');
+  var key = 'olc_' + goog.getUid(callback);
+  function cleanup() {
+    delete goog.global[key];
+    script.parentNode.removeChild(script);
+  }
+  script.async = true;
+  script.src = url + (url.indexOf('?') == -1 ? '?' : '&') +
+      (opt_callbackParam || 'callback') + '=' + key;
+  var timer = goog.global.setTimeout(function() {
+    cleanup();
+    if (opt_errback) {
+      opt_errback();
+    }
+  }, 10000);
+  goog.global[key] = function(data) {
+    goog.global.clearTimeout(timer);
+    cleanup();
+    callback(data);
+  };
+  goog.global.document.getElementsByTagName('head')[0].appendChild(script);
+};
--- a/src/ol/object.js
+++ b/src/ol/object.js
@@ -2,8 +2,8 @@ goog.provide('ol.Object');
 goog.provide('ol.ObjectEvent');
 goog.provide('ol.ObjectEventType');

-goog.require('goog.events');
-goog.require('goog.events.Event');
+goog.require('ol.events');
+goog.require('ol.events.Event');
 goog.require('ol.Observable');


@@ -27,7 +27,7 @@ ol.ObjectEventType = {
 * @param {string} type The event type.
 * @param {string} key The property name.
 * @param {*} oldValue The old value for `key`.
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.ObjectEvent}
 * @constructor
 */
@@ -50,7 +50,7 @@ ol.ObjectEvent = function(type, key, oldValue) {
  this.oldValue = oldValue;

 };
-goog.inherits(ol.ObjectEvent, goog.events.Event);
+goog.inherits(ol.ObjectEvent, ol.events.Event);


 /**
--- a/src/ol/observable.js
+++ b/src/ol/observable.js
@@ -1,8 +1,8 @@
 goog.provide('ol.Observable');

-goog.require('goog.events');
-goog.require('goog.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventTarget');
+goog.require('ol.events.EventType');


 /**
@@ -14,7 +14,7 @@ goog.require('goog.events.EventType');
 * {@link ol.Observable#changed}.
 *
 * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 * @fires change
 * @struct
 * @api stable
@@ -30,16 +30,23 @@ ol.Observable = function() {
  this.revision_ = 0;

 };
-goog.inherits(ol.Observable, goog.events.EventTarget);
+goog.inherits(ol.Observable, ol.events.EventTarget);


 /**
 * Removes an event listener using the key returned by `on()` or `once()`.
- * @param {goog.events.Key} key The key returned by `on()` or `once()`.
+ * @param {ol.events.Key|Array.<ol.events.Key>} key The key returned by `on()`
+ *     or `once()` (or an array of keys).
 * @api stable
 */
 ol.Observable.unByKey = function(key) {
-  goog.events.unlistenByKey(key);
+  if (Array.isArray(key)) {
+    for (var i = 0, ii = key.length; i < ii; ++i) {
+      ol.events.unlistenByKey(key[i]);
+    }
+  } else {
+    ol.events.unlistenByKey(/** @type {ol.events.Key} */ (key));
+  }
 };


@@ -49,7 +56,7 @@ ol.Observable.unByKey = function(key) {
 */
 ol.Observable.prototype.changed = function() {
  ++this.revision_;
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };


@@ -65,7 +72,9 @@ ol.Observable.prototype.changed = function() {
 * of this type. The event parameter can either be a string or an
 * Object with a `type` property.
 *
- * @param {goog.events.EventLike} event Event object.
+ * @param {{type: string,
+ *     target: (EventTarget|ol.events.EventTarget|undefined)}|ol.events.Event|
+ *     string} event Event object.
 * @function
 * @api
 */
@@ -88,11 +97,23 @@ ol.Observable.prototype.getRevision = function() {
 * @param {string|Array.<string>} type The event type or array of event types.
 * @param {function(?): ?} listener The listener function.
 * @param {Object=} opt_this The object to use as `this` in `listener`.
- * @return {goog.events.Key} Unique key for the listener.
+ * @return {ol.events.Key|Array.<ol.events.Key>} Unique key for the listener. If
+ *     called with an array of event types as the first argument, the return
+ *     will be an array of keys.
 * @api stable
 */
 ol.Observable.prototype.on = function(type, listener, opt_this) {
-  return goog.events.listen(this, type, listener, false, opt_this);
+  if (Array.isArray(type)) {
+    var len = type.length;
+    var keys = new Array(len);
+    for (var i = 0; i < len; ++i) {
+      keys[i] = ol.events.listen(this, type[i], listener, opt_this);
+    }
+    return keys;
+  } else {
+    return ol.events.listen(
+        this, /** @type {string} */ (type), listener, opt_this);
+  }
 };


@@ -101,11 +122,23 @@ ol.Observable.prototype.on = function(type, listener, opt_this) {
 * @param {string|Array.<string>} type The event type or array of event types.
 * @param {function(?): ?} listener The listener function.
 * @param {Object=} opt_this The object to use as `this` in `listener`.
- * @return {goog.events.Key} Unique key for the listener.
+ * @return {ol.events.Key|Array.<ol.events.Key>} Unique key for the listener. If
+ *     called with an array of event types as the first argument, the return
+ *     will be an array of keys.
 * @api stable
 */
 ol.Observable.prototype.once = function(type, listener, opt_this) {
-  return goog.events.listenOnce(this, type, listener, false, opt_this);
+  if (Array.isArray(type)) {
+    var len = type.length;
+    var keys = new Array(len);
+    for (var i = 0; i < len; ++i) {
+      keys[i] = ol.events.listenOnce(this, type[i], listener, opt_this);
+    }
+    return keys;
+  } else {
+    return ol.events.listenOnce(
+        this, /** @type {string} */ (type), listener, opt_this);
+  }
 };


@@ -118,7 +151,14 @@ ol.Observable.prototype.once = function(type, listener, opt_this) {
 * @api stable
 */
 ol.Observable.prototype.un = function(type, listener, opt_this) {
-  goog.events.unlisten(this, type, listener, false, opt_this);
+  if (Array.isArray(type)) {
+    for (var i = 0, ii = type.length; i < ii; ++i) {
+      ol.events.unlisten(this, type[i], listener, opt_this);
+    }
+    return;
+  } else {
+    ol.events.unlisten(this, /** @type {string} */ (type), listener, opt_this);
+  }
 };


@@ -126,7 +166,8 @@ ol.Observable.prototype.un = function(type, listener, opt_this) {
 * Removes an event listener using the key returned by `on()` or `once()`.
 * Note that using the {@link ol.Observable.unByKey} static function is to
 * be preferred.
- * @param {goog.events.Key} key The key returned by `on()` or `once()`.
+ * @param {ol.events.Key|Array.<ol.events.Key>} key The key returned by `on()`
+ *     or `once()` (or an array of keys).
 * @function
 * @api stable
 */
--- a/src/ol/overlay.js
+++ b/src/ol/overlay.js
@@ -4,7 +4,7 @@ goog.provide('ol.OverlayProperty');

 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.style');
 goog.require('ol.Coordinate');
 goog.require('ol.Map');
@@ -137,29 +137,29 @@ ol.Overlay = function(options) {

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.mapPostrenderListenerKey_ = null;

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.OverlayProperty.ELEMENT),
-      this.handleElementChanged, false, this);
+      this.handleElementChanged, this);

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.OverlayProperty.MAP),
-      this.handleMapChanged, false, this);
+      this.handleMapChanged, this);

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.OverlayProperty.OFFSET),
-      this.handleOffsetChanged, false, this);
+      this.handleOffsetChanged, this);

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.OverlayProperty.POSITION),
-      this.handlePositionChanged, false, this);
+      this.handlePositionChanged, this);

-  goog.events.listen(
+  ol.events.listen(
      this, ol.Object.getChangeEventType(ol.OverlayProperty.POSITIONING),
-      this.handlePositioningChanged, false, this);
+      this.handlePositioningChanged, this);

  if (options.element !== undefined) {
    this.setElement(options.element);
@@ -269,13 +269,13 @@ ol.Overlay.prototype.handleElementChanged = function() {
 ol.Overlay.prototype.handleMapChanged = function() {
  if (this.mapPostrenderListenerKey_) {
    goog.dom.removeNode(this.element_);
-    goog.events.unlistenByKey(this.mapPostrenderListenerKey_);
+    ol.events.unlistenByKey(this.mapPostrenderListenerKey_);
    this.mapPostrenderListenerKey_ = null;
  }
  var map = this.getMap();
  if (map) {
-    this.mapPostrenderListenerKey_ = goog.events.listen(map,
-        ol.MapEventType.POSTRENDER, this.render, false, this);
+    this.mapPostrenderListenerKey_ = ol.events.listen(map,
+        ol.MapEventType.POSTRENDER, this.render, this);
    this.updatePixelPosition();
    var container = this.stopEvent_ ?
        map.getOverlayContainerStopEvent() : map.getOverlayContainer();
--- a/src/ol/pointer/eventsource.js
+++ b/src/ol/pointer/eventsource.js
@@ -1,11 +1,9 @@
 goog.provide('ol.pointer.EventSource');

-goog.require('goog.events.BrowserEvent');
-

 /**
 * @param {ol.pointer.PointerEventHandler} dispatcher Event handler.
- * @param {!Object.<string, function(goog.events.BrowserEvent)>} mapping Event
+ * @param {!Object.<string, function(Event)>} mapping Event
 *     mapping.
 * @constructor
 */
@@ -18,7 +16,7 @@ ol.pointer.EventSource = function(dispatcher, mapping) {
  /**
   * @private
   * @const
-   * @type {!Object.<string, function(goog.events.BrowserEvent)>}
+   * @type {!Object.<string, function(Event)>}
   */
  this.mapping_ = mapping;
 };
@@ -36,7 +34,7 @@ ol.pointer.EventSource.prototype.getEvents = function() {
 /**
 * Returns a mapping between the supported event types and
 * the handlers that should handle an event.
- * @return {Object.<string, function(goog.events.BrowserEvent)>}
+ * @return {Object.<string, function(Event)>}
 *         Event/Handler mapping
 */
 ol.pointer.EventSource.prototype.getMapping = function() {
@@ -47,7 +45,7 @@ ol.pointer.EventSource.prototype.getMapping = function() {
 /**
 * Returns the handler that should handle a given event type.
 * @param {string} eventType The event type.
- * @return {function(goog.events.BrowserEvent)} Handler
+ * @return {function(Event)} Handler
 */
 ol.pointer.EventSource.prototype.getHandlerForEvent = function(eventType) {
  return this.mapping_[eventType];
--- a/src/ol/pointer/mousesource.js
+++ b/src/ol/pointer/mousesource.js
@@ -50,7 +50,7 @@ ol.pointer.MouseSource = function(dispatcher) {

  /**
   * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
   */
  this.pointerMap = dispatcher.pointerMap;

@@ -107,7 +107,7 @@ ol.pointer.MouseSource.DEDUP_DIST = 25;
 * or detect that the positions are invalid.
 *
 * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 * @return {boolean} True, if the event was generated by a touch.
 */
 ol.pointer.MouseSource.prototype.isEventSimulatedFromTouch_ = function(inEvent) {
@@ -129,12 +129,12 @@ ol.pointer.MouseSource.prototype.isEventSimulatedFromTouch_ = function(inEvent)
 * Creates a copy of the original event that will be used
 * for the fake pointer event.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 * @param {ol.pointer.PointerEventHandler} dispatcher Event handler.
 * @return {Object} The copied event.
 */
 ol.pointer.MouseSource.prepareEvent = function(inEvent, dispatcher) {
-  var e = dispatcher.cloneEvent(inEvent, inEvent.getBrowserEvent());
+  var e = dispatcher.cloneEvent(inEvent, inEvent);

  // forward mouse preventDefault
  var pd = e.preventDefault;
@@ -154,7 +154,7 @@ ol.pointer.MouseSource.prepareEvent = function(inEvent, dispatcher) {
 /**
 * Handler for `mousedown`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MouseSource.prototype.mousedown = function(inEvent) {
  if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -173,7 +173,7 @@ ol.pointer.MouseSource.prototype.mousedown = function(inEvent) {
 /**
 * Handler for `mousemove`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MouseSource.prototype.mousemove = function(inEvent) {
  if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -186,7 +186,7 @@ ol.pointer.MouseSource.prototype.mousemove = function(inEvent) {
 /**
 * Handler for `mouseup`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MouseSource.prototype.mouseup = function(inEvent) {
  if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -204,7 +204,7 @@ ol.pointer.MouseSource.prototype.mouseup = function(inEvent) {
 /**
 * Handler for `mouseover`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MouseSource.prototype.mouseover = function(inEvent) {
  if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -217,7 +217,7 @@ ol.pointer.MouseSource.prototype.mouseover = function(inEvent) {
 /**
 * Handler for `mouseout`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MouseSource.prototype.mouseout = function(inEvent) {
  if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -230,7 +230,7 @@ ol.pointer.MouseSource.prototype.mouseout = function(inEvent) {
 /**
 * Dispatches a `pointercancel` event.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MouseSource.prototype.cancel = function(inEvent) {
  var e = ol.pointer.MouseSource.prepareEvent(inEvent, this.dispatcher);
--- a/src/ol/pointer/mssource.js
+++ b/src/ol/pointer/mssource.js
@@ -53,7 +53,7 @@ ol.pointer.MsSource = function(dispatcher) {

  /**
   * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
   */
  this.pointerMap = dispatcher.pointerMap;

@@ -77,14 +77,14 @@ goog.inherits(ol.pointer.MsSource, ol.pointer.EventSource);
 * for the fake pointer event.
 *
 * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 * @return {Object} The copied event.
 */
 ol.pointer.MsSource.prototype.prepareEvent_ = function(inEvent) {
  var e = inEvent;
-  if (goog.isNumber(inEvent.getBrowserEvent().pointerType)) {
-    e = this.dispatcher.cloneEvent(inEvent, inEvent.getBrowserEvent());
-    e.pointerType = this.POINTER_TYPES[inEvent.getBrowserEvent().pointerType];
+  if (goog.isNumber(inEvent.pointerType)) {
+    e = this.dispatcher.cloneEvent(inEvent, inEvent);
+    e.pointerType = this.POINTER_TYPES[inEvent.pointerType];
  }

  return e;
@@ -103,10 +103,10 @@ ol.pointer.MsSource.prototype.cleanup = function(pointerId) {
 /**
 * Handler for `msPointerDown`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msPointerDown = function(inEvent) {
-  this.pointerMap[inEvent.getBrowserEvent().pointerId.toString()] = inEvent;
+  this.pointerMap[inEvent.pointerId.toString()] = inEvent;
  var e = this.prepareEvent_(inEvent);
  this.dispatcher.down(e, inEvent);
 };
@@ -115,7 +115,7 @@ ol.pointer.MsSource.prototype.msPointerDown = function(inEvent) {
 /**
 * Handler for `msPointerMove`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msPointerMove = function(inEvent) {
  var e = this.prepareEvent_(inEvent);
@@ -126,19 +126,19 @@ ol.pointer.MsSource.prototype.msPointerMove = function(inEvent) {
 /**
 * Handler for `msPointerUp`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msPointerUp = function(inEvent) {
  var e = this.prepareEvent_(inEvent);
  this.dispatcher.up(e, inEvent);
-  this.cleanup(inEvent.getBrowserEvent().pointerId);
+  this.cleanup(inEvent.pointerId);
 };


 /**
 * Handler for `msPointerOut`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msPointerOut = function(inEvent) {
  var e = this.prepareEvent_(inEvent);
@@ -149,7 +149,7 @@ ol.pointer.MsSource.prototype.msPointerOut = function(inEvent) {
 /**
 * Handler for `msPointerOver`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msPointerOver = function(inEvent) {
  var e = this.prepareEvent_(inEvent);
@@ -160,23 +160,23 @@ ol.pointer.MsSource.prototype.msPointerOver = function(inEvent) {
 /**
 * Handler for `msPointerCancel`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msPointerCancel = function(inEvent) {
  var e = this.prepareEvent_(inEvent);
  this.dispatcher.cancel(e, inEvent);
-  this.cleanup(inEvent.getBrowserEvent().pointerId);
+  this.cleanup(inEvent.pointerId);
 };


 /**
 * Handler for `msLostPointerCapture`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msLostPointerCapture = function(inEvent) {
  var e = this.dispatcher.makeEvent('lostpointercapture',
-      inEvent.getBrowserEvent(), inEvent);
+      inEvent, inEvent);
  this.dispatcher.dispatchEvent(e);
 };

@@ -184,10 +184,10 @@ ol.pointer.MsSource.prototype.msLostPointerCapture = function(inEvent) {
 /**
 * Handler for `msGotPointerCapture`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.MsSource.prototype.msGotPointerCapture = function(inEvent) {
  var e = this.dispatcher.makeEvent('gotpointercapture',
-      inEvent.getBrowserEvent(), inEvent);
+      inEvent, inEvent);
  this.dispatcher.dispatchEvent(e);
 };
--- a/src/ol/pointer/nativesource.js
+++ b/src/ol/pointer/nativesource.js
@@ -57,7 +57,7 @@ goog.inherits(ol.pointer.NativeSource, ol.pointer.EventSource);
 /**
 * Handler for `pointerdown`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.pointerDown = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -67,7 +67,7 @@ ol.pointer.NativeSource.prototype.pointerDown = function(inEvent) {
 /**
 * Handler for `pointermove`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.pointerMove = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -77,7 +77,7 @@ ol.pointer.NativeSource.prototype.pointerMove = function(inEvent) {
 /**
 * Handler for `pointerup`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.pointerUp = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -87,7 +87,7 @@ ol.pointer.NativeSource.prototype.pointerUp = function(inEvent) {
 /**
 * Handler for `pointerout`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.pointerOut = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -97,7 +97,7 @@ ol.pointer.NativeSource.prototype.pointerOut = function(inEvent) {
 /**
 * Handler for `pointerover`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.pointerOver = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -107,7 +107,7 @@ ol.pointer.NativeSource.prototype.pointerOver = function(inEvent) {
 /**
 * Handler for `pointercancel`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.pointerCancel = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -117,7 +117,7 @@ ol.pointer.NativeSource.prototype.pointerCancel = function(inEvent) {
 /**
 * Handler for `lostpointercapture`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.lostPointerCapture = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
@@ -127,7 +127,7 @@ ol.pointer.NativeSource.prototype.lostPointerCapture = function(inEvent) {
 /**
 * Handler for `gotpointercapture`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.NativeSource.prototype.gotPointerCapture = function(inEvent) {
  this.dispatcher.fireNativeEvent(inEvent);
--- a/src/ol/pointer/pointerevent.js
+++ b/src/ol/pointer/pointerevent.js
@@ -31,8 +31,8 @@
 goog.provide('ol.pointer.PointerEvent');


-goog.require('goog.events');
-goog.require('goog.events.Event');
+goog.require('ol.events');
+goog.require('ol.events.Event');


 /**
@@ -42,20 +42,20 @@ goog.require('goog.events.Event');
 * touch events and even native pointer events.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @param {string} type The type of the event to create.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} originalEvent The event.
 * @param {Object.<string, ?>=} opt_eventDict An optional dictionary of
 *    initial event properties.
 */
-ol.pointer.PointerEvent = function(type, browserEvent, opt_eventDict) {
+ol.pointer.PointerEvent = function(type, originalEvent, opt_eventDict) {
  goog.base(this, type);

  /**
   * @const
-   * @type {goog.events.BrowserEvent}
+   * @type {Event}
   */
-  this.browserEvent = browserEvent;
+  this.originalEvent = originalEvent;

  var eventDict = opt_eventDict ? opt_eventDict : {};

@@ -186,13 +186,13 @@ ol.pointer.PointerEvent = function(type, browserEvent, opt_eventDict) {
  this.isPrimary = 'isPrimary' in eventDict ? eventDict['isPrimary'] : false;

  // keep the semantics of preventDefault
-  if (browserEvent.preventDefault) {
+  if (originalEvent.preventDefault) {
    this.preventDefault = function() {
-      browserEvent.preventDefault();
+      originalEvent.preventDefault();
    };
  }
 };
-goog.inherits(ol.pointer.PointerEvent, goog.events.Event);
+goog.inherits(ol.pointer.PointerEvent, ol.events.Event);


 /**
--- a/src/ol/pointer/pointereventhandler.js
+++ b/src/ol/pointer/pointereventhandler.js
@@ -31,9 +31,8 @@
 goog.provide('ol.pointer.PointerEventHandler');

 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.BrowserEvent');
-goog.require('goog.events.EventTarget');
+goog.require('ol.events');
+goog.require('ol.events.EventTarget');

 goog.require('ol.has');
 goog.require('ol.pointer.MouseSource');
@@ -45,7 +44,7 @@ goog.require('ol.pointer.TouchSource');

 /**
 * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 * @param {Element|HTMLDocument} element Viewport element.
 */
 ol.pointer.PointerEventHandler = function(element) {
@@ -60,12 +59,12 @@ ol.pointer.PointerEventHandler = function(element) {

  /**
   * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
   */
  this.pointerMap = {};

  /**
-   * @type {Object.<string, function(goog.events.BrowserEvent)>}
+   * @type {Object.<string, function(Event)>}
   * @private
   */
  this.eventMap_ = {};
@@ -78,7 +77,7 @@ ol.pointer.PointerEventHandler = function(element) {

  this.registerSources();
 };
-goog.inherits(ol.pointer.PointerEventHandler, goog.events.EventTarget);
+goog.inherits(ol.pointer.PointerEventHandler, ol.events.EventTarget);


 /**
@@ -159,7 +158,7 @@ ol.pointer.PointerEventHandler.prototype.unregister_ = function() {
 /**
 * Calls the right handler for a new event.
 * @private
- * @param {goog.events.BrowserEvent} inEvent Browser event.
+ * @param {Event} inEvent Browser event.
 */
 ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) {
  var type = inEvent.type;
@@ -177,8 +176,7 @@ ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) {
 */
 ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) {
  events.forEach(function(eventName) {
-    goog.events.listen(this.element_, eventName,
-        this.eventHandler_, false, this);
+    ol.events.listen(this.element_, eventName, this.eventHandler_, this);
  }, this);
 };

@@ -190,8 +188,7 @@ ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) {
 */
 ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) {
  events.forEach(function(e) {
-    goog.events.unlisten(this.element_, e,
-        this.eventHandler_, false, this);
+    ol.events.unlisten(this.element_, e, this.eventHandler_, this);
  }, this);
 };

@@ -199,20 +196,17 @@ ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) {
 /**
 * Returns a snapshot of inEvent, with writable properties.
 *
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} event Browser event.
 * @param {Event|Touch} inEvent An event that contains
 *    properties to copy.
 * @return {Object} An object containing shallow copies of
 *    `inEvent`'s properties.
 */
-ol.pointer.PointerEventHandler.prototype.cloneEvent = function(browserEvent, inEvent) {
+ol.pointer.PointerEventHandler.prototype.cloneEvent = function(event, inEvent) {
  var eventCopy = {}, p;
  for (var i = 0, ii = ol.pointer.CLONE_PROPS.length; i < ii; i++) {
    p = ol.pointer.CLONE_PROPS[i][0];
-    eventCopy[p] =
-        browserEvent[p] ||
-        inEvent[p] ||
-        ol.pointer.CLONE_PROPS[i][1];
+    eventCopy[p] = event[p] || inEvent[p] || ol.pointer.CLONE_PROPS[i][1];
  }

  return eventCopy;
@@ -224,122 +218,110 @@ ol.pointer.PointerEventHandler.prototype.cloneEvent = function(browserEvent, inE

 /**
 * Triggers a 'pointerdown' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.down = function(pointerEventData, browserEvent) {
-  this.fireEvent(ol.pointer.EventType.POINTERDOWN,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.down = function(data, event) {
+  this.fireEvent(ol.pointer.EventType.POINTERDOWN, data, event);
 };


 /**
 * Triggers a 'pointermove' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.move = function(pointerEventData, browserEvent) {
-  this.fireEvent(ol.pointer.EventType.POINTERMOVE,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.move = function(data, event) {
+  this.fireEvent(ol.pointer.EventType.POINTERMOVE, data, event);
 };


 /**
 * Triggers a 'pointerup' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.up = function(pointerEventData, browserEvent) {
-  this.fireEvent(ol.pointer.EventType.POINTERUP,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.up = function(data, event) {
+  this.fireEvent(ol.pointer.EventType.POINTERUP, data, event);
 };


 /**
 * Triggers a 'pointerenter' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.enter = function(pointerEventData, browserEvent) {
-  pointerEventData.bubbles = false;
-  this.fireEvent(ol.pointer.EventType.POINTERENTER,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.enter = function(data, event) {
+  data.bubbles = false;
+  this.fireEvent(ol.pointer.EventType.POINTERENTER, data, event);
 };


 /**
 * Triggers a 'pointerleave' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.leave = function(pointerEventData, browserEvent) {
-  pointerEventData.bubbles = false;
-  this.fireEvent(ol.pointer.EventType.POINTERLEAVE,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.leave = function(data, event) {
+  data.bubbles = false;
+  this.fireEvent(ol.pointer.EventType.POINTERLEAVE, data, event);
 };


 /**
 * Triggers a 'pointerover' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.over = function(pointerEventData, browserEvent) {
-  pointerEventData.bubbles = true;
-  this.fireEvent(ol.pointer.EventType.POINTEROVER,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.over = function(data, event) {
+  data.bubbles = true;
+  this.fireEvent(ol.pointer.EventType.POINTEROVER, data, event);
 };


 /**
 * Triggers a 'pointerout' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.out = function(pointerEventData, browserEvent) {
-  pointerEventData.bubbles = true;
-  this.fireEvent(ol.pointer.EventType.POINTEROUT,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.out = function(data, event) {
+  data.bubbles = true;
+  this.fireEvent(ol.pointer.EventType.POINTEROUT, data, event);
 };


 /**
 * Triggers a 'pointercancel' event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.cancel = function(pointerEventData, browserEvent) {
-  this.fireEvent(ol.pointer.EventType.POINTERCANCEL,
-      pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.cancel = function(data, event) {
+  this.fireEvent(ol.pointer.EventType.POINTERCANCEL, data, event);
 };


 /**
 * Triggers a combination of 'pointerout' and 'pointerleave' events.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.leaveOut = function(pointerEventData, browserEvent) {
-  this.out(pointerEventData, browserEvent);
-  if (!this.contains_(
-      pointerEventData.target,
-      pointerEventData.relatedTarget)) {
-    this.leave(pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.leaveOut = function(data, event) {
+  this.out(data, event);
+  if (!this.contains_(data.target, data.relatedTarget)) {
+    this.leave(data, event);
  }
 };


 /**
 * Triggers a combination of 'pointerover' and 'pointerevents' events.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.enterOver = function(pointerEventData, browserEvent) {
-  this.over(pointerEventData, browserEvent);
-  if (!this.contains_(
-      pointerEventData.target,
-      pointerEventData.relatedTarget)) {
-    this.enter(pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.enterOver = function(data, event) {
+  this.over(data, event);
+  if (!this.contains_(data.target, data.relatedTarget)) {
+    this.enter(data, event);
  }
 };

@@ -362,26 +344,26 @@ ol.pointer.PointerEventHandler.prototype.contains_ = function(container, contain
 // EVENT CREATION AND TRACKING
 /**
 * Creates a new Event of type `inType`, based on the information in
- * `pointerEventData`.
+ * `data`.
 *
 * @param {string} inType A string representing the type of event to create.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 * @return {ol.pointer.PointerEvent} A PointerEvent of type `inType`.
 */
-ol.pointer.PointerEventHandler.prototype.makeEvent = function(inType, pointerEventData, browserEvent) {
-  return new ol.pointer.PointerEvent(inType, browserEvent, pointerEventData);
+ol.pointer.PointerEventHandler.prototype.makeEvent = function(inType, data, event) {
+  return new ol.pointer.PointerEvent(inType, event, data);
 };


 /**
 * Make and dispatch an event in one call.
 * @param {string} inType A string representing the type of event.
- * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Object} data Pointer event data.
+ * @param {Event} event The event.
 */
-ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, pointerEventData, browserEvent) {
-  var e = this.makeEvent(inType, pointerEventData, browserEvent);
+ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, data, event) {
+  var e = this.makeEvent(inType, data, event);
  this.dispatchEvent(e);
 };

@@ -389,11 +371,10 @@ ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, pointerEve
 /**
 * Creates a pointer event from a native pointer event
 * and dispatches this event.
- * @param {goog.events.BrowserEvent} nativeEvent A platform event with a target.
+ * @param {Event} event A platform event with a target.
 */
-ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(nativeEvent) {
-  var e = this.makeEvent(nativeEvent.type, nativeEvent.getBrowserEvent(),
-      nativeEvent);
+ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(event) {
+  var e = this.makeEvent(event.type, event, event);
  this.dispatchEvent(e);
 };

@@ -402,15 +383,12 @@ ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(nativeEvent)
 * Wrap a native mouse event into a pointer event.
 * This proxy method is required for the legacy IE support.
 * @param {string} eventType The pointer event type.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} event The event.
 * @return {ol.pointer.PointerEvent} The wrapped event.
 */
-ol.pointer.PointerEventHandler.prototype.wrapMouseEvent = function(eventType, browserEvent) {
+ol.pointer.PointerEventHandler.prototype.wrapMouseEvent = function(eventType, event) {
  var pointerEvent = this.makeEvent(
-      eventType,
-      ol.pointer.MouseSource.prepareEvent(browserEvent, this),
-      browserEvent
-      );
+      eventType, ol.pointer.MouseSource.prepareEvent(event, this), event);
  return pointerEvent;
 };

--- a/src/ol/pointer/touchsource.js
+++ b/src/ol/pointer/touchsource.js
@@ -54,7 +54,7 @@ ol.pointer.TouchSource = function(dispatcher, mouseSource) {

  /**
   * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
   */
  this.pointerMap = dispatcher.pointerMap;

@@ -176,7 +176,7 @@ ol.pointer.TouchSource.prototype.cancelResetClickCount_ = function() {

 /**
 * @private
- * @param {goog.events.BrowserEvent} browserEvent Browser event
+ * @param {Event} browserEvent Browser event
 * @param {Touch} inTouch Touch event
 * @return {Object} A pointer object.
 */
@@ -212,12 +212,12 @@ ol.pointer.TouchSource.prototype.touchToPointer_ = function(browserEvent, inTouc

 /**
 * @private
- * @param {goog.events.BrowserEvent} inEvent Touch event
- * @param {function(goog.events.BrowserEvent, Object)} inFunction In function.
+ * @param {Event} inEvent Touch event
+ * @param {function(Event, Object)} inFunction In function.
 */
 ol.pointer.TouchSource.prototype.processTouches_ = function(inEvent, inFunction) {
  var touches = Array.prototype.slice.call(
-      inEvent.getBrowserEvent().changedTouches);
+      inEvent.changedTouches);
  var count = touches.length;
  function preventDefault() {
    inEvent.preventDefault();
@@ -260,10 +260,10 @@ ol.pointer.TouchSource.prototype.findTouch_ = function(touchList, searchId) {
 * this "abandoned" touch
 *
 * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.TouchSource.prototype.vacuumTouches_ = function(inEvent) {
-  var touchList = inEvent.getBrowserEvent().touches;
+  var touchList = inEvent.touches;
  // pointerMap.getCount() should be < touchList.length here,
  // as the touchstart has not been processed yet.
  var keys = Object.keys(this.pointerMap);
@@ -293,11 +293,11 @@ ol.pointer.TouchSource.prototype.vacuumTouches_ = function(inEvent) {
 * Handler for `touchstart`, triggers `pointerover`,
 * `pointerenter` and `pointerdown` events.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.TouchSource.prototype.touchstart = function(inEvent) {
  this.vacuumTouches_(inEvent);
-  this.setPrimaryTouch_(inEvent.getBrowserEvent().changedTouches[0]);
+  this.setPrimaryTouch_(inEvent.changedTouches[0]);
  this.dedupSynthMouse_(inEvent);
  this.clickCount_++;
  this.processTouches_(inEvent, this.overDown_);
@@ -306,7 +306,7 @@ ol.pointer.TouchSource.prototype.touchstart = function(inEvent) {

 /**
 * @private
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
 * @param {Object} inPointer The in pointer object.
 */
 ol.pointer.TouchSource.prototype.overDown_ = function(browserEvent, inPointer) {
@@ -324,7 +324,7 @@ ol.pointer.TouchSource.prototype.overDown_ = function(browserEvent, inPointer) {
 /**
 * Handler for `touchmove`.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.TouchSource.prototype.touchmove = function(inEvent) {
  inEvent.preventDefault();
@@ -334,7 +334,7 @@ ol.pointer.TouchSource.prototype.touchmove = function(inEvent) {

 /**
 * @private
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
 * @param {Object} inPointer The in pointer.
 */
 ol.pointer.TouchSource.prototype.moveOverOut_ = function(browserEvent, inPointer) {
@@ -371,7 +371,7 @@ ol.pointer.TouchSource.prototype.moveOverOut_ = function(browserEvent, inPointer
 * Handler for `touchend`, triggers `pointerup`,
 * `pointerout` and `pointerleave` events.
 *
- * @param {goog.events.BrowserEvent} inEvent The event.
+ * @param {Event} inEvent The event.
 */
 ol.pointer.TouchSource.prototype.touchend = function(inEvent) {
  this.dedupSynthMouse_(inEvent);
@@ -381,7 +381,7 @@ ol.pointer.TouchSource.prototype.touchend = function(inEvent) {

 /**
 * @private
- * @param {goog.events.BrowserEvent} browserEvent An event.
+ * @param {Event} browserEvent An event.
 * @param {Object} inPointer The inPointer object.
 */
 ol.pointer.TouchSource.prototype.upOut_ = function(browserEvent, inPointer) {
@@ -396,7 +396,7 @@ ol.pointer.TouchSource.prototype.upOut_ = function(browserEvent, inPointer) {
 * Handler for `touchcancel`, triggers `pointercancel`,
 * `pointerout` and `pointerleave` events.
 *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.TouchSource.prototype.touchcancel = function(inEvent) {
  this.processTouches_(inEvent, this.cancelOut_);
@@ -405,7 +405,7 @@ ol.pointer.TouchSource.prototype.touchcancel = function(inEvent) {

 /**
 * @private
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
 * @param {Object} inPointer The in pointer.
 */
 ol.pointer.TouchSource.prototype.cancelOut_ = function(browserEvent, inPointer) {
@@ -430,11 +430,11 @@ ol.pointer.TouchSource.prototype.cleanUpPointer_ = function(inPointer) {
 * Prevent synth mouse events from creating pointer events.
 *
 * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
 */
 ol.pointer.TouchSource.prototype.dedupSynthMouse_ = function(inEvent) {
  var lts = this.mouseSource.lastTouches;
-  var t = inEvent.getBrowserEvent().changedTouches[0];
+  var t = inEvent.changedTouches[0];
  // only the primary finger will synth mouse events
  if (this.isPrimaryTouch_(t)) {
    // remember x/y of last touch
--- a/src/ol/render/renderevent.js
+++ b/src/ol/render/renderevent.js
@@ -1,7 +1,7 @@
 goog.provide('ol.render.Event');
 goog.provide('ol.render.EventType');

-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.render.VectorContext');


@@ -29,7 +29,7 @@ ol.render.EventType = {

 /**
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.render.Event}
 * @param {ol.render.EventType} type Type.
 * @param {Object=} opt_target Target.
@@ -75,4 +75,4 @@ ol.render.Event = function(
  this.glContext = opt_glContext;

 };
-goog.inherits(ol.render.Event, goog.events.Event);
+goog.inherits(ol.render.Event, ol.events.Event);
--- a/src/ol/render/vector.js
+++ b/src/ol/render/vector.js
@@ -69,7 +69,7 @@ ol.renderer.vector.renderCircleGeometry_ = function(replayGroup, geometry, style
 * @param {ol.Feature|ol.render.Feature} feature Feature.
 * @param {ol.style.Style} style Style.
 * @param {number} squaredTolerance Squared tolerance.
- * @param {function(this: T, goog.events.Event)} listener Listener function.
+ * @param {function(this: T, ol.events.Event)} listener Listener function.
 * @param {T} thisArg Value to use as `this` when executing `listener`.
 * @return {boolean} `true` if style is loading.
 * @template T
--- a/src/ol/renderer/canvas/canvasvectorlayerrenderer.js
+++ b/src/ol/renderer/canvas/canvasvectorlayerrenderer.js
@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.canvas.VectorLayer');

 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.ViewHint');
 goog.require('ol.dom');
 goog.require('ol.extent');
@@ -181,7 +181,7 @@ ol.renderer.canvas.VectorLayer.prototype.forEachFeatureAtCoordinate = function(c

 /**
 * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
 * @private
 */
 ol.renderer.canvas.VectorLayer.prototype.handleStyleImageChange_ = function(event) {
--- a/src/ol/renderer/canvas/canvasvectortilelayerrenderer.js
+++ b/src/ol/renderer/canvas/canvasvectortilelayerrenderer.js
@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.canvas.VectorTileLayer');

 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.vec.Mat4');
 goog.require('ol.Feature');
 goog.require('ol.TileRange');
@@ -364,7 +364,7 @@ ol.renderer.canvas.VectorTileLayer.prototype.forEachFeatureAtCoordinate = functi

 /**
 * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
 * @private
 */
 ol.renderer.canvas.VectorTileLayer.prototype.handleStyleImageChange_ = function(event) {
--- a/src/ol/renderer/dom/dommaprenderer.js
+++ b/src/ol/renderer/dom/dommaprenderer.js
@@ -2,9 +2,9 @@ goog.provide('ol.renderer.dom.Map');

 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('goog.style');
 goog.require('goog.vec.Mat4');
 goog.require('ol');
@@ -68,8 +68,8 @@ ol.renderer.dom.Map = function(container, map) {
  style.height = '100%';

  // prevent the img context menu on mobile devices
-  goog.events.listen(this.layersPane_, goog.events.EventType.TOUCHSTART,
-      goog.events.Event.preventDefault);
+  ol.events.listen(this.layersPane_, ol.events.EventType.TOUCHSTART,
+      ol.events.Event.preventDefault);

  goog.dom.insertChildAt(container, this.layersPane_, 0);

--- a/src/ol/renderer/dom/domvectorlayerrenderer.js
+++ b/src/ol/renderer/dom/domvectorlayerrenderer.js
@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.dom.VectorLayer');

 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.vec.Mat4');
 goog.require('ol.ViewHint');
 goog.require('ol.dom');
@@ -202,7 +202,7 @@ ol.renderer.dom.VectorLayer.prototype.forEachFeatureAtCoordinate = function(coor

 /**
 * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
 * @private
 */
 ol.renderer.dom.VectorLayer.prototype.handleStyleImageChange_ = function(event) {
--- a/src/ol/renderer/layerrenderer.js
+++ b/src/ol/renderer/layerrenderer.js
@@ -1,8 +1,8 @@
 goog.provide('ol.renderer.Layer');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.functions');
 goog.require('ol');
 goog.require('ol.ImageState');
@@ -121,7 +121,7 @@ ol.renderer.Layer.prototype.getLayer = function() {

 /**
 * Handle changes in image state.
- * @param {goog.events.Event} event Image change event.
+ * @param {ol.events.Event} event Image change event.
 * @private
 */
 ol.renderer.Layer.prototype.handleImageChange_ = function(event) {
@@ -149,8 +149,8 @@ ol.renderer.Layer.prototype.loadImage = function(image) {
    goog.asserts.assert(imageState == ol.ImageState.IDLE ||
        imageState == ol.ImageState.LOADING,
        'imageState is "idle" or "loading"');
-    goog.events.listen(image, goog.events.EventType.CHANGE,
-        this.handleImageChange_, false, this);
+    ol.events.listen(image, ol.events.EventType.CHANGE,
+        this.handleImageChange_, this);
  }
  if (imageState == ol.ImageState.IDLE) {
    image.load();
--- a/src/ol/renderer/maprenderer.js
+++ b/src/ol/renderer/maprenderer.js
@@ -4,8 +4,8 @@ goog.provide('ol.renderer.Map');
 goog.require('goog.Disposable');
 goog.require('goog.asserts');
 goog.require('goog.dispose');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.functions');
 goog.require('goog.object');
 goog.require('goog.vec.Mat4');
@@ -55,7 +55,7 @@ ol.renderer.Map = function(container, map) {

  /**
   * @private
-   * @type {Object.<string, goog.events.Key>}
+   * @type {Object.<string, ol.events.Key>}
   */
  this.layerRendererListeners_ = {};

@@ -255,9 +255,8 @@ ol.renderer.Map.prototype.getLayerRenderer = function(layer) {
  } else {
    var layerRenderer = this.createLayerRenderer(layer);
    this.layerRenderers_[layerKey] = layerRenderer;
-    this.layerRendererListeners_[layerKey] = goog.events.listen(layerRenderer,
-        goog.events.EventType.CHANGE, this.handleLayerRendererChange_,
-        false, this);
+    this.layerRendererListeners_[layerKey] = ol.events.listen(layerRenderer,
+        ol.events.EventType.CHANGE, this.handleLayerRendererChange_, this);

    return layerRenderer;
  }
@@ -321,7 +320,7 @@ ol.renderer.Map.prototype.removeLayerRendererByKey_ = function(layerKey) {

  goog.asserts.assert(layerKey in this.layerRendererListeners_,
      'given layerKey (%s) exists in layerRendererListeners', layerKey);
-  goog.events.unlistenByKey(this.layerRendererListeners_[layerKey]);
+  ol.events.unlistenByKey(this.layerRendererListeners_[layerKey]);
  delete this.layerRendererListeners_[layerKey];

  return layerRenderer;
--- a/src/ol/renderer/webgl/webglmaprenderer.js
+++ b/src/ol/renderer/webgl/webglmaprenderer.js
@@ -4,8 +4,8 @@ goog.provide('ol.renderer.webgl.Map');

 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
-goog.require('goog.events.Event');
+goog.require('ol.events');
+goog.require('ol.events.Event');
 goog.require('goog.log');
 goog.require('goog.log.Logger');
 goog.require('goog.object');
@@ -106,10 +106,10 @@ ol.renderer.webgl.Map = function(container, map) {
   */
  this.context_ = new ol.webgl.Context(this.canvas_, this.gl_);

-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
-      this.handleWebGLContextLost, false, this);
-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
-      this.handleWebGLContextRestored, false, this);
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
+      this.handleWebGLContextLost, this);
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
+      this.handleWebGLContextRestored, this);

  /**
   * @private
@@ -377,7 +377,7 @@ ol.renderer.webgl.Map.prototype.getType = function() {


 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @protected
 */
 ol.renderer.webgl.Map.prototype.handleWebGLContextLost = function(event) {
--- a/src/ol/renderer/webgl/webglvectorlayerrenderer.js
+++ b/src/ol/renderer/webgl/webglvectorlayerrenderer.js
@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.webgl.VectorLayer');

 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.ViewHint');
 goog.require('ol.extent');
 goog.require('ol.layer.Vector');
@@ -169,7 +169,7 @@ ol.renderer.webgl.VectorLayer.prototype.forEachLayerAtPixel = function(pixel, fr

 /**
 * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
 * @private
 */
 ol.renderer.webgl.VectorLayer.prototype.handleStyleImageChange_ = function(event) {
--- a/src/ol/reproj/image.js
+++ b/src/ol/reproj/image.js
@@ -2,8 +2,8 @@ goog.provide('ol.reproj.Image');
 goog.provide('ol.reproj.ImageFunctionType');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.ImageBase');
 goog.require('ol.ImageState');
 goog.require('ol.extent');
@@ -102,7 +102,7 @@ ol.reproj.Image = function(sourceProj, targetProj,

  /**
   * @private
-   * @type {goog.events.Key}
+   * @type {?ol.events.Key}
   */
  this.sourceListenerKey_ = null;

@@ -183,15 +183,15 @@ ol.reproj.Image.prototype.load = function() {
        sourceState == ol.ImageState.ERROR) {
      this.reproject_();
    } else {
-      this.sourceListenerKey_ = this.sourceImage_.listen(
-          goog.events.EventType.CHANGE, function(e) {
+      this.sourceListenerKey_ = ol.events.listen(this.sourceImage_,
+          ol.events.EventType.CHANGE, function(e) {
            var sourceState = this.sourceImage_.getState();
            if (sourceState == ol.ImageState.LOADED ||
                sourceState == ol.ImageState.ERROR) {
              this.unlistenSource_();
              this.reproject_();
            }
-          }, false, this);
+          }, this);
      this.sourceImage_.load();
    }
  }
@@ -204,6 +204,6 @@ ol.reproj.Image.prototype.load = function() {
 ol.reproj.Image.prototype.unlistenSource_ = function() {
  goog.asserts.assert(this.sourceListenerKey_,
      'this.sourceListenerKey_ should not be null');
-  goog.events.unlistenByKey(this.sourceListenerKey_);
+  ol.events.unlistenByKey(this.sourceListenerKey_);
  this.sourceListenerKey_ = null;
 };
--- a/src/ol/reproj/tile.js
+++ b/src/ol/reproj/tile.js
@@ -2,8 +2,8 @@ goog.provide('ol.reproj.Tile');
 goog.provide('ol.reproj.TileFunctionType');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.math');
 goog.require('goog.object');
 goog.require('ol.Tile');
@@ -97,7 +97,7 @@ ol.reproj.Tile = function(sourceProj, sourceTileGrid,

  /**
   * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   */
  this.sourcesListenerKeys_ = null;

@@ -297,13 +297,13 @@ ol.reproj.Tile.prototype.load = function() {
        leftToLoad++;

        var sourceListenKey;
-        sourceListenKey = tile.listen(goog.events.EventType.CHANGE,
+        sourceListenKey = ol.events.listen(tile, ol.events.EventType.CHANGE,
            function(e) {
              var state = tile.getState();
              if (state == ol.TileState.LOADED ||
                  state == ol.TileState.ERROR ||
                  state == ol.TileState.EMPTY) {
-                goog.events.unlistenByKey(sourceListenKey);
+                ol.events.unlistenByKey(sourceListenKey);
                leftToLoad--;
                goog.asserts.assert(leftToLoad >= 0,
                    'leftToLoad should not be negative');
@@ -312,7 +312,7 @@ ol.reproj.Tile.prototype.load = function() {
                  this.reproject_();
                }
              }
-            }, false, this);
+            }, this);
        this.sourcesListenerKeys_.push(sourceListenKey);
      }
    }, this);
@@ -337,6 +337,6 @@ ol.reproj.Tile.prototype.load = function() {
 ol.reproj.Tile.prototype.unlistenSources_ = function() {
  goog.asserts.assert(this.sourcesListenerKeys_,
      'this.sourcesListenerKeys_ should not be null');
-  this.sourcesListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.sourcesListenerKeys_.forEach(ol.events.unlistenByKey);
  this.sourcesListenerKeys_ = null;
 };
--- a/src/ol/source/bingmapssource.js
+++ b/src/ol/source/bingmapssource.js
@@ -1,12 +1,11 @@
 goog.provide('ol.source.BingMaps');

-goog.require('goog.Uri');
 goog.require('goog.asserts');
-goog.require('goog.net.Jsonp');
 goog.require('ol.Attribution');
 goog.require('ol.TileRange');
 goog.require('ol.TileUrlFunction');
 goog.require('ol.extent');
+goog.require('ol.net');
 goog.require('ol.proj');
 goog.require('ol.source.State');
 goog.require('ol.source.TileImage');
@@ -46,16 +45,12 @@ ol.source.BingMaps = function(options) {
   */
  this.maxZoom_ = options.maxZoom !== undefined ? options.maxZoom : -1;

-  var uri = new goog.Uri(
-      'https://dev.virtualearth.net/REST/v1/Imagery/Metadata/' +
-      options.imagerySet);
+  var url = 'https://dev.virtualearth.net/REST/v1/Imagery/Metadata/' +
+      options.imagerySet +
+      '?uriScheme=https&include=ImageryProviders&key=' + options.key;

-  var jsonp = new goog.net.Jsonp(uri, 'jsonp');
-  jsonp.send({
-    'include': 'ImageryProviders',
-    'uriScheme': 'https',
-    'key': options.key
-  }, this.handleImageryMetadataResponse.bind(this));
+  ol.net.jsonp(url, this.handleImageryMetadataResponse.bind(this), undefined,
+      'jsonp');

 };
 goog.inherits(ol.source.BingMaps, ol.source.TileImage);
--- a/src/ol/source/clustersource.js
+++ b/src/ol/source/clustersource.js
@@ -4,7 +4,7 @@
 goog.provide('ol.source.Cluster');

 goog.require('goog.asserts');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Feature');
 goog.require('ol.coordinate');
@@ -55,7 +55,7 @@ ol.source.Cluster = function(options) {
   */
  this.source_ = options.source;

-  this.source_.on(goog.events.EventType.CHANGE,
+  this.source_.on(ol.events.EventType.CHANGE,
      ol.source.Cluster.prototype.onSourceChange_, this);
 };
 goog.inherits(ol.source.Cluster, ol.source.Vector);
--- a/src/ol/source/imagemapguidesource.js
+++ b/src/ol/source/imagemapguidesource.js
@@ -1,7 +1,7 @@
 goog.provide('ol.source.ImageMapGuide');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.uri.utils');
 goog.require('ol.Image');
@@ -143,8 +143,8 @@ ol.source.ImageMapGuide.prototype.getImageInternal = function(extent, resolution
    image = new ol.Image(extent, resolution, pixelRatio,
        this.getAttributions(), imageUrl, this.crossOrigin_,
        this.imageLoadFunction_);
-    goog.events.listen(image, goog.events.EventType.CHANGE,
-        this.handleImageChange, false, this);
+    ol.events.listen(image, ol.events.EventType.CHANGE,
+        this.handleImageChange, this);
  } else {
    image = null;
  }
--- a/src/ol/source/imagesource.js
+++ b/src/ol/source/imagesource.js
@@ -2,7 +2,7 @@ goog.provide('ol.source.Image');
 goog.provide('ol.source.ImageEvent');

 goog.require('goog.asserts');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.Attribution');
 goog.require('ol.ImageState');
 goog.require('ol.array');
@@ -153,7 +153,7 @@ ol.source.Image.prototype.getImageInternal = goog.abstractMethod;

 /**
 * Handle image change events.
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @protected
 */
 ol.source.Image.prototype.handleImageChange = function(event) {
@@ -197,7 +197,7 @@ ol.source.Image.defaultImageLoadFunction = function(image, src) {
 * type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.source.ImageEvent}
 * @param {string} type Type.
 * @param {ol.Image} image The image.
@@ -214,7 +214,7 @@ ol.source.ImageEvent = function(type, image) {
  this.image = image;

 };
-goog.inherits(ol.source.ImageEvent, goog.events.Event);
+goog.inherits(ol.source.ImageEvent, ol.events.Event);


 /**
--- a/src/ol/source/imagestaticsource.js
+++ b/src/ol/source/imagestaticsource.js
@@ -1,7 +1,7 @@
 goog.provide('ol.source.ImageStatic');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.Image');
 goog.require('ol.ImageLoadFunctionType');
 goog.require('ol.ImageState');
@@ -52,8 +52,8 @@ ol.source.ImageStatic = function(options) {
   */
  this.imageSize_ = options.imageSize ? options.imageSize : null;

-  goog.events.listen(this.image_, goog.events.EventType.CHANGE,
-      this.handleImageChange, false, this);
+  ol.events.listen(this.image_, ol.events.EventType.CHANGE,
+      this.handleImageChange, this);

 };
 goog.inherits(ol.source.ImageStatic, ol.source.Image);
--- a/src/ol/source/imagevectorsource.js
+++ b/src/ol/source/imagevectorsource.js
@@ -1,8 +1,8 @@
 goog.provide('ol.source.ImageVector');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.vec.Mat4');
 goog.require('ol.dom');
 goog.require('ol.extent');
@@ -89,8 +89,8 @@ ol.source.ImageVector = function(options) {

  this.setStyle(options.style);

-  goog.events.listen(this.source_, goog.events.EventType.CHANGE,
-      this.handleSourceChange_, undefined, this);
+  ol.events.listen(this.source_, ol.events.EventType.CHANGE,
+      this.handleSourceChange_, this);

 };
 goog.inherits(ol.source.ImageVector, ol.source.ImageCanvas);
@@ -226,7 +226,7 @@ ol.source.ImageVector.prototype.getTransform_ = function(center, resolution, pix

 /**
 * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
 * @private
 */
 ol.source.ImageVector.prototype.handleImageChange_ = function(event) {
--- a/src/ol/source/imagewmssource.js
+++ b/src/ol/source/imagewmssource.js
@@ -3,8 +3,8 @@
 goog.provide('ol.source.ImageWMS');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.string');
 goog.require('goog.uri.utils');
@@ -241,8 +241,8 @@ ol.source.ImageWMS.prototype.getImageInternal = function(extent, resolution, pix

  this.renderedRevision_ = this.getRevision();

-  goog.events.listen(this.image_, goog.events.EventType.CHANGE,
-      this.handleImageChange, false, this);
+  ol.events.listen(this.image_, ol.events.EventType.CHANGE,
+      this.handleImageChange, this);

  return this.image_;

--- a/src/ol/source/rastersource.js
+++ b/src/ol/source/rastersource.js
@@ -3,9 +3,9 @@ goog.provide('ol.source.RasterEvent');
 goog.provide('ol.source.RasterEventType');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.vec.Mat4');
 goog.require('ol.ImageCanvas');
@@ -62,8 +62,8 @@ ol.source.Raster = function(options) {
  this.renderers_ = ol.source.Raster.createRenderers_(options.sources);

  for (var r = 0, rr = this.renderers_.length; r < rr; ++r) {
-    goog.events.listen(this.renderers_[r], goog.events.EventType.CHANGE,
-        this.changed, false, this);
+    ol.events.listen(this.renderers_[r], ol.events.EventType.CHANGE,
+        this.changed, this);
  }

  /**
@@ -474,7 +474,7 @@ ol.source.Raster.RenderedState;
 * type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.source.RasterEvent}
 * @param {string} type Type.
 * @param {olx.FrameState} frameState The frame state.
@@ -506,7 +506,7 @@ ol.source.RasterEvent = function(type, frameState, data) {
  this.data = data;

 };
-goog.inherits(ol.source.RasterEvent, goog.events.Event);
+goog.inherits(ol.source.RasterEvent, ol.events.Event);


 /**
--- a/src/ol/source/tileimagesource.js
+++ b/src/ol/source/tileimagesource.js
@@ -1,8 +1,8 @@
 goog.provide('ol.source.TileImage');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.ImageTile');
 goog.require('ol.TileCache');
@@ -197,8 +197,8 @@ ol.source.TileImage.prototype.createTile_ = function(z, x, y, pixelRatio, projec
      this.crossOrigin,
      this.tileLoadFunction);
  tile.key = key;
-  goog.events.listen(tile, goog.events.EventType.CHANGE,
-      this.handleTileChange, false, this);
+  ol.events.listen(tile, ol.events.EventType.CHANGE,
+      this.handleTileChange, this);
  return tile;
 };

--- a/src/ol/source/tilejsonsource.js
+++ b/src/ol/source/tilejsonsource.js
@@ -8,15 +8,11 @@ goog.provide('ol.source.TileJSON');
 goog.provide('ol.tilejson');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.net.CorsXmlHttpFactory');
-goog.require('goog.net.EventType');
-goog.require('goog.net.Jsonp');
-goog.require('goog.net.XhrIo');
 goog.require('ol.Attribution');
 goog.require('ol.TileRange');
 goog.require('ol.TileUrlFunction');
 goog.require('ol.extent');
+goog.require('ol.net');
 goog.require('ol.proj');
 goog.require('ol.source.State');
 goog.require('ol.source.TileImage');
@@ -44,21 +40,20 @@ ol.source.TileJSON = function(options) {
  });

  if (options.jsonp) {
-    var request = new goog.net.Jsonp(options.url);
-    request.send(undefined, this.handleTileJSONResponse.bind(this),
+    ol.net.jsonp(options.url, this.handleTileJSONResponse.bind(this),
        this.handleTileJSONError.bind(this));
  } else {
-    var xhr = new goog.net.XhrIo(new goog.net.CorsXmlHttpFactory());
-    goog.events.listen(xhr, goog.net.EventType.COMPLETE, function(e) {
-      if (xhr.isSuccess()) {
-        var response = /** @type {TileJSON} */(xhr.getResponseJson());
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', options.url, true);
+    xhr.onload = function(e) {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        var response = /** @type {TileJSON} */(JSON.parse(xhr.responseText));
        this.handleTileJSONResponse(response);
      } else {
        this.handleTileJSONError();
      }
-      xhr.dispose();
-    }, false, this);
-    xhr.send(options.url);
+    }.bind(this);
+    xhr.send();
  }

 };
--- a/src/ol/source/tilesource.js
+++ b/src/ol/source/tilesource.js
@@ -3,7 +3,7 @@ goog.provide('ol.source.TileEvent');
 goog.provide('ol.source.TileOptions');

 goog.require('goog.asserts');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol');
 goog.require('ol.Attribution');
 goog.require('ol.Extent');
@@ -305,7 +305,7 @@ ol.source.Tile.prototype.useTile = ol.nullFunction;
 * type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.source.TileEvent}
 * @param {string} type Type.
 * @param {ol.Tile} tile The tile.
@@ -322,7 +322,7 @@ ol.source.TileEvent = function(type, tile) {
  this.tile = tile;

 };
-goog.inherits(ol.source.TileEvent, goog.events.Event);
+goog.inherits(ol.source.TileEvent, ol.events.Event);


 /**
--- a/src/ol/source/tileutfgridsource.js
+++ b/src/ol/source/tileutfgridsource.js
@@ -2,14 +2,14 @@ goog.provide('ol.source.TileUTFGrid');

 goog.require('goog.asserts');
 goog.require('goog.async.nextTick');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
-goog.require('goog.net.Jsonp');
 goog.require('ol.Attribution');
 goog.require('ol.Tile');
 goog.require('ol.TileState');
 goog.require('ol.TileUrlFunction');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.extent');
+goog.require('ol.net');
 goog.require('ol.proj');
 goog.require('ol.source.State');
 goog.require('ol.source.Tile');
@@ -49,8 +49,7 @@ ol.source.TileUTFGrid = function(options) {
   */
  this.template_ = undefined;

-  var request = new goog.net.Jsonp(options.url);
-  request.send(undefined, this.handleTileJSONResponse.bind(this));
+  ol.net.jsonp(options.url, this.handleTileJSONResponse.bind(this));
 };
 goog.inherits(ol.source.TileUTFGrid, ol.source.Tile);

@@ -307,9 +306,9 @@ ol.source.TileUTFGridTile_.prototype.getData = function(coordinate) {
 */
 ol.source.TileUTFGridTile_.prototype.forDataAtCoordinate = function(coordinate, callback, opt_this, opt_request) {
  if (this.state == ol.TileState.IDLE && opt_request === true) {
-    goog.events.listenOnce(this, goog.events.EventType.CHANGE, function(e) {
+    ol.events.listenOnce(this, ol.events.EventType.CHANGE, function(e) {
      callback.call(opt_this, this.getData(coordinate));
-    }, false, this);
+    }, this);
    this.loadInternal_();
  } else {
    if (opt_request === true) {
@@ -360,9 +359,8 @@ ol.source.TileUTFGridTile_.prototype.handleLoad_ = function(json) {
 ol.source.TileUTFGridTile_.prototype.loadInternal_ = function() {
  if (this.state == ol.TileState.IDLE) {
    this.state = ol.TileState.LOADING;
-    var request = new goog.net.Jsonp(this.src_);
-    request.send(undefined, this.handleLoad_.bind(this),
-                 this.handleError_.bind(this));
+    ol.net.jsonp(this.src_, this.handleLoad_.bind(this),
+        this.handleError_.bind(this));
  }
 };

--- a/src/ol/source/urltilesource.js
+++ b/src/ol/source/urltilesource.js
@@ -1,6 +1,6 @@
 goog.provide('ol.source.UrlTile');

-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.TileLoadFunctionType');
 goog.require('ol.TileState');
 goog.require('ol.TileUrlFunction');
@@ -126,7 +126,7 @@ ol.source.UrlTile.prototype.getUrls = function() {

 /**
 * Handle tile change events.
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @protected
 */
 ol.source.UrlTile.prototype.handleTileChange = function(event) {
--- a/src/ol/source/vectorsource.js
+++ b/src/ol/source/vectorsource.js
@@ -6,9 +6,9 @@ goog.provide('ol.source.VectorEvent');
 goog.provide('ol.source.VectorEventType');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Collection');
@@ -146,7 +146,7 @@ ol.source.Vector = function(opt_options) {

  /**
   * @private
-   * @type {Object.<string, Array.<goog.events.Key>>}
+   * @type {Object.<string, Array.<ol.events.Key>>}
   */
  this.featureChangeKeys_ = {};

@@ -228,12 +228,10 @@ ol.source.Vector.prototype.setupChangeEvents_ = function(featureKey, feature) {
  goog.asserts.assert(!(featureKey in this.featureChangeKeys_),
      'key (%s) not yet registered in featureChangeKey', featureKey);
  this.featureChangeKeys_[featureKey] = [
-    goog.events.listen(feature,
-        goog.events.EventType.CHANGE,
-        this.handleFeatureChange_, false, this),
-    goog.events.listen(feature,
-        ol.ObjectEventType.PROPERTYCHANGE,
-        this.handleFeatureChange_, false, this)
+    ol.events.listen(feature, ol.events.EventType.CHANGE,
+        this.handleFeatureChange_, this),
+    ol.events.listen(feature, ol.ObjectEventType.PROPERTYCHANGE,
+        this.handleFeatureChange_, this)
  ];
 };

@@ -327,7 +325,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
  goog.asserts.assert(!this.featuresCollection_,
      'bindFeaturesCollection can only be called once');
  var modifyingCollection = false;
-  goog.events.listen(this, ol.source.VectorEventType.ADDFEATURE,
+  ol.events.listen(this, ol.source.VectorEventType.ADDFEATURE,
      function(evt) {
        if (!modifyingCollection) {
          modifyingCollection = true;
@@ -335,7 +333,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
          modifyingCollection = false;
        }
      });
-  goog.events.listen(this, ol.source.VectorEventType.REMOVEFEATURE,
+  ol.events.listen(this, ol.source.VectorEventType.REMOVEFEATURE,
      function(evt) {
        if (!modifyingCollection) {
          modifyingCollection = true;
@@ -343,7 +341,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
          modifyingCollection = false;
        }
      });
-  goog.events.listen(collection, ol.CollectionEventType.ADD,
+  ol.events.listen(collection, ol.CollectionEventType.ADD,
      function(evt) {
        if (!modifyingCollection) {
          var feature = evt.element;
@@ -352,8 +350,8 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
          this.addFeature(feature);
          modifyingCollection = false;
        }
-      }, false, this);
-  goog.events.listen(collection, ol.CollectionEventType.REMOVE,
+      }, this);
+  ol.events.listen(collection, ol.CollectionEventType.REMOVE,
      function(evt) {
        if (!modifyingCollection) {
          var feature = evt.element;
@@ -362,7 +360,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
          this.removeFeature(feature);
          modifyingCollection = false;
        }
-      }, false, this);
+      }, this);
  this.featuresCollection_ = collection;
 };

@@ -376,7 +374,7 @@ ol.source.Vector.prototype.clear = function(opt_fast) {
  if (opt_fast) {
    for (var featureId in this.featureChangeKeys_) {
      var keys = this.featureChangeKeys_[featureId];
-      keys.forEach(goog.events.unlistenByKey);
+      keys.forEach(ol.events.unlistenByKey);
    }
    if (!this.featuresCollection_) {
      this.featureChangeKeys_ = {};
@@ -680,7 +678,7 @@ ol.source.Vector.prototype.getFeatureById = function(id) {


 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @private
 */
 ol.source.Vector.prototype.handleFeatureChange_ = function(event) {
@@ -816,7 +814,7 @@ ol.source.Vector.prototype.removeFeatureInternal = function(feature) {
  var featureKey = goog.getUid(feature).toString();
  goog.asserts.assert(featureKey in this.featureChangeKeys_,
      'featureKey exists in featureChangeKeys');
-  this.featureChangeKeys_[featureKey].forEach(goog.events.unlistenByKey);
+  this.featureChangeKeys_[featureKey].forEach(ol.events.unlistenByKey);
  delete this.featureChangeKeys_[featureKey];
  var id = feature.getId();
  if (id !== undefined) {
@@ -855,7 +853,7 @@ ol.source.Vector.prototype.removeFromIdIndex_ = function(feature) {
 * type.
 *
 * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
 * @implements {oli.source.VectorEvent}
 * @param {string} type Type.
 * @param {ol.Feature=} opt_feature Feature.
@@ -872,4 +870,4 @@ ol.source.VectorEvent = function(type, opt_feature) {
  this.feature = opt_feature;

 };
-goog.inherits(ol.source.VectorEvent, goog.events.Event);
+goog.inherits(ol.source.VectorEvent, ol.events.Event);
--- a/src/ol/source/vectortilesource.js
+++ b/src/ol/source/vectortilesource.js
@@ -1,9 +1,9 @@
 goog.provide('ol.source.VectorTile');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
 goog.require('ol.TileState');
 goog.require('ol.VectorTile');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.featureloader');
 goog.require('ol.source.UrlTile');

@@ -79,8 +79,8 @@ ol.source.VectorTile.prototype.getTile = function(z, x, y, pixelRatio, projectio
        tileUrl !== undefined ? ol.TileState.IDLE : ol.TileState.EMPTY,
        tileUrl !== undefined ? tileUrl : '',
        this.format_, this.tileLoadFunction);
-    goog.events.listen(tile, goog.events.EventType.CHANGE,
-        this.handleTileChange, false, this);
+    ol.events.listen(tile, ol.events.EventType.CHANGE,
+        this.handleTileChange, this);

    this.tileCache.set(tileCoordKey, tile);
    return tile;
--- a/src/ol/style/iconstyle.js
+++ b/src/ol/style/iconstyle.js
@@ -4,9 +4,9 @@ goog.provide('ol.style.IconImageCache');
 goog.provide('ol.style.IconOrigin');

 goog.require('goog.asserts');
-goog.require('goog.events');
-goog.require('goog.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventTarget');
+goog.require('ol.events.EventType');
 goog.require('ol.color');
 goog.require('ol.dom');
 goog.require('ol.style.Image');
@@ -345,8 +345,8 @@ ol.style.Icon.prototype.getSize = function() {
 * @inheritDoc
 */
 ol.style.Icon.prototype.listenImageChange = function(listener, thisArg) {
-  return goog.events.listen(this.iconImage_, goog.events.EventType.CHANGE,
-      listener, false, thisArg);
+  return ol.events.listen(this.iconImage_, ol.events.EventType.CHANGE,
+      listener, thisArg);
 };


@@ -366,8 +366,8 @@ ol.style.Icon.prototype.load = function() {
 * @inheritDoc
 */
 ol.style.Icon.prototype.unlistenImageChange = function(listener, thisArg) {
-  goog.events.unlisten(this.iconImage_, goog.events.EventType.CHANGE,
-      listener, false, thisArg);
+  ol.events.unlisten(this.iconImage_, ol.events.EventType.CHANGE,
+      listener, thisArg);
 };


@@ -379,7 +379,7 @@ ol.style.Icon.prototype.unlistenImageChange = function(listener, thisArg) {
 * @param {?string} crossOrigin Cross origin.
 * @param {ol.style.ImageState} imageState Image state.
 * @param {ol.Color} color Color.
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 * @private
 */
 ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState,
@@ -419,7 +419,7 @@ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState,

  /**
   * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
   */
  this.imageListenerKeys_ = null;

@@ -451,7 +451,7 @@ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState,
  }

 };
-goog.inherits(ol.style.IconImage_, goog.events.EventTarget);
+goog.inherits(ol.style.IconImage_, ol.events.EventTarget);


 /**
@@ -494,7 +494,7 @@ ol.style.IconImage_.prototype.determineTainting_ = function() {
 * @private
 */
 ol.style.IconImage_.prototype.dispatchChangeEvent_ = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };


@@ -585,10 +585,10 @@ ol.style.IconImage_.prototype.load = function() {
        'no listener keys existing');
    this.imageState_ = ol.style.ImageState.LOADING;
    this.imageListenerKeys_ = [
-      goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
-          this.handleImageError_, false, this),
-      goog.events.listenOnce(this.image_, goog.events.EventType.LOAD,
-          this.handleImageLoad_, false, this)
+      ol.events.listenOnce(this.image_, ol.events.EventType.ERROR,
+          this.handleImageError_, this),
+      ol.events.listenOnce(this.image_, ol.events.EventType.LOAD,
+          this.handleImageLoad_, this)
    ];
    try {
      this.image_.src = this.src_;
@@ -639,7 +639,7 @@ ol.style.IconImage_.prototype.replaceColor_ = function() {
 ol.style.IconImage_.prototype.unlistenImage_ = function() {
  goog.asserts.assert(this.imageListenerKeys_,
      'we must have listeners registered');
-  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(ol.events.unlistenByKey);
  this.imageListenerKeys_ = null;
 };

@@ -703,7 +703,7 @@ ol.style.IconImageCache.prototype.expire = function() {
    var key, iconImage;
    for (key in this.cache_) {
      iconImage = this.cache_[key];
-      if ((i++ & 3) === 0 && !goog.events.hasListener(iconImage)) {
+      if ((i++ & 3) === 0 && !iconImage.hasListener()) {
        delete this.cache_[key];
        --this.cacheSize_;
      }
--- a/src/ol/style/imagestyle.js
+++ b/src/ol/style/imagestyle.js
@@ -231,9 +231,9 @@ ol.style.Image.prototype.setSnapToPixel = function(snapToPixel) {


 /**
- * @param {function(this: T, goog.events.Event)} listener Listener function.
+ * @param {function(this: T, ol.events.Event)} listener Listener function.
 * @param {T} thisArg Value to use as `this` when executing `listener`.
- * @return {goog.events.Key|undefined} Listener key.
+ * @return {ol.events.Key|undefined} Listener key.
 * @template T
 */
 ol.style.Image.prototype.listenImageChange = goog.abstractMethod;
@@ -246,7 +246,7 @@ ol.style.Image.prototype.load = goog.abstractMethod;


 /**
- * @param {function(this: T, goog.events.Event)} listener Listener function.
+ * @param {function(this: T, ol.events.Event)} listener Listener function.
 * @param {T} thisArg Value to use as `this` when executing `listener`.
 * @template T
 */
--- a/src/ol/tile.js
+++ b/src/ol/tile.js
@@ -1,9 +1,9 @@
 goog.provide('ol.Tile');
 goog.provide('ol.TileState');

-goog.require('goog.events');
-goog.require('goog.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventTarget');
+goog.require('ol.events.EventType');
 goog.require('ol.TileCoord');


@@ -24,7 +24,7 @@ ol.TileState = {
 * Base class for tiles.
 *
 * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 * @param {ol.TileCoord} tileCoord Tile coordinate.
 * @param {ol.TileState} state State.
 */
@@ -60,14 +60,14 @@ ol.Tile = function(tileCoord, state) {
  this.key = '';

 };
-goog.inherits(ol.Tile, goog.events.EventTarget);
+goog.inherits(ol.Tile, ol.events.EventTarget);


 /**
 * @protected
 */
 ol.Tile.prototype.changed = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };


--- a/src/ol/tilequeue.js
+++ b/src/ol/tilequeue.js
@@ -1,8 +1,8 @@
 goog.provide('ol.TilePriorityFunction');
 goog.provide('ol.TileQueue');

-goog.require('goog.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.Coordinate');
 goog.require('ol.TileState');
 goog.require('ol.structs.PriorityQueue');
@@ -71,8 +71,8 @@ ol.TileQueue.prototype.enqueue = function(element) {
  var added = goog.base(this, 'enqueue', element);
  if (added) {
    var tile = element[0];
-    goog.events.listen(tile, goog.events.EventType.CHANGE,
-        this.handleTileChange, false, this);
+    ol.events.listen(tile, ol.events.EventType.CHANGE,
+        this.handleTileChange, this);
  }
  return added;
 };
@@ -87,7 +87,7 @@ ol.TileQueue.prototype.getTilesLoading = function() {


 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
 * @protected
 */
 ol.TileQueue.prototype.handleTileChange = function(event) {
@@ -95,8 +95,8 @@ ol.TileQueue.prototype.handleTileChange = function(event) {
  var state = tile.getState();
  if (state === ol.TileState.LOADED || state === ol.TileState.ERROR ||
      state === ol.TileState.EMPTY) {
-    goog.events.unlisten(tile, goog.events.EventType.CHANGE,
-        this.handleTileChange, false, this);
+    ol.events.unlisten(tile, ol.events.EventType.CHANGE,
+        this.handleTileChange, this);
    var tileKey = tile.getKey();
    if (tileKey in this.tilesLoadingKeys_) {
      delete this.tilesLoadingKeys_[tileKey];
--- a/src/ol/webgl/context.js
+++ b/src/ol/webgl/context.js
@@ -1,7 +1,7 @@
 goog.provide('ol.webgl.Context');

 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.log');
 goog.require('goog.object');
 goog.require('ol');
@@ -22,7 +22,7 @@ ol.webgl.BufferCacheEntry;
 * A WebGL context for accessing low-level WebGL capabilities.
 *
 * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
 * @param {HTMLCanvasElement} canvas Canvas.
 * @param {WebGLRenderingContext} gl GL.
 */
@@ -95,10 +95,10 @@ ol.webgl.Context = function(canvas, gl) {
        'Failed to get extension "OES_element_index_uint"');
  }

-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
-      this.handleWebGLContextLost, false, this);
-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
-      this.handleWebGLContextRestored, false, this);
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
+      this.handleWebGLContextLost, this);
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
+      this.handleWebGLContextRestored, this);

 };

--- a/test/index.html
+++ b/test/index.html
@@ -32,22 +32,6 @@

    goog.json.USE_NATIVE_JSON = true;

-    /**
-     * The goog.dom.ViewportSizeMonitor (used in map.js) creates a global leak
-     * by setting goog.UID_PROPERTY_ on the monitored window.  In order to test
-     * that we don't have other global leaks, we preemptively set the property
-     * so Mocha can compare the global before and after our tests.
-     *
-     * In addition, calling goog.events.listen on the global object (as done
-     * in deviceorientation.js) creates a second leak by setting
-     * goog.events.LISTENER_MAP_PROP_ on the global object.
-     *
-     * We preemptively set both of these properties so Mocha can compare the
-     * global before and after tests.  The call to goog.events.listen also
-     * calls goog.getUid.
-     */
-    goog.events.listen(this, 'test', function() {});
-
    var runner = mocha.run();
    if (window.console && console.log) {
      // write stacks to the console for failed tests
--- a/test/spec/ol/collection.test.js
+++ b/test/spec/ol/collection.test.js
@@ -114,7 +114,7 @@ describe('ol.collection', function() {
    it('fires a remove event', function() {
      var collection = new ol.Collection([0, 1, 2]);
      var cb = sinon.spy();
-      goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb);
+      ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb);
      expect(collection.remove(1)).to.eql(1);
      expect(cb).to.be.called();
      expect(cb.lastCall.args[0].element).to.eql(1);
@@ -137,10 +137,10 @@ describe('ol.collection', function() {
    it('does dispatch events', function() {
      var collection = new ol.Collection(['a', 'b']);
      var added, removed;
-      goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
+      ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
        added = e.element;
      });
-      goog.events.listen(
+      ol.events.listen(
          collection, ol.CollectionEventType.REMOVE, function(e) {
            removed = e.element;
          });
@@ -154,7 +154,7 @@ describe('ol.collection', function() {
    it('does dispatch events', function() {
      var collection = new ol.Collection(['a']);
      var removed;
-      goog.events.listen(
+      ol.events.listen(
          collection, ol.CollectionEventType.REMOVE, function(e) {
            removed = e.element;
          });
@@ -167,7 +167,7 @@ describe('ol.collection', function() {
    it('does dispatch events', function() {
      var collection = new ol.Collection([0, 2]);
      var added;
-      goog.events.listen(
+      ol.events.listen(
          collection, ol.CollectionEventType.ADD, function(e) {
            added = e.element;
          });
@@ -179,7 +179,7 @@ describe('ol.collection', function() {
  describe('setAt beyond end', function() {
    it('triggers events properly', function() {
      var added = [];
-      goog.events.listen(
+      ol.events.listen(
          collection, ol.CollectionEventType.ADD, function(e) {
            added.push(e.element);
          });
@@ -200,7 +200,7 @@ describe('ol.collection', function() {
    beforeEach(function() {
      collection = new ol.Collection([0, 1, 2]);
      cb = sinon.spy();
-      goog.events.listen(collection, 'change:length', cb);
+      ol.events.listen(collection, 'change:length', cb);
    });

    describe('insertAt', function() {
@@ -229,7 +229,7 @@ describe('ol.collection', function() {
    it('triggers add when pushing', function() {
      var collection = new ol.Collection();
      var elem;
-      goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
+      ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
        elem = e.element;
      });
      collection.push(1);
@@ -246,8 +246,8 @@ describe('ol.collection', function() {
    });
    describe('setAt', function() {
      it('triggers remove', function() {
-        goog.events.listen(collection, ol.CollectionEventType.ADD, cb1);
-        goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb2);
+        ol.events.listen(collection, ol.CollectionEventType.ADD, cb1);
+        ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb2);
        collection.setAt(0, 2);
        expect(cb2.lastCall.args[0].element).to.eql(1);
        expect(cb1.lastCall.args[0].element).to.eql(2);
@@ -255,7 +255,7 @@ describe('ol.collection', function() {
    });
    describe('pop', function() {
      it('triggers remove', function() {
-        goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb1);
+        ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb1);
        collection.pop();
        expect(cb1.lastCall.args[0].element).to.eql(1);
      });
@@ -273,7 +273,7 @@ describe('ol.collection', function() {
    it('fires events', function() {
      var collection = new ol.Collection();
      var elems = [];
-      goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
+      ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
        elems.push(e.element);
      });
      collection.extend([1, 2]);
@@ -284,6 +284,6 @@ describe('ol.collection', function() {
 });


-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.Collection');
 goog.require('ol.CollectionEventType');
--- a/test/spec/ol/control/zoomslidercontrol.test.js
+++ b/test/spec/ol/control/zoomslidercontrol.test.js
@@ -1,3 +1,4 @@
+/*global createMapDiv, disposeMap*/
 goog.provide('ol.test.control.ZoomSlider');

 describe('ol.control.ZoomSlider', function() {
@@ -50,10 +51,10 @@ describe('ol.control.ZoomSlider', function() {

  });

-  describe('dragger setup', function() {
-    it('creates a goog.fx.Dragger', function() {
-      expect(zoomslider.dragger_ instanceof goog.fx.Dragger).to.be(true);
-      expect(zoomslider.dragger_.limits instanceof goog.math.Rect).to.be(true);
+  describe('#initSlider_', function() {
+    it('sets limits', function() {
+      zoomslider.initSlider_();
+      expect(zoomslider.limits_ instanceof goog.math.Rect).to.be(true);
    });
  });

@@ -85,12 +86,104 @@ describe('ol.control.ZoomSlider', function() {
    });
  });

+  describe('Pointer event handling', function() {
+    var map;
+
+    beforeEach(function() {
+      map = new ol.Map({
+        target: createMapDiv(500, 100),
+        view: new ol.View({
+          center: [0, 0],
+          resolutions: [16, 8, 4, 2, 1, 0.5, 0.25, 0.125, 0.0625]
+        })
+      });
+    });
+    afterEach(function() {
+      disposeMap(map);
+    });
+
+    it('[horizontal] handles a drag sequence', function() {
+      var spy = sinon.spy(goog.Disposable.prototype, 'registerDisposable');
+      var control = new ol.control.ZoomSlider();
+      map.addControl(control);
+      map.getView().setZoom(0);
+      control.element.style.width = '500px';
+      control.element.style.height = '10px';
+      control.element.firstChild.style.width = '100px';
+      control.element.firstChild.style.height = '10px';
+      map.renderSync();
+      var dragger = spy.firstCall.args[0];
+      spy.restore();
+      var event = new ol.pointer.PointerEvent(ol.pointer.EventType.POINTERDOWN, {
+        target: control.element.firstElementChild
+      });
+      event.clientX = control.limits_.width;
+      event.clientY = 0;
+      dragger.dispatchEvent(event);
+      expect(control.currentResolution_).to.be(16);
+      expect(control.dragging_).to.be(true);
+      expect(control.dragListenerKeys_).to.be.ok();
+      event.type = ol.pointer.EventType.POINTERMOVE;
+      event.clientX = 6 * control.limits_.width / 8;
+      event.clientY = 0;
+      dragger.dispatchEvent(event);
+      expect(control.currentResolution_).to.be(4);
+      event.type = ol.pointer.EventType.POINTERMOVE;
+      event.clientX = 4 * control.limits_.width / 8;
+      event.clientY = 0;
+      dragger.dispatchEvent(event);
+      event.type = ol.pointer.EventType.POINTERUP;
+      dragger.dispatchEvent(event);
+      expect(control.currentResolution_).to.be(1);
+      expect(control.dragListenerKeys_).to.be(null);
+      expect(control.dragging_).to.be(false);
+    });
+    it('[vertical] handles a drag sequence', function() {
+      var spy = sinon.spy(goog.Disposable.prototype, 'registerDisposable');
+      var control = new ol.control.ZoomSlider();
+      control.element.style.width = '10px';
+      control.element.style.height = '100px';
+      control.element.firstChild.style.width = '10px';
+      control.element.firstChild.style.height = '20px';
+      map.addControl(control);
+      map.getView().setZoom(8);
+      map.renderSync();
+      var dragger = spy.firstCall.args[0];
+      spy.restore();
+      var event = new ol.pointer.PointerEvent(ol.pointer.EventType.POINTERDOWN, {
+        target: control.element.firstElementChild
+      });
+      event.clientX = 0;
+      event.clientY = 0;
+      dragger.dispatchEvent(event);
+      expect(control.currentResolution_).to.be(0.0625);
+      expect(control.dragging_).to.be(true);
+      expect(control.dragListenerKeys_).to.be.ok();
+      event.type = ol.pointer.EventType.POINTERMOVE;
+      event.clientX = 0;
+      event.clientY = 2 * control.limits_.height / 8;
+      dragger.dispatchEvent(event);
+      expect(control.currentResolution_).to.be(0.25);
+      event.type = ol.pointer.EventType.POINTERMOVE;
+      event.clientX = 0;
+      event.clientY = 4 * control.limits_.height / 8;
+      dragger.dispatchEvent(event);
+      event.type = ol.pointer.EventType.POINTERUP;
+      dragger.dispatchEvent(event);
+      expect(control.currentResolution_).to.be(1);
+      expect(control.dragListenerKeys_).to.be(null);
+      expect(control.dragging_).to.be(false);
+    });
+  });
+
 });

+goog.require('goog.Disposable');
 goog.require('goog.dispose');
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.fx.Dragger');
 goog.require('goog.math.Rect');
 goog.require('ol.Map');
+goog.require('ol.View');
 goog.require('ol.control.ZoomSlider');
+goog.require('ol.pointer.PointerEvent');
--- a/test/spec/ol/events.test.js
+++ b/test/spec/ol/events.test.js
@@ -0,0 +1,216 @@
+goog.provide('ol.test.events');
+
+
+describe('ol.events', function() {
+  var add, remove, target;
+
+  beforeEach(function() {
+    add = sinon.spy();
+    remove = sinon.spy();
+    target = {
+      addEventListener: add,
+      removeEventListener: remove
+    };
+  });
+
+  describe('bindListener_()', function() {
+    it('binds a listener and returns a bound listener function', function() {
+      var listenerObj = {
+        listener: sinon.spy(),
+        bindTo: {id: 1}
+      };
+      var boundListener = ol.events.bindListener_(listenerObj);
+      expect(listenerObj.boundListener).to.equal(boundListener);
+      boundListener();
+      expect(listenerObj.listener.thisValues[0]).to.equal(listenerObj.bindTo);
+    });
+    it('binds a self-unregistering listener when callOnce is true', function() {
+      var bindTo = {id: 1};
+      var listener = sinon.spy();
+      target.removeEventListener = function() {};
+      var listenerObj = {
+        type: 'foo',
+        target: target,
+        listener: listener,
+        bindTo: bindTo,
+        callOnce: true
+      };
+      var boundListener = ol.events.bindListener_(listenerObj);
+      expect(listenerObj.boundListener).to.equal(boundListener);
+      var spy = sinon.spy(ol.events, 'unlistenByKey');
+      boundListener();
+      expect(listener.thisValues[0]).to.equal(bindTo);
+      expect(spy.firstCall.args[0]).to.eql(listenerObj);
+      ol.events.unlistenByKey.restore();
+    });
+  });
+
+  describe('findListener_()', function() {
+    var listener, listenerObj, listeners;
+
+    beforeEach(function() {
+      listener = function() {};
+      listenerObj = {
+        type: 'foo',
+        target: target,
+        listener: listener
+      };
+      listeners = [listenerObj];
+    });
+
+    it('searches a listener array for a specific listener', function() {
+      var bindTo = {id: 1};
+      var result = ol.events.findListener_(listeners, listener);
+      expect(result).to.be(listenerObj);
+      result = ol.events.findListener_(listeners, listener, bindTo);
+      expect(result).to.be(undefined);
+      listenerObj.bindTo = bindTo;
+      result = ol.events.findListener_(listeners, listener);
+      expect(result).to.be(undefined);
+      result = ol.events.findListener_(listeners, listener, bindTo);
+      expect(result).to.be(listenerObj);
+    });
+    it('marks the delete index on a listener object', function() {
+      var result = ol.events.findListener_(listeners, listener, undefined, true);
+      expect(result).to.be(listenerObj);
+      expect(listenerObj.deleteIndex).to.be(0);
+    });
+  });
+
+  describe('getListeners()', function() {
+    it('returns listeners for a target and type', function() {
+      var foo = ol.events.listen(target, 'foo', function() {});
+      var bar = ol.events.listen(target, 'bar', function() {});
+      expect (ol.events.getListeners(target, 'foo')).to.eql([foo]);
+      expect (ol.events.getListeners(target, 'bar')).to.eql([bar]);
+    });
+    it('returns undefined when no listeners are registered', function() {
+      expect (ol.events.getListeners(target, 'foo')).to.be(undefined);
+    });
+  });
+
+  describe('listen()', function() {
+    it('calls addEventListener on the target', function() {
+      ol.events.listen(target, 'foo', function() {});
+      expect(add.callCount).to.be(1);
+    });
+    it('returns a key', function() {
+      var key = ol.events.listen(target, 'foo', function() {});
+      expect(key).to.be.a(Object);
+    });
+    it('does not add the same listener twice', function() {
+      var listener = function() {};
+      var key1 = ol.events.listen(target, 'foo', listener);
+      var key2 = ol.events.listen(target, 'foo', listener);
+      expect(key1).to.equal(key2);
+      expect(add.callCount).to.be(1);
+    });
+    it('only treats listeners as same when all args are equal', function() {
+      var listener = function() {};
+      ol.events.listen(target, 'foo', listener, {});
+      ol.events.listen(target, 'foo', listener, {});
+      ol.events.listen(target, 'foo', listener, undefined);
+      expect(add.callCount).to.be(3);
+    });
+  });
+
+  describe('listenOnce()', function() {
+    it('creates a one-off listener', function() {
+      var listener = sinon.spy();
+      var key = ol.events.listenOnce(target, 'foo', listener);
+      expect(add.callCount).to.be(1);
+      expect(key.callOnce).to.be(true);
+      key.boundListener();
+      expect(listener.callCount).to.be(1);
+      expect(remove.callCount).to.be(1);
+    });
+    it('does not add the same listener twice', function() {
+      var listener = function() {};
+      var key1 = ol.events.listenOnce(target, 'foo', listener);
+      var key2 = ol.events.listenOnce(target, 'foo', listener);
+      expect(key1).to.equal(key2);
+      expect(add.callCount).to.be(1);
+      expect(key1.callOnce).to.be(true);
+    });
+    it('listen() can turn a one-off listener into a permanent one', function() {
+      var listener = sinon.spy();
+      var key = ol.events.listenOnce(target, 'foo', listener);
+      expect(key.callOnce).to.be(true);
+      key = ol.events.listen(target, 'foo', listener);
+      expect(add.callCount).to.be(1);
+      expect(key.callOnce).to.be(false);
+      key.boundListener();
+      expect(remove.callCount).to.be(0);
+    });
+  });
+
+  describe('unlisten()', function() {
+    it('unregisters previously registered listeners', function() {
+      var listener = function() {};
+      ol.events.listen(target, 'foo', listener);
+      ol.events.unlisten(target, 'foo', listener);
+      expect(ol.events.getListeners(target, 'foo')).to.be(undefined);
+    });
+    it('works with multiple types', function() {
+      var listener = function() {};
+      ol.events.listen(target, ['foo', 'bar'], listener);
+      ol.events.unlisten(target, ['bar', 'foo'], listener);
+      expect(ol.events.getListeners(target, 'foo')).to.be(undefined);
+      expect(ol.events.getListeners(target, 'bar')).to.be(undefined);
+    });
+  });
+
+  describe('unlistenByKey()', function() {
+    it('unregisters previously registered listeners', function() {
+      var key = ol.events.listen(target, 'foo', function() {});
+      ol.events.unlistenByKey(key);
+      expect(ol.events.getListeners(target, 'foo')).to.be(undefined);
+    });
+    it('works with multiple types', function() {
+      var key = ol.events.listen(target, ['foo', 'bar'], function() {});
+      ol.events.unlistenByKey(key);
+      expect(ol.events.getListeners(target, 'foo')).to.be(undefined);
+      expect(ol.events.getListeners(target, 'bar')).to.be(undefined);
+    });
+  });
+
+  describe('unlistenAll()', function() {
+    it('unregisters all listeners registered for a target', function() {
+      var keys = [
+        ol.events.listen(target, 'foo', function() {}),
+        ol.events.listen(target, 'bar', function() {})
+      ];
+      ol.events.unlistenAll(target);
+      expect(ol.events.getListeners(target, 'foo')).to.be(undefined);
+      expect(ol.events.getListeners(target, 'bar')).to.be(undefined);
+      expect(ol.events.LISTENER_MAP_PROP_ in target).to.be(false);
+      expect(keys).to.eql([{}, {}]);
+    });
+  });
+
+  describe('Compatibility with ol.events.EventTarget', function() {
+    it('does not register duplicated listeners', function() {
+      var target = new ol.events.EventTarget();
+      var listener = function() {};
+      var key1 = ol.events.listen(target, 'foo', listener);
+      expect(target.getListeners('foo')).to.eql([key1.boundListener]);
+      var key2 = ol.events.listen(target, 'foo', listener);
+      expect(key2.boundListener).to.equal(key1.boundListener);
+      expect(target.getListeners('foo')).to.eql([key1.boundListener]);
+    });
+    it('registers multiple listeners if this object is different', function() {
+      var target = new ol.events.EventTarget();
+      var listener = function() {};
+      var key1 = ol.events.listen(target, 'foo', listener, {});
+      var key2 = ol.events.listen(target, 'foo', listener, {});
+      expect(key1.boundListener).to.not.equal(key2.boundListener);
+      expect(target.getListeners('foo')).to.eql(
+          [key2.boundListener, key1.boundListener]);
+    });
+  });
+
+});
+
+
+goog.require('ol.events');
+goog.require('ol.events.EventTarget');
--- a/test/spec/ol/events/event.test.js
+++ b/test/spec/ol/events/event.test.js
@@ -0,0 +1,57 @@
+goog.provide('ol.test.events.Event');
+
+
+describe('ol.events.Event', function() {
+
+  describe('constructor', function() {
+    it('takes a type as argument', function() {
+      var event = new ol.events.Event('foo');
+      expect(event.type).to.be('foo');
+    });
+    it('can be constructed with an optional 2nd target arg', function() {
+      var target = {id: 1};
+      var event = new ol.events.Event('foo', target);
+      expect(event.target).to.equal(target);
+    });
+    it('does not set the propagationStopped flag', function() {
+      var event = new ol.events.Event('foo');
+      expect(event.propagationStopped).to.be(undefined);
+    });
+  });
+
+  describe('#preventDefault', function() {
+    it('sets the propagationStopped flag', function() {
+      var event = new ol.events.Event('foo');
+      event.preventDefault();
+      expect(event.propagationStopped).to.be(true);
+    });
+    it('is the same as #stopPropagation', function() {
+      var event = new ol.events.Event('foo');
+      expect(event.stopPropagation).to.equal(event.preventDefault);
+    });
+  });
+
+  describe('ol.events.Event.preventDefault', function() {
+    it('calls preventDefault on the event object', function() {
+      var event = {
+        preventDefault: sinon.spy()
+      };
+      ol.events.Event.preventDefault(event);
+      expect(event.preventDefault.called).to.be(true);
+    });
+  });
+
+  describe('ol.events.Event.stopPropagation', function() {
+    it('calls preventDefault on the event object', function() {
+      var event = {
+        stopPropagation: sinon.spy()
+      };
+      ol.events.Event.stopPropagation(event);
+      expect(event.stopPropagation.called).to.be(true);
+    });
+  });
+
+});
+
+
+goog.require('ol.events.Event');
--- a/test/spec/ol/events/eventtarget.test.js
+++ b/test/spec/ol/events/eventtarget.test.js
@@ -0,0 +1,132 @@
+goog.provide('ol.test.events.EventTarget');
+
+
+describe('ol.events.EventTarget', function() {
+  var called, events, eventTarget, spy1, spy2, spy3;
+
+  beforeEach(function() {
+    called = [];
+    events = [];
+    function spy(evt) {
+      called.push(this.id);
+      events.push(evt);
+    }
+    spy1 = spy.bind({id: 1});
+    spy2 = spy.bind({id: 2});
+    spy3 = spy.bind({id: 3});
+    eventTarget = new ol.events.EventTarget();
+  });
+
+  describe('constructor', function() {
+    it('creates an instance', function() {
+      expect(eventTarget).to.be.a(ol.events.EventTarget);
+    });
+    it('creates an empty listeners_ object', function() {
+      expect(Object.keys(eventTarget.listeners_)).to.have.length(0);
+    });
+  });
+
+  describe('#hasListener', function() {
+    it('reports any listeners when called without argument', function() {
+      expect(eventTarget.hasListener()).to.be(false);
+      eventTarget.listeners_['foo'] = [function() {}];
+      expect(eventTarget.hasListener()).to.be(true);
+    });
+    it('reports listeners for the type passed as argument', function() {
+      eventTarget.listeners_['foo'] = [function() {}];
+      expect(eventTarget.hasListener('foo')).to.be(true);
+      expect(eventTarget.hasListener('bar')).to.be(false);
+    });
+  });
+
+  describe('#getListeners', function() {
+    it('returns listeners for a type or undefined if none', function() {
+      expect(eventTarget.getListeners('foo')).to.be(undefined);
+      var listeners = [function() {}];
+      eventTarget.listeners_['foo'] = listeners;
+      expect(eventTarget.getListeners('foo')).to.equal(listeners);
+    });
+  });
+
+
+  describe('#addEventListener()', function() {
+    it('has listeners for each registered type', function() {
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.addEventListener('bar', spy2);
+      expect(eventTarget.hasListener('foo')).to.be(true);
+      expect(eventTarget.hasListener('bar')).to.be(true);
+    });
+  });
+
+  describe('#removeEventListener()', function() {
+    it('keeps the listeners registry clean', function() {
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.removeEventListener('foo', spy1);
+      expect(eventTarget.hasListener('foo')).to.be(false);
+    });
+    it('removes added listeners from the listeners registry', function() {
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.addEventListener('foo', spy2);
+      eventTarget.removeEventListener('foo', spy1, false);
+      expect(eventTarget.getListeners('foo')).to.have.length(1);
+    });
+  });
+
+  describe('#dispatchEvent()', function() {
+    it('calls listeners in the correct order', function() {
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.addEventListener('foo', spy2);
+      eventTarget.dispatchEvent('foo');
+      expect(called).to.eql([1, 2]);
+    });
+    it('stops propagation when listeners return false', function() {
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.addEventListener('foo', function(evt) {
+        spy2();
+        return false;
+      }, false);
+      eventTarget.addEventListener('foo', spy3);
+      eventTarget.dispatchEvent('foo');
+      expect(called).to.eql([1, 2]);
+    });
+    it('stops propagation when listeners call preventDefault()', function() {
+      eventTarget.addEventListener('foo', function(evt) {
+        spy2();
+        evt.preventDefault();
+      });
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.dispatchEvent('foo');
+      expect(called).to.eql([2]);
+    });
+    it('passes a default ol.events.Event object to listeners', function() {
+      eventTarget.addEventListener('foo', spy1);
+      eventTarget.dispatchEvent('foo');
+      expect(events[0]).to.be.a(ol.events.Event);
+      expect(events[0].type).to.be('foo');
+      expect(events[0].target).to.equal(eventTarget);
+    });
+    it('passes a custom event object with target to listeners', function() {
+      eventTarget.addEventListener('foo', spy1);
+      var event = {
+        type: 'foo'
+      };
+      eventTarget.dispatchEvent(event);
+      expect(events[0]).to.equal(event);
+      expect(events[0].target).to.equal(eventTarget);
+    });
+  });
+
+  describe('#dispose()', function() {
+    it('cleans up foreign references', function() {
+      ol.events.listen(eventTarget, 'foo', spy1, document);
+      expect(eventTarget.hasListener('foo')).to.be(true);
+      eventTarget.dispose();
+      expect(eventTarget.hasListener('foo')).to.be(false);
+    });
+  });
+});
+
+
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventTarget');
--- a/test/spec/ol/feature.test.js
+++ b/test/spec/ol/feature.test.js
@@ -462,7 +462,7 @@ describe('ol.Feature.createStyleFunction()', function() {
 });


-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.object');
 goog.require('ol.Feature');
 goog.require('ol.geom.Point');
--- a/test/spec/ol/featureloader.test.js
+++ b/test/spec/ol/featureloader.test.js
@@ -69,7 +69,7 @@ describe('ol.featureloader', function() {
      var url = 'spec/ol/data/point.json';
      var format = new ol.format.GeoJSON();
      loader = ol.featureloader.tile(url, format);
-      goog.events.listen(tile, 'change', function(e) {
+      ol.events.listen(tile, 'change', function(e) {
        expect(tile.getFeatures().length).to.be.greaterThan(0);
        done();
      });
@@ -81,7 +81,7 @@ describe('ol.featureloader', function() {
          var url = 'spec/ol/data/14-8938-5680.vector.pbf';
          var format = new ol.format.MVT();
          loader = ol.featureloader.tile(url, format);
-          goog.events.listen(tile, 'change', function(e) {
+          ol.events.listen(tile, 'change', function(e) {
            expect(tile.getFeatures().length).to.be.greaterThan(0);
            expect(tile.getProjection().getUnits()).to.be('tile-pixels');
            done();
@@ -93,7 +93,7 @@ describe('ol.featureloader', function() {

 });

-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.VectorTile');
 goog.require('ol.featureloader');
 goog.require('ol.format.GeoJSON');
--- a/test/spec/ol/interaction/draganddropinteraction.test.js
+++ b/test/spec/ol/interaction/draganddropinteraction.test.js
@@ -1,16 +1,101 @@
 goog.provide('ol.test.interaction.DragAndDrop');

 describe('ol.interaction.DragAndDrop', function() {
+  var viewport, map, interaction;
+
+  beforeEach(function() {
+    viewport = new ol.events.EventTarget();
+    map = {
+      getViewport: function() {
+        return viewport;
+      },
+      getView: function() {
+        return new ol.View()
+      }
+    };
+    interaction = new ol.interaction.DragAndDrop({
+      formatConstructors: [ol.format.GeoJSON]
+    });
+  });

  describe('constructor', function() {

    it('can be constructed without arguments', function() {
-      var instance = new ol.interaction.DragAndDrop();
-      expect(instance).to.be.an(ol.interaction.DragAndDrop);
+      var interaction = new ol.interaction.DragAndDrop();
+      expect(interaction).to.be.an(ol.interaction.DragAndDrop);
    });

+    it('sets formatConstructors on the instance', function() {
+      expect(interaction.formatConstructors_).to.have.length(1);
+    });
+
+
+  });
+
+  describe('#setMap()', function() {
+    it('registers and unregisters listeners', function() {
+      interaction.setMap(map);
+      expect(viewport.hasListener(ol.events.EventType.DRAGENTER)).to.be(true);
+      expect(viewport.hasListener(ol.events.EventType.DRAGOVER)).to.be(true);
+      expect(viewport.hasListener(ol.events.EventType.DROP)).to.be(true);
+      interaction.setMap(null);
+      expect(viewport.hasListener(ol.events.EventType.DRAGENTER)).to.be(false);
+      expect(viewport.hasListener(ol.events.EventType.DRAGOVER)).to.be(false);
+      expect(viewport.hasListener(ol.events.EventType.DROP)).to.be(false);
+    });
+  });
+
+  describe('#handleDrop_', function() {
+    var origFileReader = goog.global.FileReader;
+
+    beforeEach(function() {
+      FileReader = function() {
+        ol.events.EventTarget.apply(this, arguments);
+        this.readAsText = function(file) {
+          this.result = file;
+          this.dispatchEvent('load');
+        };
+      };
+      ol.inherits(FileReader, ol.events.EventTarget);
+    });
+
+    afterEach(function() {
+      goog.global.FileReader = origFileReader;
+    });
+
+    it('reads dropped files', function(done) {
+      interaction.on('addfeatures', function(evt) {
+        expect(evt.features.length).to.be(1);
+        done();
+      });
+      interaction.setMap(map);
+      var event = new ol.events.Event();
+      event.dataTransfer = {};
+      event.type = ol.events.EventType.DRAGENTER;
+      viewport.dispatchEvent(event);
+      event.type = ol.events.EventType.DRAGOVER;
+      viewport.dispatchEvent(event);
+      event.type = ol.events.EventType.DROP;
+      event.dataTransfer.files = {
+        length: 1,
+        item: function() {
+          return JSON.stringify({
+            type: 'FeatureCollection',
+            features: [{type: 'Feature', id: '1'}]
+          });
+        }
+      }
+      viewport.dispatchEvent(event);
+      expect(event.dataTransfer.dropEffect).to.be('copy');
+      expect(event.propagationStopped).to.be(true);
+    });
  });

 });

 goog.require('ol.interaction.DragAndDrop');
+goog.require('ol.View');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventTarget');
+goog.require('ol.events.EventType');
+goog.require('ol.format.GeoJSON');
--- a/test/spec/ol/interaction/drawinteraction.test.js
+++ b/test/spec/ol/interaction/drawinteraction.test.js
@@ -51,11 +51,11 @@ describe('ol.interaction.Draw', function() {
    var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false;
    var event = new ol.MapBrowserPointerEvent(type, map,
        new ol.pointer.PointerEvent(type,
-            new goog.events.BrowserEvent({
+            {
              clientX: position.x + x + width / 2,
              clientY: position.y + y + height / 2,
              shiftKey: shiftKey
-            })));
+            }));
    map.handleMapBrowserEvent(event);
  }

@@ -163,8 +163,8 @@ describe('ol.interaction.Draw', function() {
    it('triggers draw events', function() {
      var ds = sinon.spy();
      var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
      simulateEvent('pointermove', 10, 20);
      simulateEvent('pointerdown', 10, 20);
      simulateEvent('pointerup', 10, 20);
@@ -180,7 +180,7 @@ describe('ol.interaction.Draw', function() {
        end: 0,
        addfeature: 0
      };
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND,
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND,
          function() {
            expect(receivedEvents.end).to.be(0);
            expect(receivedEvents.addfeature).to.be(0);
@@ -309,8 +309,8 @@ describe('ol.interaction.Draw', function() {
    it('triggers draw events', function() {
      var ds = sinon.spy();
      var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);

      // first point
      simulateEvent('pointermove', 10, 20);
@@ -467,8 +467,8 @@ describe('ol.interaction.Draw', function() {
    it('triggers draw events', function() {
      var ds = sinon.spy();
      var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);

      // first point
      simulateEvent('pointermove', 10, 20);
@@ -607,8 +607,8 @@ describe('ol.interaction.Draw', function() {
    it('triggers draw events', function() {
      var ds = sinon.spy();
      var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);

      // first point
      simulateEvent('pointermove', 10, 20);
@@ -805,7 +805,7 @@ describe('ol.interaction.Draw', function() {

    it('dispatches a drawstart event', function() {
      var spy = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, spy);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, spy);
      draw.extend(feature);
      expect(spy.callCount).to.be(1);
    });
@@ -814,8 +814,7 @@ describe('ol.interaction.Draw', function() {
 });

 goog.require('goog.dispose');
-goog.require('goog.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events');
 goog.require('goog.style');
 goog.require('ol.Feature');
 goog.require('ol.Map');
--- a/test/spec/ol/interaction/interaction.test.js
+++ b/test/spec/ol/interaction/interaction.test.js
@@ -11,7 +11,7 @@ describe('ol.interaction.Interaction', function() {

    it('creates a new interaction', function() {
      expect(interaction).to.be.a(ol.interaction.Interaction);
-      expect(interaction).to.be.a(goog.events.EventTarget);
+      expect(interaction).to.be.a(ol.events.EventTarget);
    });

    it('creates an active interaction', function() {
@@ -55,6 +55,6 @@ describe('ol.interaction.Interaction', function() {

 });

-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
 goog.require('ol.Map');
 goog.require('ol.interaction.Interaction');
--- a/test/spec/ol/interaction/keyboardpaninteraction.test.js
+++ b/test/spec/ol/interaction/keyboardpaninteraction.test.js
@@ -0,0 +1,58 @@
+/*global createMapDiv, disposeMap*/
+goog.provide('ol.test.interaction.KeyboardPan');
+
+
+describe('ol.interaction.KeyboardPan', function() {
+  var map;
+
+  beforeEach(function() {
+    map = new ol.Map({
+      target: createMapDiv(100, 100),
+      view: new ol.View({
+        center: [0, 0],
+        resolutions: [1],
+        zoom: 0
+      })
+    });
+    map.renderSync();
+  });
+  afterEach(function() {
+    disposeMap(map);
+  });
+
+  describe('handleEvent()', function() {
+    it('pans on arrow keys', function() {
+      var spy = sinon.spy(ol.interaction.Interaction, 'pan');
+      var event = new ol.MapBrowserEvent(ol.events.EventType.KEYDOWN, map, {
+        type: ol.events.EventType.KEYDOWN,
+        target: map.getTargetElement(),
+        preventDefault: ol.events.Event.prototype.preventDefault
+      });
+      event.originalEvent.keyCode = ol.events.KeyCode.DOWN;
+      map.handleMapBrowserEvent(event);
+      event.originalEvent.keyCode = ol.events.KeyCode.UP;
+      map.handleMapBrowserEvent(event);
+      event.originalEvent.keyCode = ol.events.KeyCode.LEFT;
+      map.handleMapBrowserEvent(event);
+      event.originalEvent.keyCode = ol.events.KeyCode.RIGHT;
+      map.handleMapBrowserEvent(event);
+      expect(spy.getCall(0).args[2]).to.eql([0, -128]);
+      expect(spy.getCall(1).args[2]).to.eql([0, 128]);
+      expect(spy.getCall(2).args[2]).to.eql([-128, 0]);
+      expect(spy.getCall(3).args[2]).to.eql([128, 0]);
+      ol.interaction.Interaction.pan.restore();
+    });
+  });
+
+});
+
+
+goog.require('goog.object');
+goog.require('ol.Map');
+goog.require('ol.MapBrowserEvent');
+goog.require('ol.View');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
+goog.require('ol.events.KeyCode');
+goog.require('ol.interaction.Interaction');
+goog.require('ol.interaction.KeyboardPan');
--- a/Show More
+++ b/Show More