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

chrome/renderer/resources/extensions/event.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 eventNatives = requireNative('event_natives');
   var logging = requireNative('logging');
   var schemaRegistry = requireNative('schema_registry');
   var sendRequest = require('sendRequest').sendRequest;
   var utils = require('utils');
   var validate = require('schemaUtils').validate;
@@ skipping 91 matching lines @@
   };
 
   FilteredAttachmentStrategy.prototype.detach = function(manual) {
     for (var i in this.listenerMap_)
       this.detachListener(this.listenerMap_[i], manual);
   };
 
   FilteredAttachmentStrategy.prototype.getListenersByIDs = function(ids) {
     var result = [];
     for (var i = 0; i < ids.length; i++)
-      result.push(this.listenerMap_[ids[i]]);
+      $Array.push(result, this.listenerMap_[ids[i]]);
     return result;
   };
 
   function parseEventOptions(opt_eventOptions) {
     function merge(dest, src) {
       for (var k in src) {
-        if (!dest.hasOwnProperty(k)) {
+        if (!$Object.hasOwnProperty(dest, k)) {
           dest[k] = src[k];
         }
       }
     }
 
     var options = opt_eventOptions || {};
     merge(options,
         {supportsFilters: false,
          supportsListeners: true,
          supportsRules: false,
@@ skipping 87 matching lines @@
         this.getListenerCount() >= this.eventOptions_.maxListeners)
       throw new Error("Too many listeners for " + this.eventName_);
     if (filters) {
       if (!this.eventOptions_.supportsFilters)
         throw new Error("This event does not support filters.");
       if (filters.url && !(filters.url instanceof Array))
         throw new Error("filters.url should be an array");
     }
     var listener = {callback: cb, filters: filters};
     this.attach_(listener);
-    this.listeners_.push(listener);
+    $Array.push(this.listeners_, listener);
   };
 
   Event.prototype.attach_ = function(listener) {
     this.attachmentStrategy_.onAddedListener(listener);
     if (this.listeners_.length == 0) {
       allAttachedEvents[allAttachedEvents.length] = this;
       if (!this.eventName_)
         return;
 
       if (attachedNamedEvents[this.eventName_])
         throw new Error("Event '" + this.eventName_ + "' is already attached.");
 
       attachedNamedEvents[this.eventName_] = this;
     }
   };
 
   // Unregisters a callback.
   Event.prototype.removeListener = function(cb) {
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
     var idx = this.findListener_(cb);
     if (idx == -1)
       return;
 
-    var removedListener = this.listeners_.splice(idx, 1)[0];
+    var removedListener = $Array.splice(this.listeners_, idx, 1)[0];
     this.attachmentStrategy_.onRemovedListener(removedListener);
 
     if (this.listeners_.length == 0) {
       var i = allAttachedEvents.indexOf(this);
       if (i >= 0)
         delete allAttachedEvents[i];
       if (!this.eventName_)
         return;
 
       if (!attachedNamedEvents[this.eventName_])
@@ skipping 38 matching lines @@
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
     var validationErrors = this.validateEventArgs_(args);
     if (validationErrors) {
       console.error(validationErrors);
       return {validationErrors: validationErrors};
     }
 
     // Make a copy of the listeners in case the listener list is modified
     // while dispatching the event.
-    var listeners =
-        this.attachmentStrategy_.getListenersByIDs(listenerIDs).slice();
+    var listeners = $Array.slice(
+        this.attachmentStrategy_.getListenersByIDs(listenerIDs));
 
     var results = [];
     for (var i = 0; i < listeners.length; i++) {
       try {
         var result = this.dispatchToListener(listeners[i].callback, args);
         if (result !== undefined)
-          results.push(result);
+          $Array.push(results, result);
       } catch (e) {
         var errorMessage = "Error in event handler";
         if (this.eventName_)
           errorMessage += " for " + this.eventName_;
         errorMessage += ": " + e;
         console.error(errorMessage);
       }
     }
     if (results.length)
       return {results: results};
   }
 
   // Can be overridden to support custom dispatching.
   Event.prototype.dispatchToListener = function(callback, args) {
-    return callback.apply(null, args);
+    return $Function.apply(callback, null, args);
   }
 
   // Dispatches this event object to all listeners, passing all supplied
   // arguments to this function each listener.
   Event.prototype.dispatch = function(varargs) {
-    return this.dispatch_(Array.prototype.slice.call(arguments), undefined);
+    return this.dispatch_($Array.slice(arguments), undefined);
   };
 
   // Detaches this event object from its name.
   Event.prototype.detach_ = function() {
     this.attachmentStrategy_.detach(false);
   };
 
   Event.prototype.destroy_ = function() {
     this.listeners_ = [];
     this.validateEventArgs_ = [];
@@ skipping 38 matching lines @@
     }
 
     validateRules(rules,
                   this.eventOptions_.conditions,
                   this.eventOptions_.actions);
 
     ensureRuleSchemasLoaded();
     // We remove the first parameter from the validation to give the user more
     // meaningful error messages.
     validate([rules, opt_cb],
-             ruleFunctionSchemas.addRules.parameters.slice().splice(1));
+             $Array.splice(
+                 $Array.slice(ruleFunctionSchemas.addRules.parameters), 1));
     sendRequest("events.addRules", [this.eventName_, rules, opt_cb],
                 ruleFunctionSchemas.addRules.parameters);
   }
 
   Event.prototype.removeRules = function(ruleIdentifiers, opt_cb) {
     if (!this.eventOptions_.supportsRules)
       throw new Error("This event does not support rules.");
     ensureRuleSchemasLoaded();
     // We remove the first parameter from the validation to give the user more
     // meaningful error messages.
     validate([ruleIdentifiers, opt_cb],
-             ruleFunctionSchemas.removeRules.parameters.slice().splice(1));
+             $Array.splice(
+                 $Array.slice(ruleFunctionSchemas.removeRules.parameters), 1));
     sendRequest("events.removeRules",
                 [this.eventName_, ruleIdentifiers, opt_cb],
                 ruleFunctionSchemas.removeRules.parameters);
   }
 
   Event.prototype.getRules = function(ruleIdentifiers, cb) {
     if (!this.eventOptions_.supportsRules)
       throw new Error("This event does not support rules.");
     ensureRuleSchemasLoaded();
     // We remove the first parameter from the validation to give the user more
     // meaningful error messages.
     validate([ruleIdentifiers, cb],
-             ruleFunctionSchemas.getRules.parameters.slice().splice(1));
+             $Array.splice(
+                 $Array.slice(ruleFunctionSchemas.getRules.parameters), 1));
 
     sendRequest("events.getRules",
                 [this.eventName_, ruleIdentifiers, cb],
                 ruleFunctionSchemas.getRules.parameters);
   }
 
   unloadEvent.addListener(function() {
     for (var i = 0; i < allAttachedEvents.length; ++i) {
       var event = allAttachedEvents[i];
       if (event)
         event.detach_();
     }
   });
 
   // NOTE: Event is (lazily) exposed as chrome.Event from dispatcher.cc.
   exports.Event = Event;
 
   exports.dispatchEvent = dispatchEvent;
   exports.parseEventOptions = parseEventOptions;
   exports.registerArgumentMassager = registerArgumentMassager;