Add filtered event support to event.js.

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 AttachFilteredEvent = eventBindingsNatives.AttachFilteredEvent;
+  var DetachFilteredEvent = eventBindingsNatives.DetachFilteredEvent;

[Matt Perry, 2012/05/15 19:28:27]

I don't see these in this CL.

[koz (OOO until 15th September), 2012/05/16 01:26:12]

These are only exercised by the unit test where we provide an implementation
(via OverrideNativeHandler()). I'm working on a separate patch where I implement
the real version of these (which will be covered by a browser test).

 
   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 21 matching lines @@
           $Array.prototype.toJSON = customizedArrayToJSON;
         }
       }
     };
 
     this.parse = function(thing) {
       return $jsonParse(thing);
     };
   })();
 
+  // Handles adding/removing/dispatching listeners for unfiltered events.
+  var UnfilteredAttachmentStrategy = function(event) {
+    this.event_ = event;
+    this.eventName_ = event.eventName_;
+  };
+
+  UnfilteredAttachmentStrategy.prototype.onAddedListener =
+      function(listener) {
+        // Only attach / detach on the first / last listener removed.

[Matt Perry, 2012/05/15 19:28:27]

Is this proper formatting? I thought indent should still be +2 from the
Unfiltered* line.

[koz (OOO until 15th September), 2012/05/16 01:26:12]

Done.

+        if (this.event_.listeners_.length > 1)
+          return;
+        AttachEvent(this.eventName_);
+        allAttachedEvents[allAttachedEvents.length] = this.event_;
+        if (!this.eventName_)
+          return;
+
+        if (attachedNamedEvents[this.eventName_]) {
+          throw new Error("chrome.Event '" + this.eventName_ +
+                          "' is already attached.");
+        }
+
+        attachedNamedEvents[this.eventName_] = this.event_;
+      };
+
+  UnfilteredAttachmentStrategy.prototype.onRemovedListener =
+      function(listener) {
+        if (this.event_.listeners_.length == 0)
+          this.detach(true);
+      };
+
+  UnfilteredAttachmentStrategy.prototype.detach =
+      function(manual) {
+        var i = allAttachedEvents.indexOf(this.event_);
+        if (i >= 0)
+          delete allAttachedEvents[i];
+        DetachEvent(this.eventName_, manual);
+        if (!this.eventName_)
+          return;
+
+        if (!attachedNamedEvents[this.eventName_]) {
+          throw new Error("chrome.Event '" + this.eventName_ +
+                          "' is not attached.");
+        }
+
+        delete attachedNamedEvents[this.eventName_];
+      };
+
+  var FilteredAttachmentStrategy = function(event) {
+    this.event_ = event;
+    this.eventName_ = event.eventName_;
+    this.listenerMap_ = {};
+  };
+
+  FilteredAttachmentStrategy.prototype.onAddedListener = function(listener) {
+    var id = AttachFilteredEvent(this.eventName_, listener.filters || {});
+    listener.id = id;
+    this.listenerMap_[id] = listener;
+  };
+
+  FilteredAttachmentStrategy.prototype.onRemovedListener = function(listener) {
+    this.detachListener(listener, true);
+  }
+
+  FilteredAttachmentStrategy.prototype.detachListener =
+      function(listener, manual) {
+    if (listener.id == undefined)
+      throw new Error("listener.id undefined - '" + listener + "'");
+    var id = listener.id;
+    delete this.listenerMap_[id];
+    DetachFilteredEvent(id, manual);
+  };
+
+  FilteredAttachmentStrategy.prototype.detach = function(manual) {
+    for (var i in this.listenerMap_)
+      this.detachListener(this.listenerMap_[i], manual);
+  };
+
   // 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. Note that
   // 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) {
     this.eventName_ = opt_eventName;
     this.listeners_ = [];
     this.eventOptions_ = opt_eventOptions ||
-        {"supportsListeners": true, "supportsRules": false};
+        {"supportsListeners": true,
+         "supportsRules": false,
+         "supportsFilters": false,

[Matt Perry, 2012/05/15 19:28:27]

nit: quotes are unnecessary

[koz (OOO until 15th September), 2012/05/16 01:26:12]

Done.

+        };
 
     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 {
+      this.attachmentStrategy_ = new UnfilteredAttachmentStrategy(this);
+    }
+
     // 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 + " -- " +
@@ skipping 48 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) {
+  chrome.Event.prototype.addListener = function(cb, filters) {
     if (!this.eventOptions_.supportsListeners)
       throw new Error("This event does not support listeners.");
-    if (this.listeners_.length == 0) {
-      this.attach_();
-    }
-    this.listeners_.push(cb);
+    if (!this.eventOptions_.supportsFilters && filters)
+      throw new Error("This event does not support filters.");
+    var listener = {callback: cb, filters: filters};
+    this.listeners_.push(listener);
+    this.attachmentStrategy_.onAddedListener(listener);
   };
 
   // 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;
     }
 
+    var removedListener = this.listeners_[idx];
     this.listeners_.splice(idx, 1);
-    if (this.listeners_.length == 0) {
-      this.detach_(true);
-    }
+    this.attachmentStrategy_.onRemovedListener(removedListener);
   };
 
   // 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() {
     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) {
+      if (this.listeners_[i].callback == 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);
     var validationErrors = this.validate_(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);
+        var result = this.listeners_[i].callback.apply(null, 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};
   };
 
-  // Attaches this event object to its name.  Only one object can have a given
-  // name.
-  chrome.Event.prototype.attach_ = function() {
-    AttachEvent(this.eventName_);
-    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;
-  };
-
   // Detaches this event object from its name.
-  chrome.Event.prototype.detach_ = function(manual) {
-    var i = allAttachedEvents.indexOf(this);
-    if (i >= 0)
-      delete allAttachedEvents[i];
-    DetachEvent(this.eventName_, manual);
-    if (!this.eventName_)
-      return;
-
-    if (!attachedNamedEvents[this.eventName_]) {
-      throw new Error("chrome.Event '" + this.eventName_ +
-                      "' is not attached.");
-    }
-
-    delete attachedNamedEvents[this.eventName_];
+  chrome.Event.prototype.detach = function() {
+    this.attachmentStrategy_.detach(false);
   };
 
   chrome.Event.prototype.destroy_ = function() {
-    this.listeners_ = [];
+    var listenersToRemove = this.listeners_.slice();
+    for (var listener in listenersToRemove) {
+      this.removeListener(listener);

[Matt Perry, 2012/05/15 19:28:27]

This will result in detach being called with manual=true. Why not just call
detach directly?

[koz (OOO until 15th September), 2012/05/16 01:26:12]

Indeed that is what happens and this is dead code. Removed.

+    }
     this.validate_ = [];
-    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;
   }
@@ skipping 37 matching lines @@
   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);
+        event.detach();
     }
   };
 
   chromeHidden.dispatchError = function(msg) {
     console.error(msg);
   };
 
   exports.Event = chrome.Event;