Lazy load chrome.* APIs

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 DCHECK = requireNative('logging').DCHECK;
+  // TODO(cduvall/kalman): json_schema shouldn't put things on chromeHidden.
+  require('json_schema');
   var eventBindingsNatives = requireNative('event_bindings');
   var AttachEvent = eventBindingsNatives.AttachEvent;
   var DetachEvent = eventBindingsNatives.DetachEvent;
   var AttachFilteredEvent = eventBindingsNatives.AttachFilteredEvent;
   var DetachFilteredEvent = eventBindingsNatives.DetachFilteredEvent;
   var MatchAgainstEventFilter = eventBindingsNatives.MatchAgainstEventFilter;
   var sendRequest = require('sendRequest').sendRequest;
   var utils = require('utils');
   var validate = require('schemaUtils').validate;
 
   var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
-  var GetExtensionAPIDefinition =
-      requireNative('apiDefinitions').GetExtensionAPIDefinition;
+  var chrome = requireNative('chrome').GetChrome();
+  var schemaRegistry = requireNative('schema_registry');
 
   // Schemas for the rule-style functions on the events API that
   // only need to be generated occasionally, so populate them lazily.
   var ruleFunctionSchemas = {
     // These values are set lazily:
     // addRules: {},
     // getRules: {},
     // removeRules: {}
   };
 
   // This function ensures that |ruleFunctionSchemas| is populated.
   function ensureRuleSchemasLoaded() {
     if (ruleFunctionSchemas.addRules)
       return;
-    var eventsSchema = GetExtensionAPIDefinition("events")[0];
+    var eventsSchema = schemaRegistry.GetSchema("events");
     var eventType = utils.lookup(eventsSchema.types, 'id', 'events.Event');
 
     ruleFunctionSchemas.addRules =
         utils.lookup(eventType.functions, 'name', 'addRules');
     ruleFunctionSchemas.getRules =
         utils.lookup(eventType.functions, 'name', 'getRules');
     ruleFunctionSchemas.removeRules =
         utils.lookup(eventType.functions, 'name', 'removeRules');
   }
 
@@ skipping 138 matching lines @@
   // opt_eventName is required for events that support rules.
   //
   // Example:
   //   chrome.tabs.onChanged = new chrome.Event("tab-changed");
   //   chrome.tabs.onChanged.addListener(function(data) { alert(data); });
   //   chromeHidden.Event.dispatch("tab-changed", "hi");
   // will result in an alert dialog that says 'hi'.
   //
   // If opt_eventOptions exists, it is a dictionary that contains the boolean
   // entries "supportsListeners" and "supportsRules".
-  chrome.Event = function(opt_eventName, opt_argSchemas, opt_eventOptions) {
+  var Event = function(opt_eventName, opt_argSchemas, opt_eventOptions) {
     this.eventName_ = opt_eventName;
     this.listeners_ = [];
     this.eventOptions_ = chromeHidden.parseEventOptions(opt_eventOptions);
 
     if (this.eventOptions_.supportsRules && !opt_eventName)
       throw new Error("Events that support rules require an event name.");
 
     if (this.eventOptions_.supportsFilters) {
       this.attachmentStrategy_ = new FilteredAttachmentStrategy(this);
     } else {
@@ skipping 54 matching lines @@
       dispatchArgs(args);
   };
 
   // Test if a named event has any listeners.
   chromeHidden.Event.hasListener = function(name) {
     return (attachedNamedEvents[name] &&
             attachedNamedEvents[name].listeners_.length > 0);
   };
 
   // Registers a callback to be called when this event is dispatched.
-  chrome.Event.prototype.addListener = function(cb, filters) {
+  Event.prototype.addListener = function(cb, filters) {
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
     if (this.eventOptions_.maxListeners &&
         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);
   };
 
-  chrome.Event.prototype.attach_ = function(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("chrome.Event '" + this.eventName_ +
                         "' is already attached.");
       }
 
       attachedNamedEvents[this.eventName_] = this;
     }
   };
 
   // Unregisters a callback.
-  chrome.Event.prototype.removeListener = function(cb) {
+  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];
     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_]) {
         throw new Error("chrome.Event '" + this.eventName_ +
                         "' is not attached.");
       }
 
       delete attachedNamedEvents[this.eventName_];
     }
   };
 
   // Test if the given callback is registered for this event.
