Move declarative API into events API

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 eventBindingsNatives = requireNative('event_bindings');
   var AttachEvent = eventBindingsNatives.AttachEvent;
   var DetachEvent = eventBindingsNatives.DetachEvent;
   var Print = eventBindingsNatives.Print;
+  var sendRequest = require('sendRequest').sendRequest;

[Aaron Boodman, 2012/05/09 19:29:46]

TODO(aa): Look at this file more closely.

 
   var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
 
   // Local implementation of JSON.parse & JSON.stringify that protect us
   // from being clobbered by an extension.
   //
   // TODO(aa): This makes me so sad. We shouldn't need it, as we can just pass
   // Values directly over IPC without serializing to strings and use
   // JSONValueConverter.
   chromeHidden.JSON = new (function() {
@@ skipping 34 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) {
+  chrome.Event = function(opt_eventName, opt_argSchemas, opt_eventOptions,

[not at google - send to devlin, 2012/05/10 09:01:25]

nit: arguments should line up or fix on 1 line :(

[battre, 2012/05/10 16:40:29]

According to the JavaScript Style Guide, the rule is:

"When possible, all function arguments should be listed on the same line. If
doing so would exceed the 80-column limit, the arguments must be line-wrapped in
a readable way. To save space, you may wrap as close to 80 as possible, or put
each argument on its own line to enhance readability. The indentation may be
either four spaces, or aligned to the parenthesis. Below are the most common
patterns for argument wrapping"

So it is not necessary that all arguments line up. I have added a line break
after function( to put all of them on one line.

+                          opt_eventsSchema) {
     this.eventName_ = opt_eventName;
     this.listeners_ = [];
     this.eventOptions_ = opt_eventOptions ||
         {"supportsListeners": true, "supportsRules": false};
+    this.eventsSchema_ = opt_eventsSchema;
 
     if (this.eventOptions_.supportsRules && !opt_eventName)
       throw new Error("Events that support rules require an event name.");
 
-    // Validate event parameters if we are in debug.
+    // Validate event arguments (the data that is passed to the callbacks)
+    // if we are in debug.
     if (opt_argSchemas &&
         chromeHidden.validateCallbacks &&
         chromeHidden.validate) {
 
-      this.validate_ = function(args) {
+      this.validateEventArgs_ = function(args) {
         try {
           chromeHidden.validate(args, opt_argSchemas);
         } catch (exception) {
           return "Event validation error during " + opt_eventName + " -- " +
                  exception;
         }
       };
     } else {
-      this.validate_ = function() {}
+      this.validateEventArgs_ = function() {}
+    }
+
+    if (this.eventOptions_.supportsRules) {
+      if (!this.eventsSchema_) {
+        throw new Error("Events with rules support require the schema of the " +
+                        "chrome.events namespace");
+      }
+      // Determine schemas of function parameters.
+      var eventType = chromeHidden.lookup(this.eventsSchema_.types,
+                                          'id', 'Event');

[not at google - send to devlin, 2012/05/10 09:01:25]

nit: argument lineup thing (and on the lines below)

[battre, 2012/05/10 16:40:29]

See above

+      this.addRulesParams_ = chromeHidden.lookup(eventType.functions,
+          'name', 'addRules').parameters;
+      this.getRulesParams_ = chromeHidden.lookup(eventType.functions,
+          'name', 'getRules').parameters;
+      this.removeRulesParams_ = chromeHidden.lookup(eventType.functions,
+          'name', 'removeRules').parameters;
+    } else {
+      this.addRulesParams_ = [];
+      this.getRulesParams_ = [];
+      this.removeRulesParams_ = [];
     }
   };
 
   // A map of event names to the event object that is registered to that name.
   var attachedNamedEvents = {};
 
   // An array of all attached event objects, used for detaching on unload.
   var allAttachedEvents = [];
 
   // A map of functions that massage event arguments before they are dispatched.
@@ skipping 89 matching lines @@
 
     return -1;
   };
 
   // Dispatches this event object to all listeners, passing all supplied
   // arguments to this function each listener.
   chrome.Event.prototype.dispatch = function(varargs) {
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
     var args = Array.prototype.slice.call(arguments);
-    var validationErrors = this.validate_(args);
+    var validationErrors = this.validateEventArgs_(args);
     if (validationErrors) {
       return {validationErrors: validationErrors};
     }
     var results = [];
     for (var i = 0; i < this.listeners_.length; i++) {
       try {
         var result = this.listeners_[i].apply(null, args);
         if (result !== undefined)
           results.push(result);
       } catch (e) {
@@ skipping 33 matching lines @@
     if (!attachedNamedEvents[this.eventName_]) {
       throw new Error("chrome.Event '" + this.eventName_ +
                       "' is not attached.");
     }
 
     delete attachedNamedEvents[this.eventName_];
   };
 
   chrome.Event.prototype.destroy_ = function() {
     this.listeners_ = [];
-    this.validate_ = [];
+    this.validateEventArgs_ = [];
     this.detach_(false);
   };
 
-  // Gets the declarative API object, or undefined if this extension doesn't
-  // have access to it.
-  //
-  // This is defined as a function (rather than a variable) because it isn't
-  // accessible until the schema bindings have been generated.
-  function getDeclarativeAPI() {
-    return chromeHidden.internalAPIs.declarative;
-  }
-
   chrome.Event.prototype.addRules = function(rules, opt_cb) {
     if (!this.eventOptions_.supportsRules)
       throw new Error("This event does not support rules.");
-    if (!getDeclarativeAPI()) {
-      throw new Error("You must have permission to use the declarative " +
-                      "API to support rules in events");
+
+    // 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': {
+          'choices': typesList.map(function(el) {return {'$ref': el};})
+        }
+      };
+    };
+
+    // Validate conditions and actions against specific schemas of this
+    // event object type.
+    // |rules| is an array of JSON objects that follow the Rule type of the
+    // declarative extension APIs. |conditions| is an array of JSON type
+    // identifiers that are allowed to occur in the conditions attribute of each
+    // rule. Likewise, |actions| is an array of JSON type identifiers that are
+    // allowed to occur in the actions attribute of each rule.
+    function validateRules(rules, conditions, actions) {
+      var conditionsSchema = buildArrayOfChoicesSchema(conditions);
+      var actionsSchema = buildArrayOfChoicesSchema(actions);
+      rules.forEach(function(rule) {
+        chromeHidden.validate([rule.conditions], [conditionsSchema]);
+        chromeHidden.validate([rule.actions], [actionsSchema]);
+      })
+    };
+
+    if (!this.eventOptions_.conditions || !this.eventOptions_.actions) {
+      throw new Error('Event ' + this.eventName_ + ' misses conditions or ' +
+                'actions in the API specification.');
     }
-    getDeclarativeAPI().addRules(this.eventName_, rules, opt_cb);
+
+    validateRules(rules,
+                  this.eventOptions_.conditions,
+                  this.eventOptions_.actions);
+
+    sendRequest("events.addRules", [this.eventName_, rules, opt_cb],
+                this.addRulesParams_);

[not at google - send to devlin, 2012/05/10 09:01:25]

did we lose the ability to do chromeHidden.internalAPIs.events.addRules(...)
like before?

[battre, 2012/05/10 16:40:29]

Yes, because there is no such function anymore. "events.addRules" is the
function that is described in the "Event" type of events.json as "addRules".

   }
 
   chrome.Event.prototype.removeRules = function(ruleIdentifiers, opt_cb) {
     if (!this.eventOptions_.supportsRules)
       throw new Error("This event does not support rules.");
-    if (!getDeclarativeAPI()) {
-      throw new Error("You must have permission to use the declarative " +
-                      "API to support rules in events");
-    }
-    getDeclarativeAPI().removeRules(
-        this.eventName_, ruleIdentifiers, opt_cb);
+    sendRequest("events.removeRules",
+                [this.eventName_, ruleIdentifiers, opt_cb],
+                this.removeRulesParams_);
   }
 
   chrome.Event.prototype.getRules = function(ruleIdentifiers, cb) {
     if (!this.eventOptions_.supportsRules)
       throw new Error("This event does not support rules.");
-    if (!getDeclarativeAPI()) {
-      throw new Error("You must have permission to use the declarative " +
-                      "API to support rules in events");
-    }
-    getDeclarativeAPI().getRules(
-        this.eventName_, ruleIdentifiers, cb);
+    sendRequest("events.getRules",
+                [this.eventName_, ruleIdentifiers, cb],
+                this.getRulesParams_);
   }
 
   // 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.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_(false);
     }
   };
 
   chromeHidden.dispatchError = function(msg) {
     console.error(msg);
   };