Merge pull request #631 from twpayne/dont-use-foreach-in-loops

Don't use forEach in loops

src/ol/attribution.js

@@ -42,13 +42,13 @@ ol.Attribution.prototype.intersectsAnyTileRange = function(tileRanges) {
   if (goog.isNull(this.tileRanges_)) {
     return true;
   }
-  var i, tileRange, z;
+  var i, ii, tileRange, z;
   for (z in tileRanges) {
     if (!(z in this.tileRanges_)) {
       continue;
     }
     tileRange = tileRanges[z];
-    for (i = 0; i < this.tileRanges_[z].length; ++i) {
+    for (i = 0, ii = this.tileRanges_[z].length; i < ii; ++i) {
       if (this.tileRanges_[z][i].intersects(tileRange)) {
         return true;
       }

src/ol/collection.js

@@ -87,8 +87,8 @@ ol.Collection.prototype.clear = function() {
  * @param {Array} arr Array.
  */
 ol.Collection.prototype.extend = function(arr) {
-  var i;
-  for (i = 0; i < arr.length; ++i) {
+  var i, ii;
+  for (i = 0, ii = arr.length; i < ii; ++i) {
     this.push(arr[i]);
   }
 };
@@ -165,9 +165,10 @@ ol.Collection.prototype.push = function(elem) {
  * @return {*} The removed element or undefined if elem was not found.
  */
 ol.Collection.prototype.remove = function(elem) {
-  var i;
-  for (i = 0; i < this.array_.length; ++i) {
-    if (this.array_[i] === elem) {
+  var arr = this.array_;
+  var i, ii;
+  for (i = 0, ii = arr.length; i < ii; ++i) {
+    if (arr[i] === elem) {
       return this.removeAt(i);
     }
   }

src/ol/map.js

@@ -617,8 +617,9 @@ ol.Map.prototype.handleMapBrowserEvent = function(mapBrowserEvent) {
   var interactions = this.getInteractions();
   var interactionsArray = /** @type {Array.<ol.interaction.Interaction>} */
       (interactions.getArray());
+  var i;
   if (this.dispatchEvent(mapBrowserEvent) !== false) {
-    for (var i = interactionsArray.length - 1; i >= 0; i--) {
+    for (i = interactionsArray.length - 1; i >= 0; i--) {
       var interaction = interactionsArray[i];
       interaction.handleMapBrowserEvent(mapBrowserEvent);
       if (mapBrowserEvent.defaultPrevented) {
@@ -663,8 +664,8 @@ ol.Map.prototype.handlePostRender = function() {
   }
 
   var postRenderFunctions = this.postRenderFunctions_;
-  var i;
-  for (i = 0; i < postRenderFunctions.length; ++i) {
+  var i, ii;
+  for (i = 0, ii = postRenderFunctions.length; i < ii; ++i) {
     postRenderFunctions[i](this, frameState);
   }
   postRenderFunctions.length = 0;
@@ -796,8 +797,8 @@ ol.Map.prototype.renderFrame_ = function(time) {
     var backgroundColor = this.getBackgroundColor();
     var viewHints = view.getHints();
     var layerStates = {};
-    var layer;
-    for (i = 0; i < layersArray.length; ++i) {
+    var ii, layer;
+    for (i = 0, ii = layersArray.length; i < ii; ++i) {
       layer = layersArray[i];
       layerStates[goog.getUid(layer)] = layer.getLayerState();
     }
@@ -828,7 +829,7 @@ ol.Map.prototype.renderFrame_ = function(time) {
 
   var preRenderFunctions = this.preRenderFunctions_;
   var n = 0, preRenderFunction;
-  for (i = 0; i < preRenderFunctions.length; ++i) {
+  for (i = 0, ii = preRenderFunctions.length; i < ii; ++i) {
     preRenderFunction = preRenderFunctions[i];
     if (preRenderFunction(this, frameState)) {
       preRenderFunctions[n++] = preRenderFunction;
@@ -1003,8 +1004,9 @@ ol.Map.createOptionsInternal = function(options) {
     rendererHints = ol.DEFAULT_RENDERER_HINTS;
   }
 
+  var n = rendererHints.length;
   var i, rendererHint;
-  for (i = 0; i < rendererHints.length; ++i) {
+  for (i = 0; i < n; ++i) {
     rendererHint = rendererHints[i];
     if (rendererHint == ol.RendererHint.CANVAS) {
       if (ol.ENABLE_CANVAS && ol.renderer.canvas.SUPPORTED) {

src/ol/parser/kml.js

@@ -270,7 +270,7 @@ ol.parser.KML = function(opt_options) {
         var reg = this.regExes;
         var coords = coordstr.replace(reg.trimSpace, '').split(reg.splitSpace);
         var coordArray = [];
-        for (var i = 0, len = coords.length; i < len; i++) {
+        for (var i = 0, ii = coords.length; i < ii; i++) {
           var array = coords[i].replace(reg.removeSpace, '').split(',');
           var pair = [];
           var jj = Math.min(array.length, this.dimension);

src/ol/parser/ogc/wmscapabilities_v1_1_0.js

@@ -16,7 +16,7 @@ ol.parser.ogc.WMSCapabilities_v1_1_0 = function() {
     'SRS': function(node, obj) {
       var srs = this.getChildValue(node);
       var values = srs.split(/ +/);
-      for (var i = 0, len = values.length; i < len; i++) {
+      for (var i = 0, ii = values.length; i < ii; i++) {
         obj['srs'][values[i]] = true;
       }
     }

src/ol/parser/ogc/wmscapabilities_v1_1_1_WMSC.js

@@ -24,7 +24,7 @@ ol.parser.ogc.WMSCapabilities_v1_1_1_WMSC = function() {
     },
     'Resolutions': function(node, tileset) {
       var res = this.getChildValue(node).split(' ');
-      for (var i = 0, len = res.length; i < len; i++) {
+      for (var i = 0, ii = res.length; i < ii; i++) {
         if (res[i] !== '') {
           tileset['resolutions'].push(parseFloat(res[i]));
         }

src/ol/renderer/canvas/canvasmaprenderer.js

@@ -2,7 +2,6 @@
 
 goog.provide('ol.renderer.canvas.Map');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.TagName');
@@ -119,18 +118,22 @@ ol.renderer.canvas.Map.prototype.renderFrame = function(frameState) {
 
   this.calculateMatrices2D(frameState);
 
-  goog.array.forEach(frameState.layersArray, function(layer) {
+  var layerStates = frameState.layerStates;
+  var layersArray = frameState.layersArray;
+  var i, ii, image, layer, layerRenderer, layerState, transform;
+  for (i = 0, ii = layersArray.length; i < ii; ++i) {
 
-    var layerRenderer = this.getLayerRenderer(layer);
-    var layerState = frameState.layerStates[goog.getUid(layer)];
+    layer = layersArray[i];
+    layerRenderer = this.getLayerRenderer(layer);
+    layerState = layerStates[goog.getUid(layer)];
     if (!layerState.visible || !layerState.ready) {
-      return;
+      continue;
     }
     layerRenderer.renderFrame(frameState, layerState);
 
-    var image = layerRenderer.getImage();
+    image = layerRenderer.getImage();
     if (!goog.isNull(image)) {
-      var transform = layerRenderer.getTransform();
+      transform = layerRenderer.getTransform();
       context.setTransform(
           goog.vec.Mat4.getElement(transform, 0, 0),
           goog.vec.Mat4.getElement(transform, 1, 0),
@@ -143,7 +146,7 @@ ol.renderer.canvas.Map.prototype.renderFrame = function(frameState) {
       context.drawImage(image, 0, 0);
     }
 
-  }, this);
+  }
 
   if (!this.renderedVisible_) {
     goog.style.showElement(this.canvas_, true);

src/ol/renderer/canvas/canvastilelayerrenderer.js

@@ -303,8 +303,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
     }
   }
 
-  var i;
-  for (i = 0; i < tilesToClear.length; ++i) {
+  var i, ii;
+  for (i = 0, ii = tilesToClear.length; i < ii; ++i) {
     tile = tilesToClear[i];
     x = tileSize.width * (tile.tileCoord.x - canvasTileRange.minX);
     y = tileSize.height * (canvasTileRange.maxY - tile.tileCoord.y);
@@ -321,7 +321,7 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
   var currentZ, index, scale, tileCoordKey, tileExtent, tilesToDraw;
   var ix, iy, interimTileExtent, interimTileRange, maxX, maxY;
   var height, width;
-  for (i = 0; i < zs.length; ++i) {
+  for (i = 0, ii = zs.length; i < ii; ++i) {
     currentZ = zs[i];
     tileSize = tileGrid.getTileSize(currentZ);
     tilesToDraw = tilesToDrawByZ[currentZ];

src/ol/renderer/dom/dommaprenderer.js

@@ -1,10 +1,8 @@
 goog.provide('ol.renderer.dom.Map');
 
-goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.TagName');
-goog.require('goog.object');
 goog.require('goog.style');
 goog.require('ol.css');
 goog.require('ol.layer.ImageLayer');
@@ -79,21 +77,25 @@ ol.renderer.dom.Map.prototype.renderFrame = function(frameState) {
     return;
   }
 
-  goog.array.forEach(frameState.layersArray, function(layer) {
-    var layerRenderer = this.getLayerRenderer(layer);
-    var layerState = frameState.layerStates[goog.getUid(layer)];
+  var layerStates = frameState.layerStates;
+  var layersArray = frameState.layersArray;
+  var i, ii, layer, layerRenderer, layerState;
+  for (i = 0, ii = layersArray.length; i < ii; ++i) {
+    layer = layersArray[i];
+    layerRenderer = this.getLayerRenderer(layer);
+    layerState = frameState.layerStates[goog.getUid(layer)];
     if (layerState.ready) {
       layerRenderer.renderFrame(frameState, layerState);
     }
-  }, this);
+  }
 
-  goog.object.forEach(
-      this.getLayerRenderers(),
-      function(layerRenderer, layerKey) {
-        if (!(layerKey in frameState.layerStates)) {
-          goog.dom.removeNode(layerRenderer.getTarget());
-        }
-      });
+  var layerKey;
+  for (layerKey in this.getLayerRenderers()) {
+    if (!(layerKey in layerStates)) {
+      layerRenderer = this.getLayerRendererByKey(layerKey);
+      goog.dom.removeNode(layerRenderer.getTarget());
+    }
+  }
 
   if (!this.renderedVisible_) {
     goog.style.showElement(this.layersPane_, true);

src/ol/renderer/dom/domtilelayerrenderer.js

@@ -155,8 +155,9 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
   /** @type {Object.<number, boolean>} */
   var newTileLayerZKeys = {};
 
-  var iz, tileCoordKey, tileCoordOrigin, tileLayerZ, tileLayerZKey, tilesToDraw;
-  for (iz = 0; iz < zs.length; ++iz) {
+  var iz, iziz;
+  var tileCoordKey, tileCoordOrigin, tileLayerZ, tileLayerZKey, tilesToDraw;
+  for (iz = 0, iziz = zs.length; iz < iziz; ++iz) {
     tileLayerZKey = zs[iz];
     if (tileLayerZKey in this.tileLayerZs_) {
       tileLayerZ = this.tileLayerZs_[tileLayerZKey];
@@ -179,9 +180,9 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
       goog.array.map(goog.object.getKeys(this.tileLayerZs_), Number);
   goog.array.sort(tileLayerZKeys);
 
-  var i, j, origin, resolution;
+  var i, ii, j, origin, resolution;
   var transform = goog.vec.Mat4.createNumber();
-  for (i = 0; i < tileLayerZKeys.length; ++i) {
+  for (i = 0, ii = tileLayerZKeys.length; i < ii; ++i) {
     tileLayerZKey = tileLayerZKeys[i];
     tileLayerZ = this.tileLayerZs_[tileLayerZKey];
     if (!(tileLayerZKey in tilesToDrawByZ)) {
@@ -371,8 +372,8 @@ ol.renderer.dom.TileLayerZ_.prototype.removeTilesOutsideExtent =
       tilesToRemove.push(tile);
     }
   }
-  var i;
-  for (i = 0; i < tilesToRemove.length; ++i) {
+  var i, ii;
+  for (i = 0, ii = tilesToRemove.length; i < ii; ++i) {
     tile = tilesToRemove[i];
     tileCoordKey = tile.tileCoord.toString();
     goog.dom.removeNode(tile.getImage(this));

src/ol/renderer/layerrenderer.js

@@ -224,9 +224,8 @@ ol.renderer.Layer.prototype.scheduleExpireCache =
 ol.renderer.Layer.prototype.updateAttributions =
     function(attributionsSet, attributions) {
   if (goog.isDefAndNotNull(attributions)) {
-    var i;
-    var attribution;
-    for (i = 0; i < attributions.length; ++i) {
+    var attribution, i, ii;
+    for (i = 0, ii = attributions.length; i < ii; ++i) {
       attribution = attributions[i];
       attributionsSet[goog.getUid(attribution).toString()] = attribution;
     }

src/ol/renderer/maprenderer.js

@@ -120,6 +120,17 @@ ol.renderer.Map.prototype.getLayerRenderer = function(layer) {
 };
 
 
+/**
+ * @param {string} layerKey Layer key.
+ * @protected
+ * @return {ol.renderer.Layer} Layer renderer.
+ */
+ol.renderer.Map.prototype.getLayerRendererByKey = function(layerKey) {
+  goog.asserts.assert(layerKey in this.layerRenderers_);
+  return this.layerRenderers_[layerKey];
+};
+
+
 /**
  * @protected
  * @return {Object.<number, ol.renderer.Layer>} Layer renderers.

src/ol/renderer/webgl/webglmaprenderer.js

@@ -524,13 +524,17 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
   this.textureCache_.set(frameState.index.toString(), null);
   ++this.textureCacheFrameMarkerCount_;
 
-  goog.array.forEach(frameState.layersArray, function(layer) {
-    var layerRenderer = this.getLayerRenderer(layer);
-    var layerState = frameState.layerStates[goog.getUid(layer)];
+  var layerStates = frameState.layerStates;
+  var layersArray = frameState.layersArray;
+  var i, ii, layer, layerRenderer, layerState;
+  for (i = 0, ii = layersArray.length; i < ii; ++i) {
+    layer = layersArray[i];
+    layerRenderer = this.getLayerRenderer(layer);
+    layerState = frameState.layerStates[goog.getUid(layer)];
     if (layerState.visible && layerState.ready) {
       layerRenderer.renderFrame(frameState, layerState);
     }
-  }, this);
+  }
 
   var size = frameState.size;
   if (!this.canvasSize_.equals(size)) {
@@ -552,9 +556,10 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
 
   var currentProgram = null;
   var locations;
-  goog.array.forEach(frameState.layersArray, function(layer) {
+  for (i = 0, ii = layersArray.length; i < ii; ++i) {
 
-    var layerState = frameState.layerStates[goog.getUid(layer)];
+    layer = layersArray[i];
+    layerState = frameState.layerStates[goog.getUid(layer)];
     if (!layerState.visible || !layerState.ready) {
       return;
     }
@@ -608,7 +613,7 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
 
     }
 
-    var layerRenderer = this.getLayerRenderer(layer);
+    layerRenderer = this.getLayerRenderer(layer);
     gl.uniformMatrix4fv(
         locations.u_texCoordMatrix, false, layerRenderer.getTexCoordMatrix());
     gl.uniformMatrix4fv(locations.u_projectionMatrix, false,
@@ -621,7 +626,7 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
     gl.bindTexture(goog.webgl.TEXTURE_2D, layerRenderer.getTexture());
     gl.drawArrays(goog.webgl.TRIANGLE_STRIP, 0, 4);
 
-  }, this);
+  }
 
   if (!this.renderedVisible_) {
     goog.style.showElement(this.canvas_, true);

src/ol/renderer/webgl/webgltilelayerrenderer.js

@@ -8,7 +8,6 @@ goog.require('goog.object');
 goog.require('goog.vec.Mat4');
 goog.require('goog.vec.Vec4');
 goog.require('goog.webgl');
-goog.require('ol.Size');
 goog.require('ol.Tile');
 goog.require('ol.TileRange');
 goog.require('ol.TileState');
@@ -150,15 +149,13 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
         tileRangeSize.width * tileSize.width,
         tileRangeSize.height * tileSize.height);
     var framebufferDimension = ol.math.roundUpToPowerOfTwo(maxDimension);
-    var framebufferExtentSize = new ol.Size(
-        tileResolution * framebufferDimension,
-        tileResolution * framebufferDimension);
+    var framebufferExtentDimension = tileResolution * framebufferDimension;
     var origin = tileGrid.getOrigin(z);
     var minX = origin[0] + tileRange.minX * tileSize.width * tileResolution;
     var minY = origin[1] + tileRange.minY * tileSize.height * tileResolution;
     framebufferExtent = [
-      minX, minX + framebufferExtentSize.width,
-      minY, minY + framebufferExtentSize.height
+      minX, minX + framebufferExtentDimension,
+      minY, minY + framebufferExtentDimension
     ];
 
     this.bindFramebuffer(frameState, framebufferDimension);
@@ -236,23 +233,24 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
     var zs = goog.array.map(goog.object.getKeys(tilesToDrawByZ), Number);
     goog.array.sort(zs);
     var u_tileOffset = goog.vec.Vec4.createFloat32();
-    goog.array.forEach(zs, function(z) {
-      goog.object.forEach(tilesToDrawByZ[z], function(tile) {
-        var tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
-        var sx =
-            2 * (tileExtent[1] - tileExtent[0]) / framebufferExtentSize.width;
-        var sy =
-            2 * (tileExtent[3] - tileExtent[2]) / framebufferExtentSize.height;
-        var tx = 2 * (tileExtent[0] - framebufferExtent[0]) /
-            framebufferExtentSize.width - 1;
-        var ty = 2 * (tileExtent[2] - framebufferExtent[2]) /
-            framebufferExtentSize.height - 1;
+    var i, ii, sx, sy, tileExtent, tileKey, tilesToDraw, tx, ty;
+    for (i = 0, ii = zs.length; i < ii; ++i) {
+      tilesToDraw = tilesToDrawByZ[zs[i]];
+      for (tileKey in tilesToDraw) {
+        tile = tilesToDraw[tileKey];
+        tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
+        sx = 2 * (tileExtent[1] - tileExtent[0]) / framebufferExtentDimension;
+        sy = 2 * (tileExtent[3] - tileExtent[2]) / framebufferExtentDimension;
+        tx = 2 * (tileExtent[0] - framebufferExtent[0]) /
+            framebufferExtentDimension - 1;
+        ty = 2 * (tileExtent[2] - framebufferExtent[2]) /
+            framebufferExtentDimension - 1;
         goog.vec.Vec4.setFromValues(u_tileOffset, sx, sy, tx, ty);
         gl.uniform4fv(this.locations_.u_tileOffset, u_tileOffset);
         mapRenderer.bindTileTexture(tile, goog.webgl.LINEAR, goog.webgl.LINEAR);
         gl.drawArrays(goog.webgl.TRIANGLE_STRIP, 0, 4);
-      }, this);
-    }, this);
+      }
+    }
 
     if (allTilesLoaded) {
       this.renderedTileRange_ = tileRange;

src/ol/structs/buffer.js

@@ -86,7 +86,8 @@ ol.structs.Buffer.prototype.add = function(values) {
   for (i = 0; i < size; ++i) {
     this.arr_[offset + i] = values[i];
   }
-  for (i = 0; i < this.dirtySets_.length; ++i) {
+  var ii;
+  for (i = 0, ii = this.dirtySets_.length; i < ii; ++i) {
     this.dirtySets_[i].addRange(offset, offset + size);
   }
   return offset;
@@ -151,9 +152,9 @@ ol.structs.Buffer.prototype.getUsage = function() {
  * @param {number} offset Offset.
  */
 ol.structs.Buffer.prototype.remove = function(size, offset) {
-  var i;
+  var i, ii;
   this.freeSet_.addRange(offset, offset + size);
-  for (i = 0; i < this.dirtySets_.length; ++i) {
+  for (i = 0, ii = this.dirtySets_.length; i < ii; ++i) {
     this.dirtySets_[i].removeRange(offset, offset + size);
   }
   if (ol.BUFFER_REPLACE_UNUSED_ENTRIES_WITH_NANS) {
@@ -186,7 +187,8 @@ ol.structs.Buffer.prototype.set = function(values, offset) {
   for (i = 0; i < n; ++i) {
     arr[offset + i] = values[i];
   }
-  for (i = 0; i < this.dirtySets_.length; ++i) {
+  var ii;
+  for (i = 0, ii = this.dirtySets_.length; i < ii; ++i) {
     this.dirtySets_[i].addRange(offset, offset + n);
   }
 };

src/ol/tilerange.js

@@ -49,8 +49,8 @@ ol.TileRange.boundingTileRange = function(var_args) {
   var tileCoord0 = arguments[0];
   var tileRange = new ol.TileRange(tileCoord0.x, tileCoord0.x,
                                    tileCoord0.y, tileCoord0.y);
-  var i, tileCoord;
-  for (i = 1; i < arguments.length; ++i) {
+  var i, ii, tileCoord;
+  for (i = 1, ii = arguments.length; i < ii; ++i) {
     tileCoord = arguments[i];
     goog.asserts.assert(tileCoord.z == tileCoord0.z);
     tileRange.minX = Math.min(tileRange.minX, tileCoord.x);