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

chrome/renderer/resources/extensions/schema_utils.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.
 
 // Routines used to validate and normalize arguments.
 // TODO(benwells): unit test this file.
 
 var JSONSchemaValidator = require('json_schema').JSONSchemaValidator;
 
 var schemaValidator = new JSONSchemaValidator();
@@ skipping 26 matching lines @@
           parameterSchemas[i].name + ") is required.");
     }
   }
 }
 
 // Generate all possible signatures for a given API function.
 function getSignatures(parameterSchemas) {
   if (parameterSchemas.length === 0)
     return [[]];
   var signatures = [];
-  var remaining = getSignatures(parameterSchemas.slice(1));
+  var remaining = getSignatures($Array.slice(parameterSchemas, 1));
   for (var i = 0; i < remaining.length; i++)
-    signatures.push([parameterSchemas[0]].concat(remaining[i]))
+    $Array.push(signatures, $Array.concat([parameterSchemas[0]], remaining[i]))
   if (parameterSchemas[0].optional)
-    return signatures.concat(remaining);
+    return $Array.concat(signatures, remaining);
   return signatures;
 };
 
 // Return true if arguments match a given signature's schema.
 function argumentsMatchSignature(args, candidateSignature) {
   if (args.length != candidateSignature.length)
     return false;
   for (var i = 0; i < candidateSignature.length; i++) {
     var argType =  JSONSchemaValidator.getType(args[i]);
     if (!schemaValidator.isValidSchemaType(argType,
@@ skipping 50 matching lines @@
   if (!resolvedSignature)
     throw new Error("Invocation of form " +
         getArgumentSignatureString(funDef.name, args) +
         " doesn't match definition " +
         getParameterSignatureString(funDef.name, definedSignature));
   validate(args, resolvedSignature);
   var normalizedArgs = [];
   var ai = 0;
   for (var si = 0; si < definedSignature.length; si++) {
     if (definedSignature[si] === resolvedSignature[ai])
-      normalizedArgs.push(args[ai++]);
+      $Array.push(normalizedArgs, args[ai++]);
     else
-      normalizedArgs.push(null);
+      $Array.push(normalizedArgs, null);
   }
   return normalizedArgs;
 };
 
 // Validates that a given schema for an API function is not ambiguous.
 function isFunctionSignatureAmbiguous(functionDef) {
   if (functionDef.allowAmbiguousOptionalArguments)
     return false;
   var signaturesAmbiguous = function(signature1, signature2) {
     if (signature1.length != signature2.length)
@@ skipping 12 matching lines @@
         return true;
     }
   }
   return false;
 };
 
 exports.isFunctionSignatureAmbiguous = isFunctionSignatureAmbiguous;
 exports.normalizeArgumentsAndValidate = normalizeArgumentsAndValidate;
 exports.schemaValidator = schemaValidator;
 exports.validate = validate;