Bindings layer for declarative events API

chrome/renderer/resources/extensions/event.js

 // Copyright (c) 2011 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 chrome = chrome || {};
 (function () {
   native function GetChromeHidden();
   native function AttachEvent(eventName);
   native function DetachEvent(eventName);
   native function Print();
@@ skipping 40 matching lines @@
 
   // Event object.  If opt_eventName is provided, this object represents
   // the unique instance of that named event, and dispatching an event
   // with that name will route through this object's listeners.
   //
   // 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'.
-  chrome.Event = function(opt_eventName, opt_argSchemas) {
+  //
+  // 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) {
     this.eventName_ = opt_eventName;
     this.listeners_ = [];
+    this.eventOptions_ = opt_eventOptions ||
+        {"supportsListeners": true, "supportsRules": false};
 
     // Validate event parameters if we are in debug.
     if (opt_argSchemas &&
         chromeHidden.validateCallbacks &&
         chromeHidden.validate) {
 
       this.validate_ = function(args) {
         try {
           chromeHidden.validate(args, opt_argSchemas);
         } catch (exception) {
           return "Event validation error during " + opt_eventName + " -- " +
                  exception;
         }
       };
+    } else {
+      this.validate_ = function() {}
     }
+
+    this.ruleIds_ = {};
+    this.lastGeneratedRuleId_ = 0;
   };
 
   // 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.
   // Key is event name, value is function.
@@ skipping 31 matching lines @@
   };
 
   // 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) {
+    if (!this.eventOptions_.supportsListeners)
+      throw new Error("This event does not support listeners.");
     if (this.listeners_.length == 0) {
       this.attach_();
     }
     this.listeners_.push(cb);
   };
 
   // Unregisters a callback.
   chrome.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;
     }
 
     this.listeners_.splice(idx, 1);
     if (this.listeners_.length == 0) {
       this.detach_();
     }
   };
 
   // Test if the given callback is registered for this event.
   chrome.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(cb) {
+  chrome.Event.prototype.hasListeners = function() {
+    if (!this.eventOptions_.supportsListeners)
+      throw new Error("This event does not support listeners.");
     return this.listeners_.length > 0;
   };
 
   // Returns the index of the given callback if registered, or -1 if not
   // found.
   chrome.Event.prototype.findListener_ = function(cb) {
     for (var i = 0; i < this.listeners_.length; i++) {
       if (this.listeners_[i] == cb) {
         return i;
       }
     }
 
     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);
     if (this.validate_) {
       var validationErrors = this.validate_(args);
       if (validationErrors) {
         return validationErrors;
       }
     }
     for (var i = 0; i < this.listeners_.length; i++) {
       try {
         this.listeners_[i].apply(null, args);
@@ skipping 36 matching lines @@
 
     delete attachedNamedEvents[this.eventName_];
   };
 
   chrome.Event.prototype.destroy_ = function() {
     this.listeners_ = [];
     this.validate_ = [];
     this.detach_();
   };
 
+  chrome.Event.prototype.getFunctionDefinition_ =
+      function(namespace, functionName) {
+    var filterNamespace = function(val) {return val.namespace === namespace;};
+    var apiSchema = chromeHidden.apiDefinitions.filter(filterNamespace)[0];
+    var filterFunctionName = function (val) {return val.name === functionName;};
+    return apiSchema.functions.filter(filterFunctionName)[0];
+  }
+
+  // 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.
+  chrome.Event.prototype.buildArrayOfChoicesSchema_ = function(typesList) {
+    return {
+      "type": "array",
+      "items": {
+        "choices": typesList.forEach(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.
+  chrome.Event.prototype.validateRules_ = function(rules, conditions, actions) {
+    if (!conditions || !actions) {
+      throw new Error("Error in API specification.");
+    }
+    var conditionsSchema = this.buildArrayOfChoicesSchema_(conditions);
+    var actionsSchema = this.buildArrayOfChoicesSchema_(actions);
+    rules.forEach(function(rule) {
+      chromeHidden.validate([rule.conditions], [conditionsSchema]);
+      chromeHidden.validate([rule.actions], [actionsSchema]);
+    })
+  }
+
+  chrome.Event.prototype.addMissingIds_ = function(rules) {
+    for (var i = 0; i < rules.lengh; ++i) {
+      // TODO(battre): check for "".
+      if (!("id" in rule[i])) {
+        // Generate a unique ID.
+        var newRuleId = "";
+        do {
+          newRuleId = "_" + (this.lastGeneratedRuleId_++) + "_"
+        } while (newRuleId in this.ruleIds_);
+        // And store it.
+        rule[i]["id"] = newRuleId;
+      }
+      this.ruleIds_[rule[i]["id"]] = 1;
+    }
+  }
+
+  chrome.Event.prototype.addRules = function(rules, opt_cb) {
+    if (!this.eventOptions_.supportsRules)
+      throw new Error("This event does not support rules.");
+
+    this.validateRules_(rules,
+                        this.eventOptions_.conditions,
+                        this.eventOptions_.actions);
+    this.addMissingIds_(rules);
+    var callback = opt_cb ? opt_cb.bind(undefined, rules) : undefined;
+
+    var functionDef =
+        this.getFunctionDefinition_("experimental.declarative", "addRules");

[Aaron Boodman, 2012/01/31 00:11:17]

This seems like something sendRequest (or some variant of sendRequest) should
just know how to do.

It shouldn't be the caller's responsibility to dig around and find the schema
for the specified function.

[battre, 2012/01/31 12:28:50]

Done.

+    return chromeHidden.sendRequest.call(
+        this,
+        "experimental.declarative.addRules",
+        [this.eventName_, rules, callback],
+        functionDef.parameters);
+  }
+
+  chrome.Event.prototype.removeRules = function(ruleIdentifiers, opt_cb) {
+    if (!this.eventOptions_.supportsRules)
+      throw new Error("This event does not support rules.");
+    var functionDef =
+        this.getFunctionDefinition_("experimental.declarative", "removeRules");
+    return chromeHidden.sendRequest.call(
+        this,
+        "experimental.declarative.removeRules",
+        [this.eventName_, ruleIdentifiers, opt_cb],
+        functionDef.parameters);
+  }
+
+  chrome.Event.prototype.getRules = function(ruleIdentifiers, cb) {
+    if (!this.eventOptions_.supportsRules)
+      throw new Error("This event does not support rules.");
+    var functionDef =
+        this.getFunctionDefinition_("experimental.declarative", "getRules");
+    return chromeHidden.sendRequest.call(
+        this,
+        "experimental.declarative.getRules",
+        [this.eventName_, ruleIdentifiers, cb],
+        functionDef.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.dispatchOnLoad = function(extensionId, isExtensionProcess,
                                          isIncognitoContext) {
     chromeHidden.onLoad.dispatch(extensionId, isExtensionProcess,
                                  isIncognitoContext);
   };
 
   chromeHidden.dispatchOnUnload = function() {
     chromeHidden.onUnload.dispatch();
     for (var i = 0; i < allAttachedEvents.length; ++i) {
       var event = allAttachedEvents[i];
       if (event)
         event.detach_();
+      if (event && event.eventOptions_.supportsRules)
+        event.removeRules([]);
     }
   };
 
   chromeHidden.dispatchError = function(msg) {
     console.error(msg);
   };
 })();