Make the externally connectable browser test clobber all of the builtins,

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.
 
 var Event = require('event_bindings').Event;
 var forEach = require('utils').forEach;
 var GetAvailability = requireNative('v8_context').GetAvailability;
 var logActivity = requireNative('activityLogger');
 var logging = requireNative('logging');
 var process = requireNative('process');
@@ skipping 22 matching lines @@
 
 // Registers a function as existing but not available, meaning that calls to
 // the set* methods that reference this function should be ignored rather
 // than throwing Errors.
 APIFunctions.prototype.registerUnavailable = function(apiName) {
   this.unavailableApiFunctions_[apiName] = apiName;
 };
 
 APIFunctions.prototype.setHook_ =
     function(apiName, propertyName, customizedFunction) {
-  if (this.unavailableApiFunctions_.hasOwnProperty(apiName))
+  if ($Object.hasOwnProperty(this.unavailableApiFunctions_, apiName))
     return;
-  if (!this.apiFunctions_.hasOwnProperty(apiName))
+  if (!$Object.hasOwnProperty(this.apiFunctions_, apiName))
     throw new Error('Tried to set hook for unknown API "' + apiName + '"');
   this.apiFunctions_[apiName][propertyName] = customizedFunction;
 };
 
 APIFunctions.prototype.setHandleRequest =
     function(apiName, customizedFunction) {
   var prefix = this.namespace;
-  // TODO(ataly): Need to replace/redefine apply and slice.
   return this.setHook_(apiName, 'handleRequest',
     function() {
-      var ret = customizedFunction.apply(this, arguments);
+      var ret = $Function.apply(customizedFunction, this, arguments);
       // Logs API calls to the Activity Log if it doesn't go through an
       // ExtensionFunction.
       if (!sendRequestHandler.getCalledSendRequest())
         logActivity.LogAPICall(extensionId, prefix + "." + apiName,
-            Array.prototype.slice.call(arguments));
+            $Array.slice(arguments));
       return ret;
     });
 };
 
 APIFunctions.prototype.setUpdateArgumentsPostValidate =
     function(apiName, customizedFunction) {
   return this.setHook_(
     apiName, 'updateArgumentsPostValidate', customizedFunction);
 };
 
