Use utils.forEach everywhere rather than Array.prototype.forEach to guard

chrome/renderer/resources/extensions/binding.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 require('json_schema');
 require('event_bindings');
+var chrome = requireNative('chrome').GetChrome();
+var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
+var forEach = require('utils').forEach;
+var GetAvailability = requireNative('v8_context').GetAvailability;
+var logging = requireNative('logging');
+var process = requireNative('process');
+var contextType = process.GetContextType();
+var extensionId = process.GetExtensionId();
+var manifestVersion = process.GetManifestVersion();
 var schemaRegistry = requireNative('schema_registry');
+var schemaUtils = require('schemaUtils');
 var sendRequest = require('sendRequest').sendRequest;
 var utils = require('utils');
-var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
-var chrome = requireNative('chrome').GetChrome();
-var schemaUtils = require('schemaUtils');
-var process = requireNative('process');
-var manifestVersion = process.GetManifestVersion();
-var extensionId = process.GetExtensionId();
-var contextType = process.GetContextType();
-var GetAvailability = requireNative('v8_context').GetAvailability;
-var logging = requireNative('logging');
 
 // Stores the name and definition of each API function, with methods to
 // modify their behaviour (such as a custom way to handle requests to the
 // API, a custom callback, etc).
 function APIFunctions() {
   this.apiFunctions_ = {};
   this.unavailableApiFunctions_ = {};
 }
 
 APIFunctions.prototype.register = function(apiName, apiFunction) {
@@ skipping 128 matching lines @@
   // Registers a function |hook| to run after the schema for all APIs has been
   // generated.  The hook is passed as its first argument an "API" object to
   // interact with, and second the current extension ID. See where
   // |customHooks| is used.
   registerCustomHook: function(fn) {
     this.customHooks_.push(fn);
   },
 
   // TODO(kalman/cduvall): Refactor this so |runHooks_| is not needed.
   runHooks_: function(api) {
-    this.customHooks_.forEach(function(hook) {
+    forEach(this.customHooks_, function(i, hook) {
       if (!isSchemaNodeSupported(this.schema_, platform, manifestVersion))
         return;
 
       if (!hook)
         return;
 
       hook({
         apiFunctions: this.apiFunctions_,
         schema: this.schema_,
         compiledApi: api
@@ skipping 23 matching lines @@
     var mod = {};
 
     var namespaces = schema.namespace.split('.');
     for (var index = 0, name; name = namespaces[index]; index++) {
       mod[name] = mod[name] || {};
       mod = mod[name];
     }
 
     // Add types to global schemaValidator
     if (schema.types) {
-      schema.types.forEach(function(t) {
+      forEach(schema.types, function(i, t) {
         if (!isSchemaNodeSupported(t, platform, manifestVersion))
           return;
 
         schemaUtils.schemaValidator.addTypes(t);
         if (t.type == 'object' && this.customTypes_[t.id]) {
           var parts = t.id.split(".");
           this.customTypes_[t.id].prototype.setSchema(t);
           mod[parts[parts.length - 1]] = this.customTypes_[t.id];
         }
       }, this);
@@ skipping 13 matching lines @@
     function addUnprivilegedAccessGetter(mod, name) {
       mod.__defineGetter__(name, function() {
         throw new Error(
             '"' + name + '" can only be used in extension processes. See ' +
             'the content scripts documentation for more details.');
       });
     }
 
     // Setup Functions.
     if (schema.functions) {
-      schema.functions.forEach(function(functionDef) {
+      forEach(schema.functions, function(i, functionDef) {
         if (functionDef.name in mod) {
           throw new Error('Function ' + functionDef.name +
                           ' already defined in ' + schema.namespace);
         }
 
         if (!isSchemaNodeSupported(functionDef, platform, manifestVersion)) {
           this.apiFunctions_.registerUnavailable(functionDef.name);
           return;
         }
         if (!isSchemaAccessAllowed(functionDef)) {
@@ skipping 46 matching lines @@
               this.definition.returns) {
             schemaUtils.validate([retval], [this.definition.returns]);
           }
           return retval;
         }).bind(apiFunction);
       }, this);
     }
 
     // Setup Events
     if (schema.events) {
-      schema.events.forEach(function(eventDef) {
+      forEach(schema.events, function(i, eventDef) {
         if (eventDef.name in mod) {
           throw new Error('Event ' + eventDef.name +
                           ' already defined in ' + schema.namespace);
         }
         if (!isSchemaNodeSupported(eventDef, platform, manifestVersion))
           return;
         if (!isSchemaAccessAllowed(eventDef)) {
           addUnprivilegedAccessGetter(mod, eventDef.name);
           return;
         }
@@ skipping 15 matching lines @@
               eventName, eventDef.parameters, options);
         }
       }, this);
     }
 
     function addProperties(m, parentDef) {
       var properties = parentDef.properties;
       if (!properties)
         return;
 
-      utils.forEach(properties, function(propertyName, propertyDef) {
+      forEach(properties, function(propertyName, propertyDef) {
         if (propertyName in m)
           return;  // TODO(kalman): be strict like functions/events somehow.
         if (!isSchemaNodeSupported(propertyDef, platform, manifestVersion))
           return;
         if (!isSchemaAccessAllowed(propertyDef)) {
           addUnprivilegedAccessGetter(m, propertyName);
           return;
         }
 
         var value = propertyDef.value;
@@ skipping 39 matching lines @@
       });
     };
 
     addProperties(mod, schema);
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;