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

chrome/renderer/resources/extensions/send_request.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 lastError = require('lastError');
 var logging = requireNative('logging');
 var natives = requireNative('sendRequest');
 var processNatives = requireNative('process');
 var validate = require('schemaUtils').validate;
 
 // All outstanding requests from sendRequest().
 var requests = {};
 
 // Used to prevent double Activity Logging for API calls that use both custom
 // bindings and ExtensionFunctions (via sendRequest).
 var calledSendRequest = false;
 
 // Runs a user-supplied callback safely.
 function safeCallbackApply(name, request, callback, args) {
   try {
-    callback.apply(request, args);
+    $Function.apply(callback, request, args);
   } catch (e) {
     var errorMessage = "Error in response to " + name + ": " + e;
     if (request.stack && request.stack != '')
       errorMessage += "\n" + request.stack;
     console.error(errorMessage);
   }
 }
 
 // Callback handling.
 function handleResponse(requestId, name, success, responseList, error) {
   // The chrome objects we will set lastError on. Really we should only be
   // setting this on the callback's chrome object, but set on ours too since
   // it's conceivable that something relies on that.
   var chromesForLastError = [chrome];
 
   try {
     var request = requests[requestId];
     logging.DCHECK(request != null);
 
     // lastError needs to be set on the caller's chrome object no matter what,
     // though chances are it's the same as ours (it will be different when
     // calling API methods on other contexts).
     if (request.callback) {
       var chromeForCallback = natives.GetGlobal(request.callback).chrome;
       if (chromeForCallback != chrome)
-        chromesForLastError.push(chromeForCallback);
+        $Array.push(chromesForLastError, chromeForCallback);
     }
 
     $Array.forEach(chromesForLastError, function(c) {lastError.clear(c)});
     if (!success) {
       if (!error)
         error = "Unknown error.";
       $Array.forEach(chromesForLastError, function(c) {
         lastError.set(name, error, request.stack, c)
       });
     }
 
     if (request.customCallback) {
       safeCallbackApply(name,
                         request,
                         request.customCallback,
-                        [name, request].concat(responseList));
+                        $Array.concat([name, request], responseList));
     }
 
     if (request.callback) {
       // Validate callback in debug only -- and only when the
       // caller has provided a callback. Implementations of api
       // calls may not return data if they observe the caller
       // has not provided a callback.
       if (logging.DCHECK_IS_ON() && !error) {
         if (!request.callbackSchema.parameters)
           throw new Error(name + ": no callback schema defined");
         validate(responseList, request.callbackSchema.parameters);
       }
       safeCallbackApply(name, request, request.callback, responseList);
     }
   } finally {
     delete requests[requestId];
     $Array.forEach(chromesForLastError, function(c) {lastError.clear(c)});
   }
 };
 
 function getExtensionStackTrace(call_name) {
-  var stack = new Error().stack.split('\n');
+  var stack = $String.split(new Error().stack, '\n');
 
   // Remove stack frames before and after that weren't associated with the
   // extension.
   var id = processNatives.GetExtensionId();
   while (stack.length > 0 && stack[0].indexOf(id) == -1)
     stack.shift();
   while (stack.length > 0 && stack[stack.length - 1].indexOf(id) == -1)
     stack.pop();
 
   return stack.join('\n');
@@ skipping 60 matching lines @@
 function clearCalledSendRequest() {
   calledSendRequest = false;
 }
 
 exports.sendRequest = sendRequest;
 exports.getCalledSendRequest = getCalledSendRequest;
 exports.clearCalledSendRequest = clearCalledSendRequest;
 
 // Called by C++.
 exports.handleResponse = handleResponse;