@@ skipping 28 matching lines @@
 function getPlatform() {
   var platforms = [
     [/CrOS Touch/, "chromeos touch"],
     [/CrOS/, "chromeos"],
     [/Linux/, "linux"],
     [/Mac/, "mac"],
     [/Win/, "win"],
   ];
 
   for (var i = 0; i < platforms.length; i++) {
-    if (platforms[i][0].test(navigator.appVersion)) {
+    if ($RegExp.test(platforms[i][0], navigator.appVersion)) {
       return platforms[i][1];
     }
   }
   return "unknown";
 }
 
 function isPlatformSupported(schemaNode, platform) {
   return !schemaNode.platforms ||
       schemaNode.platforms.indexOf(platform) > -1;
 }
@@ skipping 48 matching lines @@
   // |event| is the event's constructor.
   registerCustomEvent: function(event) {
     this.customEvent_ = event;
   },
 
   // 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);
+    $Array.push(this.customHooks_, fn);
   },
 
   // TODO(kalman/cduvall): Refactor this so |runHooks_| is not needed.
   runHooks_: function(api) {
     $Array.forEach(this.customHooks_, function(hook) {
       if (!isSchemaNodeSupported(this.schema_, platform, manifestVersion))
         return;
 
       if (!hook)
         return;
@@ skipping 10 matching lines @@
   // bindings that might be present.
   generate: function() {
     var schema = this.schema_;
 
     function shouldCheckUnprivileged() {
       var shouldCheck = 'unprivileged' in schema;
       if (shouldCheck)
         return shouldCheck;
 
       $Array.forEach(['functions', 'events'], function(type) {
-        if (schema.hasOwnProperty(type)) {
+        if ($Object.hasOwnProperty(schema, type)) {
           $Array.forEach(schema[type], function(node) {
             if ('unprivileged' in node)
               shouldCheck = true;
           });
         }
       });
       if (shouldCheck)
         return shouldCheck;
 
       for (var property in schema.properties) {
-        if (schema.hasOwnProperty(property) &&
+        if ($Object.hasOwnProperty(schema, property) &&
             'unprivileged' in schema.properties[property]) {
           shouldCheck = true;
           break;
         }
       }
       return shouldCheck;
     }
     var checkUnprivileged = shouldCheckUnprivileged();
 
     // TODO(kalman/cduvall): Make GetAvailability handle this, then delete the
     // supporting code.
     if (!isSchemaNodeSupported(schema, platform, manifestVersion)) {
       console.error('chrome.' + schema.namespace + ' is not supported on ' +
                     'this platform or manifest version');
       return undefined;
     }
 
     var mod = {};
 
-    var namespaces = schema.namespace.split('.');
+    var namespaces = $String.split(schema.namespace, '.');
     for (var index = 0, name; name = namespaces[index]; index++) {
       mod[name] = mod[name] || {};
       mod = mod[name];
     }
 
     // Add types to global schemaValidator, the types we depend on from other
     // namespaces will be added as needed.
     if (schema.types) {
       $Array.forEach(schema.types, function(t) {
         if (!isSchemaNodeSupported(t, platform, manifestVersion))
@@ skipping 42 matching lines @@
             schemaUtils.isFunctionSignatureAmbiguous(apiFunction.definition)) {
           throw new Error(
               apiFunction.name + ' has ambiguous optional arguments. ' +
               'To implement custom disambiguation logic, add ' +
               '"allowAmbiguousOptionalArguments" to the function\'s schema.');
         }
 
         this.apiFunctions_.register(functionDef.name, apiFunction);
 
         mod[functionDef.name] = $Function.bind(function() {
-          var args = Array.prototype.slice.call(arguments);
+          var args = $Array.slice(arguments);
           if (this.updateArgumentsPreValidate)
-            args = this.updateArgumentsPreValidate.apply(this, args);
+            args = $Function.apply(this.updateArgumentsPreValidate, this, args);
 
           args = schemaUtils.normalizeArgumentsAndValidate(args, this);
-          if (this.updateArgumentsPostValidate)
-            args = this.updateArgumentsPostValidate.apply(this, args);
+          if (this.updateArgumentsPostValidate) {
+            args = $Function.apply(this.updateArgumentsPostValidate,
+                                   this,
+                                   args);
+          }
 
           sendRequestHandler.clearCalledSendRequest();
 
           var retval;
           if (this.handleRequest) {
-            retval = this.handleRequest.apply(this, args);
+            retval = $Function.apply(this.handleRequest, this, args);
           } else {
             var optArgs = {
               customCallback: this.customCallback
             };
             retval = sendRequest(this.name, args,
                                  this.definition.parameters,
                                  optArgs);
           }
           sendRequestHandler.clearCalledSendRequest();
 
@@ skipping 69 matching lines @@
             var ref = propertyDef['$ref'];
             var type = utils.loadTypeSchema(propertyDef['$ref'], schema);
             logging.CHECK(type, 'Schema for $ref type ' + ref + ' not found');
             var constructor = createCustomType(type);
             var args = value;
             // For an object propertyDef, |value| is an array of constructor
             // arguments, but we want to pass the arguments directly (i.e.
             // not as an array), so we have to fake calling |new| on the
             // constructor.
             value = { __proto__: constructor.prototype };
-            constructor.apply(value, args);
+            $Function.apply(constructor, value, args);
             // Recursively add properties.
             addProperties(value, propertyDef);
           } else if (type === 'object') {
             // Recursively add properties.
             addProperties(value, propertyDef);
           } else if (type !== 'string') {
             throw new Error('NOT IMPLEMENTED (extension_api.json error): ' +
                 'Cannot parse values for type "' + type + '"');
           }
           m[propertyName] = value;
         }
       });
     };
 
     addProperties(mod, schema);
 
     var availability = GetAvailability(schema.namespace);
-    if (!availability.is_available && Object.keys(mod).length == 0) {
+    if (!availability.is_available && $Object.keys(mod).length == 0) {
       console.error('chrome.' + schema.namespace + ' is not available: ' +
                         availability.message);
       return;
     }
 
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;