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

chrome/renderer/resources/extensions/web_request_internal_custom_bindings.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.
 
 // Custom binding for the webRequestInternal API.
 
 var binding = require('binding').Binding.create('webRequestInternal');
 var eventBindings = require('event_bindings');
 var sendRequest = require('sendRequest').sendRequest;
 var validate = require('schemaUtils').validate;
@@ skipping 49 matching lines @@
 WebRequestEvent.prototype.addListener =
     function(cb, opt_filter, opt_extraInfo) {
   if (!this.eventOptions_.supportsListeners)
     throw new Error('This event does not support listeners.');
   // NOTE(benjhayden) New APIs should not use this subEventName trick! It does
   // not play well with event pages. See downloads.onDeterminingFilename and
   // ExtensionDownloadsEventRouter for an alternative approach.
   var subEventName = webRequestNatives.GetUniqueSubEventName(this.eventName_);
   // Note: this could fail to validate, in which case we would not add the
   // subEvent listener.
-  validate(Array.prototype.slice.call(arguments, 1), this.extraArgSchemas_);
+  validate($Array.slice(arguments, 1), this.extraArgSchemas_);
   webRequestInternal.addEventListener(
       cb, opt_filter, opt_extraInfo, this.eventName_, subEventName,
       this.webViewInstanceId_);
 
   var subEvent = new eventBindings.Event(subEventName, this.argSchemas_);
   var subEventCallback = cb;
   if (opt_extraInfo && opt_extraInfo.indexOf('blocking') >= 0) {
     var eventName = this.eventName_;
     subEventCallback = function() {
       var requestId = arguments[0].requestId;
       try {
-        var result = cb.apply(null, arguments);
+        var result = $Function.apply(cb, null, arguments);
         webRequestInternal.eventHandled(
             eventName, subEventName, requestId, result);
       } catch (e) {
         webRequestInternal.eventHandled(
             eventName, subEventName, requestId);
         throw e;
       }
     };
   } else if (opt_extraInfo && opt_extraInfo.indexOf('asyncBlocking') >= 0) {
     var eventName = this.eventName_;
     subEventCallback = function() {
       var details = arguments[0];
       var requestId = details.requestId;
       var handledCallback = function(response) {
         webRequestInternal.eventHandled(
             eventName, subEventName, requestId, response);
       };
-      cb.apply(null, [details, handledCallback]);
+      $Function.apply(cb, null, [details, handledCallback]);
     };
   }
-  this.subEvents_.push(
+  $Array.push(this.subEvents_,
       {subEvent: subEvent, callback: cb, subEventCallback: subEventCallback});
   subEvent.addListener(subEventCallback);
 };
 
 // Unregisters a callback.
 WebRequestEvent.prototype.removeListener = function(cb) {
   if (!this.eventOptions_.supportsListeners)
     throw new Error('This event does not support listeners.');
   var idx;
   while ((idx = this.findListener_(cb)) >= 0) {
     var e = this.subEvents_[idx];
     e.subEvent.removeListener(e.subEventCallback);
     if (e.subEvent.hasListeners()) {
       console.error(
           'Internal error: webRequest subEvent has orphaned listeners.');
     }
-    this.subEvents_.splice(idx, 1);
+    $Array.splice(this.subEvents_, idx, 1);
   }
 };
 
 WebRequestEvent.prototype.findListener_ = function(cb) {
   for (var i in this.subEvents_) {
     var e = this.subEvents_[i];
     if (e.callback === cb) {
       if (e.subEvent.findListener_(e.subEventCallback) > -1)
         return i;
       console.error('Internal error: webRequest subEvent has no callback.');
@@ skipping 18 matching lines @@
 WebRequestEvent.prototype.getRules = function(ruleIdentifiers, cb) {
   if (!this.eventOptions_.supportsRules)
     throw new Error('This event does not support rules.');
   this.eventForRules_.getRules(ruleIdentifiers, cb);
 };
 
 binding.registerCustomHook(function(api) {
   var apiFunctions = api.apiFunctions;
 
   apiFunctions.setHandleRequest('addEventListener', function() {
-    var args = Array.prototype.slice.call(arguments);
+    var args = $Array.slice(arguments);
     sendRequest(this.name, args, this.definition.parameters,
                 {forIOThread: true});
   });
 
   apiFunctions.setHandleRequest('eventHandled', function() {
-    var args = Array.prototype.slice.call(arguments);
+    var args = $Array.slice(arguments);
     sendRequest(this.name, args, this.definition.parameters,
                 {forIOThread: true});
   });
 });
 
 webRequestInternal = binding.generate();
 exports.binding = webRequestInternal;
 exports.WebRequestEvent = WebRequestEvent;