[Extensions Bindings] Introduce a supportsLazyListeners property

extensions/renderer/resources/event.js

 // Copyright 2014 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.
 
 // TODO(robwu): Fix indentation.
 
   var exceptionHandler = require('uncaught_exception_handler');
   var eventNatives = requireNative('event_natives');
   var logging = requireNative('logging');
   var schemaRegistry = requireNative('schema_registry');
@@ skipping 72 matching lines @@
   // Handles adding/removing/dispatching listeners for unfiltered events.
   function UnfilteredAttachmentStrategy(event) {
     this.event_ = event;
   }
   $Object.setPrototypeOf(UnfilteredAttachmentStrategy.prototype, null);
 
   UnfilteredAttachmentStrategy.prototype.onAddedListener =
       function(listener) {
     // Only attach / detach on the first / last listener removed.
     if (this.event_.listeners.length == 0)
-      eventNatives.AttachEvent(this.event_.eventName);
+      eventNatives.AttachEvent(this.event_.eventName,
+                               this.event_.eventOptions.supportsLazyListeners);
   };
 
   UnfilteredAttachmentStrategy.prototype.onRemovedListener =
       function(listener) {
     if (this.event_.listeners.length == 0)
       this.detach(true);
   };
 
   UnfilteredAttachmentStrategy.prototype.detach = function(manual) {
-    eventNatives.DetachEvent(this.event_.eventName, manual);
+    eventNatives.DetachEvent(this.event_.eventName, manual,
+                             this.event_.eventOptions.supportsLazyListeners);
   };
 
   UnfilteredAttachmentStrategy.prototype.getListenersByIDs = function(ids) {
     // |ids| is for filtered events only.
     return this.event_.listeners;
   };
 
   function FilteredAttachmentStrategy(event) {
     this.event_ = event;
     this.listenerMap_ = {__proto__: null};
   }
   $Object.setPrototypeOf(FilteredAttachmentStrategy.prototype, null);
 
   utils.defineProperty(FilteredAttachmentStrategy, 'idToEventMap',
       {__proto__: null});
 
   FilteredAttachmentStrategy.prototype.onAddedListener = function(listener) {
-    var id = eventNatives.AttachFilteredEvent(this.event_.eventName,
-                                              listener.filters || {});
+    var id = eventNatives.AttachFilteredEvent(
+                 this.event_.eventName, listener.filters || {},
+                 this.event_.eventOptions.supportsLazyListeners);
     if (id == -1)
       throw new Error("Can't add listener");
     listener.id = id;
     this.listenerMap_[id] = listener;
     FilteredAttachmentStrategy.idToEventMap[id] = this.event_;
   };
 
   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];
     delete FilteredAttachmentStrategy.idToEventMap[id];
-    eventNatives.DetachFilteredEvent(id, manual);
+    eventNatives.DetachFilteredEvent(
+        id, manual, this.event_.eventOptions.supportsLazyListeners);
   };
 
   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++)
       $Array.push(result, this.listenerMap_[ids[i]]);
     return result;
   };
 
   function parseEventOptions(opt_eventOptions) {
     return $Object.assign({
       __proto__: null,
     }, {
       // Event supports adding listeners with filters ("filtered events"), for
       // example as used in the webNavigation API.
       //
       // event.addListener(listener, [filter1, filter2]);
       supportsFilters: false,
 
       // Events supports vanilla events. Most APIs use these.
       //
       // event.addListener(listener);
       supportsListeners: true,
 
+      // Event supports lazy listeners, where an extension can register a
+      // listener to be used to "wake up" a lazy context.
+      supportsLazyListeners: true,
+
       // Event supports adding rules ("declarative events") rather than
       // listeners, for example as used in the declarativeWebRequest API.
       //
       // event.addRules([rule1, rule2]);
       supportsRules: false,
 
       // Event is unmanaged in that the browser has no knowledge of its
       // existence; it's never invoked, doesn't keep the renderer alive, and
       // the bindings system has no knowledge of it.
       //
@@ skipping 337 matching lines @@
       'getRules',
     ],
   });
 
   // NOTE: Event is (lazily) exposed as chrome.Event from dispatcher.cc.
   exports.$set('Event', Event);
 
   exports.$set('dispatchEvent', dispatchEvent);
   exports.$set('parseEventOptions', parseEventOptions);
   exports.$set('registerArgumentMassager', registerArgumentMassager);