-  chrome.Event.prototype.hasListener = function(cb) {
+  Event.prototype.hasListener = function(cb) {
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
     return this.findListener_(cb) > -1;
   };
 
   // Test if any callbacks are registered for this event.
-  chrome.Event.prototype.hasListeners = function() {
+  Event.prototype.hasListeners = function() {
     return this.getListenerCount() > 0;
   };
 
   // Return the number of listeners on this event.
-  chrome.Event.prototype.getListenerCount = function() {
+  Event.prototype.getListenerCount = function() {
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
     return this.listeners_.length;
   };
 
   // Returns the index of the given callback if registered, or -1 if not
   // found.
-  chrome.Event.prototype.findListener_ = function(cb) {
+  Event.prototype.findListener_ = function(cb) {
     for (var i = 0; i < this.listeners_.length; i++) {
       if (this.listeners_[i].callback == cb) {
         return i;
       }
     }
 
     return -1;
   };
 
-  chrome.Event.prototype.dispatch_ = function(args, listenerIDs) {
+  Event.prototype.dispatch_ = function(args, listenerIDs) {
     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 results = [];
     for (var i = 0; i < listeners.length; i++) {
       try {
         var result = this.dispatchToListener(listeners[i].callback, args);
         if (result !== undefined)
           results.push(result);
       } catch (e) {
         console.error("Error in event handler for '" + this.eventName_ +
                       "': " + e.message + ' ' + e.stack);
       }
     }
     if (results.length)
       return {results: results};
   }
 
   // Can be overridden to support custom dispatching.
-  chrome.Event.prototype.dispatchToListener = function(callback, args) {
+  Event.prototype.dispatchToListener = function(callback, args) {
     return callback.apply(null, args);
   }
 
   // Dispatches this event object to all listeners, passing all supplied
   // arguments to this function each listener.
-  chrome.Event.prototype.dispatch = function(varargs) {
+  Event.prototype.dispatch = function(varargs) {
     return this.dispatch_(Array.prototype.slice.call(arguments), undefined);
   };
 
   // Detaches this event object from its name.
-  chrome.Event.prototype.detach_ = function() {
+  Event.prototype.detach_ = function() {
     this.attachmentStrategy_.detach(false);
   };
 
-  chrome.Event.prototype.destroy_ = function() {
+  Event.prototype.destroy_ = function() {
     this.listeners_ = [];
     this.validateEventArgs_ = [];
     this.detach_(false);
   };
 
-  chrome.Event.prototype.addRules = function(rules, opt_cb) {
+  Event.prototype.addRules = function(rules, opt_cb) {
     if (!this.eventOptions_.supportsRules)
       throw new Error("This event does not support rules.");
 
     // Takes a list of JSON datatype identifiers and returns a schema fragment
     // that verifies that a JSON object corresponds to an array of only these
     // data types.
     function buildArrayOfChoicesSchema(typesList) {
       return {
         'type': 'array',
         'items': {
@@ skipping 29 matching lines @@
 
     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));
     sendRequest("events.addRules", [this.eventName_, rules, opt_cb],
                 ruleFunctionSchemas.addRules.parameters);
   }
 
-  chrome.Event.prototype.removeRules = function(ruleIdentifiers, opt_cb) {
+  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));
     sendRequest("events.removeRules",
                 [this.eventName_, ruleIdentifiers, opt_cb],
                 ruleFunctionSchemas.removeRules.parameters);
   }
 
-  chrome.Event.prototype.getRules = function(ruleIdentifiers, cb) {
+  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));
 
     sendRequest("events.getRules",
                 [this.eventName_, ruleIdentifiers, cb],
                 ruleFunctionSchemas.getRules.parameters);
   }
 
   // Special load events: we don't use the DOM unload because that slows
   // down tab shutdown.  On the other hand, onUnload might not always fire,
   // since Chrome will terminate renderers on shutdown (SuddenTermination).
-  chromeHidden.onLoad = new chrome.Event();
-  chromeHidden.onUnload = new chrome.Event();
+  chromeHidden.onLoad = new Event();
+  chromeHidden.onUnload = new Event();
 
   chromeHidden.dispatchOnLoad =
       chromeHidden.onLoad.dispatch.bind(chromeHidden.onLoad);
 
   chromeHidden.dispatchOnUnload = function() {
     chromeHidden.onUnload.dispatch();
     for (var i = 0; i < allAttachedEvents.length; ++i) {
       var event = allAttachedEvents[i];
       if (event)
         event.detach_();
     }
   };
 
   chromeHidden.dispatchError = function(msg) {
     console.error(msg);
   };
 
-  exports.Event = chrome.Event;
+  chrome.Event = Event;