Merge pull request #4165 from fredj/es5

Use ECMAScript 5.1 Array functions instead of goog.array

src/ol/collection.js

@@ -136,7 +136,7 @@ ol.Collection.prototype.extend = function(arr) {
  * @api stable
  */
 ol.Collection.prototype.forEach = function(f, opt_this) {
-  goog.array.forEach(this.array_, f, opt_this);
+  this.array_.forEach(f, opt_this);
 };
 
 

src/ol/control/control.js

@@ -1,6 +1,5 @@
 goog.provide('ol.control.Control');
 
-goog.require('goog.array');
 goog.require('goog.dom');
 goog.require('goog.events');
 goog.require('ol.MapEventType');
@@ -109,7 +108,7 @@ ol.control.Control.prototype.setMap = function(map) {
     goog.dom.removeNode(this.element);
   }
   if (this.listenerKeys.length > 0) {
-    goog.array.forEach(this.listenerKeys, goog.events.unlistenByKey);
+    this.listenerKeys.forEach(goog.events.unlistenByKey);
     this.listenerKeys.length = 0;
   }
   this.map_ = map;

src/ol/format/geojsonformat.js

@@ -3,7 +3,6 @@
 
 goog.provide('ol.format.GeoJSON');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.object');
 goog.require('ol.Feature');
@@ -90,7 +89,7 @@ ol.format.GeoJSON.readGeometryCollectionGeometry_ = function(
     object, opt_options) {
   goog.asserts.assert(object.type == 'GeometryCollection',
       'object.type should be GeometryCollection');
-  var geometries = goog.array.map(object.geometries,
+  var geometries = object.geometries.map(
       /**
        * @param {GeoJSONGeometry} geometry Geometry.
        * @return {ol.geom.Geometry} geometry Geometry.
@@ -212,10 +211,9 @@ ol.format.GeoJSON.writeGeometryCollectionGeometry_ = function(
     geometry, opt_options) {
   goog.asserts.assertInstanceof(geometry, ol.geom.GeometryCollection,
       'geometry should be an ol.geom.GeometryCollection');
-  var geometries = goog.array.map(
+  var geometries = geometry.getGeometriesArray().map(function(geometry) {
-      geometry.getGeometriesArray(), function(geometry) {
+    return ol.format.GeoJSON.writeGeometry_(geometry, opt_options);
-        return ol.format.GeoJSON.writeGeometry_(geometry, opt_options);
+  });
-      });
   return /** @type {GeoJSONGeometryCollection} */ ({
     type: 'GeometryCollection',
     geometries: geometries

src/ol/format/gml/gmlbaseformat.js

@@ -122,7 +122,7 @@ ol.format.GMLBase.prototype.readFeaturesInternal = function(node, objectStack) {
         var child = node.childNodes[i];
         if (child.nodeType === 1) {
           var ft = child.nodeName.split(':').pop();
-          if (goog.array.indexOf(featureType, ft) === -1) {
+          if (featureType.indexOf(ft) === -1) {
             var key;
             if (!goog.object.contains(featureNS, child.namespaceURI)) {
               key = prefix + goog.object.getCount(featureNS);

src/ol/format/wmscapabilitiesformat.js

@@ -1,6 +1,5 @@
 goog.provide('ol.format.WMSCapabilities');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.dom.NodeType');
 goog.require('goog.object');
@@ -344,7 +343,7 @@ ol.format.WMSCapabilities.readLayer_ = function(node, objectStack) {
 
   // See 7.2.4.8
   var addKeys = ['Style', 'CRS', 'AuthorityURL'];
-  goog.array.forEach(addKeys, function(key) {
+  addKeys.forEach(function(key) {
     if (key in parentLayerObject) {
       var childValue = goog.object.setIfUndefined(layerObject, key, []);
       childValue = childValue.concat(parentLayerObject[key]);
@@ -354,7 +353,7 @@ ol.format.WMSCapabilities.readLayer_ = function(node, objectStack) {
 
   var replaceKeys = ['EX_GeographicBoundingBox', 'BoundingBox', 'Dimension',
     'Attribution', 'MinScaleDenominator', 'MaxScaleDenominator'];
-  goog.array.forEach(replaceKeys, function(key) {
+  replaceKeys.forEach(function(key) {
     if (!(key in layerObject)) {
       var parentValue = parentLayerObject[key];
       layerObject[key] = parentValue;

src/ol/format/wmsgetfeatureinfoformat.js

@@ -75,9 +75,10 @@ ol.format.WMSGetFeatureInfo.prototype.readFeatures_ =
     return features;
   }
   if (localName == 'msGMLOutput') {
-    goog.array.forEach(node.childNodes, function(layer) {
+    for (var i = 0, ii = node.childNodes.length; i < ii; i++) {
+      var layer = node.childNodes[i];
       if (layer.nodeType !== goog.dom.NodeType.ELEMENT) {
-        return;
+        continue;
       }
       var context = objectStack[0];
       goog.asserts.assert(goog.isObject(context),
@@ -105,7 +106,7 @@ ol.format.WMSGetFeatureInfo.prototype.readFeatures_ =
       if (layerFeatures) {
         goog.array.extend(features, layerFeatures);
       }
-    }, this);
+    }
   }
   if (localName == 'FeatureCollection') {
     var gmlFeatures = ol.xml.pushParseAndPop([],

src/ol/image.js

@@ -1,6 +1,5 @@
 goog.provide('ol.Image');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.events.EventType');
@@ -151,6 +150,6 @@ ol.Image.prototype.load = function() {
 ol.Image.prototype.unlistenImage_ = function() {
   goog.asserts.assert(!goog.isNull(this.imageListenerKeys_),
       'this.imageListenerKeys_ should not be null');
-  goog.array.forEach(this.imageListenerKeys_, goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
   this.imageListenerKeys_ = null;
 };

src/ol/imagetile.js

@@ -1,6 +1,5 @@
 goog.provide('ol.ImageTile');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.events.EventType');
@@ -163,6 +162,6 @@ ol.ImageTile.prototype.load = function() {
 ol.ImageTile.prototype.unlistenImage_ = function() {
   goog.asserts.assert(!goog.isNull(this.imageListenerKeys_),
       'this.imageListenerKeys_ should not be null');
-  goog.array.forEach(this.imageListenerKeys_, goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
   this.imageListenerKeys_ = null;
 };

src/ol/interaction/snapinteraction.js

@@ -1,7 +1,6 @@
 goog.provide('ol.interaction.Snap');
 goog.provide('ol.interaction.SnapProperty');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.events.EventType');
@@ -321,7 +320,7 @@ ol.interaction.Snap.prototype.setMap = function(map) {
   var features = this.getFeatures_();
 
   if (currentMap) {
-    goog.array.forEach(keys, ol.Observable.unByKey);
+    keys.forEach(ol.Observable.unByKey);
     keys.length = 0;
     features.forEach(this.forEachFeatureRemove_, this);
   }
@@ -600,7 +599,7 @@ ol.interaction.Snap.handleEvent_ = function(evt) {
 ol.interaction.Snap.handleUpEvent_ = function(evt) {
   var featuresToUpdate = goog.object.getValues(this.pendingFeatures_);
   if (featuresToUpdate.length) {
-    goog.array.forEach(featuresToUpdate, this.updateFeature_, this);
+    featuresToUpdate.forEach(this.updateFeature_, this);
     this.pendingFeatures_ = {};
   }
   return false;

src/ol/layer/layergroup.js

@@ -1,6 +1,5 @@
 goog.provide('ol.layer.Group');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.events.EventType');
@@ -95,7 +94,7 @@ ol.layer.Group.prototype.handleLayerChange_ = function() {
  * @private
  */
 ol.layer.Group.prototype.handleLayersChanged_ = function(event) {
-  goog.array.forEach(this.layersListenerKeys_, goog.events.unlistenByKey);
+  this.layersListenerKeys_.forEach(goog.events.unlistenByKey);
   this.layersListenerKeys_.length = 0;
 
   var layers = this.getLayers();
@@ -106,7 +105,7 @@ ol.layer.Group.prototype.handleLayersChanged_ = function(event) {
           this.handleLayersRemove_, false, this));
 
   goog.object.forEach(this.listenerKeys_, function(keys) {
-    goog.array.forEach(keys, goog.events.unlistenByKey);
+    keys.forEach(goog.events.unlistenByKey);
   });
   goog.object.clear(this.listenerKeys_);
 
@@ -153,7 +152,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');
-  goog.array.forEach(this.listenerKeys_[key], goog.events.unlistenByKey);
+  this.listenerKeys_[key].forEach(goog.events.unlistenByKey);
   delete this.listenerKeys_[key];
   this.changed();
 };

src/ol/map.js

@@ -1119,8 +1119,7 @@ ol.Map.prototype.handleLayerGroupPropertyChanged_ = function(event) {
  */
 ol.Map.prototype.handleLayerGroupChanged_ = function() {
   if (!goog.isNull(this.layerGroupPropertyListenerKeys_)) {
-    goog.array.forEach(this.layerGroupPropertyListenerKeys_,
+    this.layerGroupPropertyListenerKeys_.forEach(goog.events.unlistenByKey);
-        goog.events.unlistenByKey);
     this.layerGroupPropertyListenerKeys_ = null;
   }
   var layerGroup = this.getLayerGroup();

src/ol/mapbrowserevent.js

@@ -3,7 +3,6 @@ goog.provide('ol.MapBrowserEvent.EventType');
 goog.provide('ol.MapBrowserEventHandler');
 goog.provide('ol.MapBrowserPointerEvent');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.events.BrowserEvent');
@@ -293,7 +292,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) {
-    goog.array.forEach(this.dragListenerKeys_, goog.events.unlistenByKey);
+    this.dragListenerKeys_.forEach(goog.events.unlistenByKey);
     this.dragListenerKeys_ = null;
     this.dragging_ = false;
     this.down_ = null;
@@ -427,7 +426,7 @@ ol.MapBrowserEventHandler.prototype.disposeInternal = function() {
     this.pointerdownListenerKey_ = null;
   }
   if (!goog.isNull(this.dragListenerKeys_)) {
-    goog.array.forEach(this.dragListenerKeys_, goog.events.unlistenByKey);
+    this.dragListenerKeys_.forEach(goog.events.unlistenByKey);
     this.dragListenerKeys_ = null;
   }
   if (!goog.isNull(this.documentPointerEventHandler_)) {

src/ol/pointer/pointereventhandler.js

@@ -30,7 +30,6 @@
 
 goog.provide('ol.pointer.PointerEventHandler');
 
-goog.require('goog.array');
 goog.require('goog.dom');
 goog.require('goog.events');
 goog.require('goog.events.BrowserEvent');
@@ -119,7 +118,7 @@ ol.pointer.PointerEventHandler.prototype.registerSource =
   var newEvents = s.getEvents();
 
   if (newEvents) {
-    goog.array.forEach(newEvents, function(e) {
+    newEvents.forEach(function(e) {
       var handler = s.getHandlerForEvent(e);
 
       if (handler) {
@@ -179,7 +178,7 @@ ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) {
  * @param {Array.<string>} events List of events.
  */
 ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) {
-  goog.array.forEach(events, function(eventName) {
+  events.forEach(function(eventName) {
     goog.events.listen(this.element_, eventName,
         this.eventHandler_, false, this);
   }, this);
@@ -192,7 +191,7 @@ ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) {
  * @param {Array.<string>} events List of events.
  */
 ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) {
-  goog.array.forEach(events, function(e) {
+  events.forEach(function(e) {
     goog.events.unlisten(this.element_, e,
         this.eventHandler_, false, this);
   }, this);

src/ol/proj/epsg3857projection.js

@@ -1,6 +1,5 @@
 goog.provide('ol.proj.EPSG3857');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('ol.math');
 goog.require('ol.proj');
@@ -91,11 +90,9 @@ ol.proj.EPSG3857.CODES = [
  * @const
  * @type {Array.<ol.proj.Projection>}
  */
-ol.proj.EPSG3857.PROJECTIONS = goog.array.map(
+ol.proj.EPSG3857.PROJECTIONS = ol.proj.EPSG3857.CODES.map(function(code) {
-    ol.proj.EPSG3857.CODES,
+  return new ol.proj.EPSG3857_(code);
-    function(code) {
+});
-      return new ol.proj.EPSG3857_(code);
-    });
 
 
 /**

src/ol/proj/proj.js

@@ -4,7 +4,6 @@ goog.provide('ol.proj.Projection');
 goog.provide('ol.proj.ProjectionLike');
 goog.provide('ol.proj.Units');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.object');
 goog.require('ol');
@@ -412,8 +411,8 @@ ol.proj.transforms_ = {};
  */
 ol.proj.addEquivalentProjections = function(projections) {
   ol.proj.addProjections(projections);
-  goog.array.forEach(projections, function(source) {
+  projections.forEach(function(source) {
-    goog.array.forEach(projections, function(destination) {
+    projections.forEach(function(destination) {
       if (source !== destination) {
         ol.proj.addTransform(source, destination, ol.proj.cloneTransform);
       }
@@ -437,8 +436,8 @@ ol.proj.addEquivalentProjections = function(projections) {
  */
 ol.proj.addEquivalentTransforms =
     function(projections1, projections2, forwardTransform, inverseTransform) {
-  goog.array.forEach(projections1, function(projection1) {
+  projections1.forEach(function(projection1) {
-    goog.array.forEach(projections2, function(projection2) {
+    projections2.forEach(function(projection2) {
       ol.proj.addTransform(projection1, projection2, forwardTransform);
       ol.proj.addTransform(projection2, projection1, inverseTransform);
     });
@@ -464,7 +463,7 @@ ol.proj.addProjection = function(projection) {
  */
 ol.proj.addProjections = function(projections) {
   var addedProjections = [];
-  goog.array.forEach(projections, function(projection) {
+  projections.forEach(function(projection) {
     addedProjections.push(ol.proj.addProjection(projection));
   });
 };

src/ol/render/box.js

@@ -3,7 +3,6 @@
 goog.provide('ol.render.Box');
 
 goog.require('goog.Disposable');
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('ol.geom.Polygon');
@@ -76,8 +75,7 @@ ol.render.Box.prototype.createGeometry_ = function() {
     endPixel,
     [endPixel[0], startPixel[1]]
   ];
-  var coordinates = goog.array.map(pixels,
+  var coordinates = pixels.map(this.map_.getCoordinateFromPixel, this.map_);
-      this.map_.getCoordinateFromPixel, this.map_);
   // close the polygon
   coordinates[4] = coordinates[0].slice();
   return new ol.geom.Polygon([coordinates]);

src/ol/render/canvas/canvasimmediate.js

@@ -725,7 +725,7 @@ ol.render.canvas.Immediate.prototype.drawText = goog.abstractMethod;
  */
 ol.render.canvas.Immediate.prototype.flush = function() {
   /** @type {Array.<number>} */
-  var zs = goog.array.map(goog.object.getKeys(this.callbacksByZIndex_), Number);
+  var zs = goog.object.getKeys(this.callbacksByZIndex_).map(Number);
   goog.array.sort(zs);
   var i, ii, callbacks, j, jj;
   for (i = 0, ii = zs.length; i < ii; ++i) {

src/ol/render/canvas/canvasreplay.js

@@ -1960,7 +1960,7 @@ ol.render.canvas.ReplayGroup.prototype.replay = function(
     context, pixelRatio, transform, viewRotation, skippedFeaturesHash) {
 
   /** @type {Array.<number>} */
-  var zs = goog.array.map(goog.object.getKeys(this.replaysByZIndex_), Number);
+  var zs = goog.object.getKeys(this.replaysByZIndex_).map(Number);
   goog.array.sort(zs);
 
   // setup clipping so that the parts of over-simplified geometries are not
@@ -2015,7 +2015,7 @@ ol.render.canvas.ReplayGroup.prototype.replayHitDetection_ = function(
     context, transform, viewRotation, skippedFeaturesHash,
     featureCallback, opt_hitExtent) {
   /** @type {Array.<number>} */
-  var zs = goog.array.map(goog.object.getKeys(this.replaysByZIndex_), Number);
+  var zs = goog.object.getKeys(this.replaysByZIndex_).map(Number);
   goog.array.sort(zs, function(a, b) { return b - a; });
 
   var i, ii, j, replays, replay, result;

src/ol/render/webgl/webglimmediate.js

@@ -80,7 +80,7 @@ goog.inherits(ol.render.webgl.Immediate, ol.render.VectorContext);
  */
 ol.render.webgl.Immediate.prototype.flush = function() {
   /** @type {Array.<number>} */
-  var zs = goog.array.map(goog.object.getKeys(this.callbacksByZIndex_), Number);
+  var zs = goog.object.getKeys(this.callbacksByZIndex_).map(Number);
   goog.array.sort(zs);
   var i, ii, callbacks, j, jj;
   for (i = 0, ii = zs.length; i < ii; ++i) {

src/ol/renderer/canvas/canvastilelayerrenderer.js

@@ -354,7 +354,7 @@ ol.renderer.canvas.TileLayer.prototype.prepareFrame =
   }
 
   /** @type {Array.<number>} */
-  var zs = goog.array.map(goog.object.getKeys(tilesToDrawByZ), Number);
+  var zs = goog.object.getKeys(tilesToDrawByZ).map(Number);
   goog.array.sort(zs);
   var opaque = tileSource.getOpaque();
   var origin = ol.extent.getTopLeft(tileGrid.getTileCoordExtent(

src/ol/renderer/canvas/canvasvectorlayerrenderer.js

@@ -301,7 +301,7 @@ ol.renderer.canvas.VectorLayer.prototype.prepareFrame =
           features.push(feature);
         }, this);
     goog.array.sort(features, vectorLayerRenderOrder);
-    goog.array.forEach(features, renderFeature, this);
+    features.forEach(renderFeature, this);
   } else {
     vectorSource.forEachFeatureInExtentAtResolution(
         extent, resolution, renderFeature, this);

src/ol/renderer/dom/domtilelayerrenderer.js

@@ -172,7 +172,7 @@ ol.renderer.dom.TileLayer.prototype.prepareFrame =
   }
 
   /** @type {Array.<number>} */
-  var zs = goog.array.map(goog.object.getKeys(tilesToDrawByZ), Number);
+  var zs = goog.object.getKeys(tilesToDrawByZ).map(Number);
   goog.array.sort(zs);
 
   /** @type {Object.<number, boolean>} */
@@ -198,8 +198,7 @@ ol.renderer.dom.TileLayer.prototype.prepareFrame =
   }
 
   /** @type {Array.<number>} */
-  var tileLayerZKeys =
+  var tileLayerZKeys = goog.object.getKeys(this.tileLayerZs_).map(Number);
-      goog.array.map(goog.object.getKeys(this.tileLayerZs_), Number);
   goog.array.sort(tileLayerZKeys);
 
   var i, ii, j, origin, resolution;

src/ol/renderer/dom/domvectorlayerrenderer.js

@@ -309,7 +309,7 @@ ol.renderer.dom.VectorLayer.prototype.prepareFrame =
           features.push(feature);
         }, this);
     goog.array.sort(features, vectorLayerRenderOrder);
-    goog.array.forEach(features, renderFeature, this);
+    features.forEach(renderFeature, this);
   } else {
     vectorSource.forEachFeatureInExtentAtResolution(
         extent, resolution, renderFeature, this);

src/ol/renderer/webgl/webgltilelayerrenderer.js

@@ -286,7 +286,7 @@ ol.renderer.webgl.TileLayer.prototype.prepareFrame =
     }
 
     /** @type {Array.<number>} */
-    var zs = goog.array.map(goog.object.getKeys(tilesToDrawByZ), Number);
+    var zs = goog.object.getKeys(tilesToDrawByZ).map(Number);
     goog.array.sort(zs);
     var u_tileOffset = goog.vec.Vec4.createFloat32();
     var i, ii, sx, sy, tileKey, tilesToDraw, tx, ty;

src/ol/renderer/webgl/webglvectorlayerrenderer.js

@@ -277,7 +277,7 @@ ol.renderer.webgl.VectorLayer.prototype.prepareFrame =
           features.push(feature);
         }, this);
     goog.array.sort(features, vectorLayerRenderOrder);
-    goog.array.forEach(features, renderFeature, this);
+    features.forEach(renderFeature, this);
   } else {
     vectorSource.forEachFeatureInExtentAtResolution(
         extent, resolution, renderFeature, this);

src/ol/source/bingmapssource.js

@@ -1,7 +1,6 @@
 goog.provide('ol.source.BingMaps');
 
 goog.require('goog.Uri');
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.net.Jsonp');
 goog.require('ol.Attribution');
@@ -115,67 +114,60 @@ ol.source.BingMaps.prototype.handleImageryMetadataResponse =
 
   var culture = this.culture_;
   this.tileUrlFunction = ol.TileUrlFunction.createFromTileUrlFunctions(
-      goog.array.map(
+      resource.imageUrlSubdomains.map(function(subdomain) {
-          resource.imageUrlSubdomains,
+        var quadKeyTileCoord = [0, 0, 0];
-          function(subdomain) {
+        var imageUrl = resource.imageUrl
-            var quadKeyTileCoord = [0, 0, 0];
+            .replace('{subdomain}', subdomain)
-            var imageUrl = resource.imageUrl
+            .replace('{culture}', culture);
-                .replace('{subdomain}', subdomain)
+        return (
-                .replace('{culture}', culture);
+            /**
-            return (
+             * @param {ol.TileCoord} tileCoord Tile coordinate.
-                /**
+             * @param {number} pixelRatio Pixel ratio.
-                 * @param {ol.TileCoord} tileCoord Tile coordinate.
+             * @param {ol.proj.Projection} projection Projection.
-                 * @param {number} pixelRatio Pixel ratio.
+             * @return {string|undefined} Tile URL.
-                 * @param {ol.proj.Projection} projection Projection.
+             */
-                 * @return {string|undefined} Tile URL.
+            function(tileCoord, pixelRatio, projection) {
-                 */
+              goog.asserts.assert(ol.proj.equivalent(
-                function(tileCoord, pixelRatio, projection) {
+                  projection, sourceProjection),
-                  goog.asserts.assert(ol.proj.equivalent(
+                  'projections are equivalent');
-                      projection, sourceProjection),
+              if (goog.isNull(tileCoord)) {
-                      'projections are equivalent');
+                return undefined;
-                  if (goog.isNull(tileCoord)) {
+              } else {
-                    return undefined;
+                ol.tilecoord.createOrUpdate(tileCoord[0], tileCoord[1],
-                  } else {
+                    -tileCoord[2] - 1, quadKeyTileCoord);
-                    ol.tilecoord.createOrUpdate(tileCoord[0], tileCoord[1],
+                return imageUrl.replace('{quadkey}', ol.tilecoord.quadKey(
-                        -tileCoord[2] - 1, quadKeyTileCoord);
+                    quadKeyTileCoord));
-                    return imageUrl.replace('{quadkey}', ol.tilecoord.quadKey(
+              }
-                        quadKeyTileCoord));
+            });
-                  }
+      }));
-                });
-          }));
 
   if (resource.imageryProviders) {
     var transform = ol.proj.getTransformFromProjections(
         ol.proj.get('EPSG:4326'), this.getProjection());
 
-    var attributions = goog.array.map(
+    var attributions = resource.imageryProviders.map(function(imageryProvider) {
-        resource.imageryProviders,
+      var html = imageryProvider.attribution;
-        function(imageryProvider) {
+      /** @type {Object.<string, Array.<ol.TileRange>>} */
-          var html = imageryProvider.attribution;
+      var tileRanges = {};
-          /** @type {Object.<string, Array.<ol.TileRange>>} */
+      imageryProvider.coverageAreas.forEach(function(coverageArea) {
-          var tileRanges = {};
+        var minZ = coverageArea.zoomMin;
-          goog.array.forEach(
+        var maxZ = Math.min(coverageArea.zoomMax, maxZoom);
-              imageryProvider.coverageAreas,
+        var bbox = coverageArea.bbox;
-              function(coverageArea) {
+        var epsg4326Extent = [bbox[1], bbox[0], bbox[3], bbox[2]];
-                var minZ = coverageArea.zoomMin;
+        var extent = ol.extent.applyTransform(epsg4326Extent, transform);
-                var maxZ = Math.min(coverageArea.zoomMax, maxZoom);
+        var tileRange, z, zKey;
-                var bbox = coverageArea.bbox;
+        for (z = minZ; z <= maxZ; ++z) {
-                var epsg4326Extent = [bbox[1], bbox[0], bbox[3], bbox[2]];
+          zKey = z.toString();
-                var extent = ol.extent.applyTransform(
+          tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
-                    epsg4326Extent, transform);
+          if (zKey in tileRanges) {
-                var tileRange, z, zKey;
+            tileRanges[zKey].push(tileRange);
-                for (z = minZ; z <= maxZ; ++z) {
+          } else {
-                  zKey = z.toString();
+            tileRanges[zKey] = [tileRange];
-                  tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
+          }
-                  if (zKey in tileRanges) {
+        }
-                    tileRanges[zKey].push(tileRange);
+      });
-                  } else {
+      return new ol.Attribution({html: html, tileRanges: tileRanges});
-                    tileRanges[zKey] = [tileRange];
+    });
-                  }
-                }
-              });
-          return new ol.Attribution({html: html, tileRanges: tileRanges});
-        });
     attributions.push(ol.source.BingMaps.TOS_ATTRIBUTION);
     this.setAttributions(attributions);
   }

src/ol/source/clustersource.js

@@ -3,7 +3,6 @@
 
 goog.provide('ol.source.Cluster');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events.EventType');
 goog.require('goog.object');
@@ -128,7 +127,7 @@ ol.source.Cluster.prototype.cluster_ = function() {
 
       var neighbors = this.source_.getFeaturesInExtent(extent);
       goog.asserts.assert(neighbors.length >= 1, 'at least one neighbor found');
-      neighbors = goog.array.filter(neighbors, function(neighbor) {
+      neighbors = neighbors.filter(function(neighbor) {
         var uid = goog.getUid(neighbor).toString();
         if (!goog.object.containsKey(clustered, uid)) {
           clustered[uid] = true;

src/ol/source/vectorsource.js

@@ -374,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];
-      goog.array.forEach(keys, goog.events.unlistenByKey);
+      keys.forEach(goog.events.unlistenByKey);
     }
     if (goog.isNull(this.featuresCollection_)) {
       this.featureChangeKeys_ = {};
@@ -823,8 +823,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');
-  goog.array.forEach(this.featureChangeKeys_[featureKey],
+  this.featureChangeKeys_[featureKey].forEach(goog.events.unlistenByKey);
-      goog.events.unlistenByKey);
   delete this.featureChangeKeys_[featureKey];
   var id = feature.getId();
   if (id !== undefined) {

src/ol/source/wmtssource.js

@@ -178,7 +178,7 @@ ol.source.WMTS = function(options) {
 
   var tileUrlFunction = this.urls_.length > 0 ?
       ol.TileUrlFunction.createFromTileUrlFunctions(
-          goog.array.map(this.urls_, createFromWMTSTemplate)) :
+          this.urls_.map(createFromWMTSTemplate)) :
       ol.TileUrlFunction.nullTileUrlFunction;
 
   goog.base(this, {
@@ -402,7 +402,7 @@ ol.source.WMTS.optionsFromCapabilities = function(wmtsCap, config) {
 
   var dimensions = {};
   if ('Dimension' in l) {
-    goog.array.forEach(l['Dimension'], function(elt, index, array) {
+    l['Dimension'].forEach(function(elt, index, array) {
       var key = elt['Identifier'];
       var value = elt['default'];
       if (value !== undefined) {
@@ -467,7 +467,7 @@ ol.source.WMTS.optionsFromCapabilities = function(wmtsCap, config) {
       goog.string.startsWith(requestEncoding, 'REST')) {
     // Add REST tile resource url
     requestEncoding = ol.source.WMTSRequestEncoding.REST;
-    goog.array.forEach(l['ResourceURL'], function(elt, index, array) {
+    l['ResourceURL'].forEach(function(elt, index, array) {
       if (elt['resourceType'] == 'tile') {
         format = elt['format'];
         urls.push(/** @type {string} */ (elt['template']));

src/ol/structs/rbush.js

@@ -1,6 +1,5 @@
 goog.provide('ol.structs.RBush');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.object');
 goog.require('ol.ext.rbush');
@@ -150,7 +149,7 @@ ol.structs.RBush.prototype.update = function(extent, value) {
  */
 ol.structs.RBush.prototype.getAll = function() {
   var items = this.rbush_.all();
-  return goog.array.map(items, function(item) {
+  return items.map(function(item) {
     return item[4];
   });
 };
@@ -163,7 +162,7 @@ ol.structs.RBush.prototype.getAll = function() {
  */
 ol.structs.RBush.prototype.getInExtent = function(extent) {
   var items = this.rbush_.search(extent);
-  return goog.array.map(items, function(item) {
+  return items.map(function(item) {
     return item[4];
   });
 };

src/ol/style/iconstyle.js

@@ -3,7 +3,6 @@ goog.provide('ol.style.IconAnchorUnits');
 goog.provide('ol.style.IconImageCache');
 goog.provide('ol.style.IconOrigin');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.events.EventTarget');
@@ -581,7 +580,7 @@ ol.style.IconImage_.prototype.load = function() {
 ol.style.IconImage_.prototype.unlistenImage_ = function() {
   goog.asserts.assert(!goog.isNull(this.imageListenerKeys_),
       'we must have listeners registered');
-  goog.array.forEach(this.imageListenerKeys_, goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
   this.imageListenerKeys_ = null;
 };
 

src/ol/tilecoord.js

@@ -1,7 +1,6 @@
 goog.provide('ol.TileCoord');
 goog.provide('ol.tilecoord');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('ol.extent');
 
@@ -35,10 +34,9 @@ ol.tilecoord.createFromString = function(str) {
   var v = str.split('/');
   goog.asserts.assert(v.length === 3,
       'must provide a string in "z/x/y" format, got "%s"', str);
-  v = goog.array.map(v, function(e, i, a) {
+  return v.map(function(e) {
     return parseInt(e, 10);
   });
-  return v;
 };
 
 

src/ol/tilegrid/tilegrid.js

@@ -121,7 +121,7 @@ ol.tilegrid.TileGrid = function(options) {
   if (options.sizes !== undefined) {
     goog.asserts.assert(options.sizes.length == this.resolutions_.length,
         'number of sizes and resolutions must be equal');
-    this.fullTileRanges_ = goog.array.map(options.sizes, function(size, z) {
+    this.fullTileRanges_ = options.sizes.map(function(size, z) {
       goog.asserts.assert(size[0] !== 0, 'width must not be 0');
       goog.asserts.assert(size[1] !== 0, 'height must not be 0');
       var tileRange = new ol.TileRange(

src/ol/tilegrid/wmtstilegrid.js

@@ -108,25 +108,23 @@ ol.tilegrid.WMTS.createFromCapabilitiesMatrixSet =
     return b[scaleDenominatorPropName] - a[scaleDenominatorPropName];
   });
 
-  goog.array.forEach(matrixSet[matrixIdsPropName],
+  matrixSet[matrixIdsPropName].forEach(function(elt, index, array) {
-      function(elt, index, array) {
+    matrixIds.push(elt[identifierPropName]);
-        matrixIds.push(elt[identifierPropName]);
+    var resolution = elt[scaleDenominatorPropName] * 0.28E-3 / metersPerUnit;
-        var resolution = elt[scaleDenominatorPropName] * 0.28E-3 /
+    var tileWidth = elt[tileWidthPropName];
-            metersPerUnit;
+    var tileHeight = elt[tileHeightPropName];
-        var tileWidth = elt[tileWidthPropName];
+    if (switchOriginXY) {
-        var tileHeight = elt[tileHeightPropName];
+      origins.push([elt[topLeftCornerPropName][1],
-        if (switchOriginXY) {
+        elt[topLeftCornerPropName][0]]);
-          origins.push([elt[topLeftCornerPropName][1],
+    } else {
-            elt[topLeftCornerPropName][0]]);
+      origins.push(elt[topLeftCornerPropName]);
-        } else {
+    }
-          origins.push(elt[topLeftCornerPropName]);
+    resolutions.push(resolution);
-        }
+    tileSizes.push(tileWidth == tileHeight ?
-        resolutions.push(resolution);
+        tileWidth : [tileWidth, tileHeight]);
-        tileSizes.push(tileWidth == tileHeight ?
+    // top-left origin, so height is negative
-            tileWidth : [tileWidth, tileHeight]);
+    sizes.push([elt['MatrixWidth'], -elt['MatrixHeight']]);
-        // top-left origin, so height is negative
+  });
-        sizes.push([elt['MatrixWidth'], -elt['MatrixHeight']]);
-      });
 
   return new ol.tilegrid.WMTS({
     extent: opt_extent,

src/ol/tileurlfunction.js

@@ -1,7 +1,6 @@
 goog.provide('ol.TileUrlFunction');
 goog.provide('ol.TileUrlFunctionType');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.math');
 goog.require('ol.TileCoord');
@@ -73,7 +72,7 @@ ol.TileUrlFunction.createFromTemplate = function(template) {
  */
 ol.TileUrlFunction.createFromTemplates = function(templates) {
   return ol.TileUrlFunction.createFromTileUrlFunctions(
-      goog.array.map(templates, ol.TileUrlFunction.createFromTemplate));
+      templates.map(ol.TileUrlFunction.createFromTemplate));
 };
 
 

test/spec/ol/interaction/modifyinteraction.test.js

@@ -270,7 +270,7 @@ describe('ol.interaction.Modify', function() {
       getListeners = function(feature, modify) {
         var listeners = goog.events.getListeners(
             feature, goog.events.EventType.CHANGE, false);
-        return goog.array.filter(listeners, function(listener) {
+        return listeners.filter(function(listener) {
           return listener.handler == modify;
         });
       };
@@ -317,7 +317,6 @@ describe('ol.interaction.Modify', function() {
 
 });
 
-goog.require('goog.array');
 goog.require('goog.dispose');
 goog.require('goog.events');
 goog.require('goog.events.EventType');

test/spec/ol/proj/proj.test.js

@@ -10,9 +10,9 @@ describe('ol.proj', function() {
   describe('projection equivalence', function() {
 
     function _testAllEquivalent(codes) {
-      var projections = goog.array.map(codes, ol.proj.get);
+      var projections = codes.map(ol.proj.get);
-      goog.array.forEach(projections, function(source) {
+      projections.forEach(function(source) {
-        goog.array.forEach(projections, function(destination) {
+        projections.forEach(function(destination) {
           expect(ol.proj.equivalent(source, destination)).to.be.ok();
         });
       });
@@ -522,7 +522,6 @@ describe('ol.proj', function() {
 });
 
 
-goog.require('goog.array');
 goog.require('ol.proj');
 goog.require('ol.proj.Projection');
 goog.require('ol.proj.Units');

test_rendering/spec/ol/layer/image.test.js

@@ -29,7 +29,7 @@ describe('ol.rendering.layer.Image', function() {
       }
     };
 
-    goog.array.forEach(sources, function(source) {
+    sources.forEach(function(source) {
       source.on('imageloadstart', function(event) {
         imagesLoading++;
       });
@@ -84,7 +84,6 @@ describe('ol.rendering.layer.Image', function() {
   });
 });
 
-goog.require('goog.array');
 goog.require('goog.object');
 goog.require('ol.proj');
 goog.require('ol.Map');

test_rendering/spec/ol/layer/tile.test.js

@@ -29,7 +29,7 @@ describe('ol.rendering.layer.Tile', function() {
       }
     };
 
-    goog.array.forEach(sources, function(source) {
+    sources.forEach(function(source) {
       source.on('tileloadstart', function(event) {
         tilesLoading++;
       });
@@ -190,7 +190,6 @@ describe('ol.rendering.layer.Tile', function() {
 
 });
 
-goog.require('goog.array');
 goog.require('goog.object');
 goog.require('ol.proj');
 goog.require('ol.Map');