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

Don't use forEach in loops

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;