Revert of Move the event attach/detach logic on unload from event.js to

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.
 
   var exceptionHandler = require('uncaught_exception_handler');
   var eventNatives = requireNative('event_natives');
   var logging = requireNative('logging');
   var schemaRegistry = requireNative('schema_registry');
   var sendRequest = require('sendRequest').sendRequest;
   var utils = require('utils');
   var validate = require('schemaUtils').validate;
+  var unloadEvent = require('unload_event');
 
   // 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 = 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');
   }
 
   // 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.
   var eventArgumentMassagers = {};
 
   // An attachment strategy for events that aren't attached to the browser.
   // This applies to events with the "unmanaged" option and events without
   // names.
   var NullAttachmentStrategy = function(event) {
     this.event_ = event;
   };
@@ skipping 222 matching lines @@
     }
     var listener = {callback: cb, filters: filters};
     this.attach_(listener);
     $Array.push(this.listeners, listener);
   };
 
   EventImpl.prototype.attach_ = function(listener) {
     this.attachmentStrategy.onAddedListener(listener);
 
     if (this.listeners.length == 0) {
+      allAttachedEvents[allAttachedEvents.length] = this;
       if (this.eventName) {
         if (attachedNamedEvents[this.eventName]) {
           throw new Error("Event '" + this.eventName +
                           "' is already attached.");
         }
         attachedNamedEvents[this.eventName] = this;
       }
     }
   };
 
   // Unregisters a callback.
   EventImpl.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 = $Array.splice(this.listeners, idx, 1)[0];
     this.attachmentStrategy.onRemovedListener(removedListener);
 
     if (this.listeners.length == 0) {
+      var i = $Array.indexOf(allAttachedEvents, this);
+      if (i >= 0)
+        delete allAttachedEvents[i];
       if (this.eventName) {
         if (!attachedNamedEvents[this.eventName]) {
           throw new Error(
               "Event '" + this.eventName + "' is not attached.");
         }
         delete attachedNamedEvents[this.eventName];
       }
     }
   };
 
@@ skipping 168 matching lines @@
     validate([this.webViewInstanceId, ruleIdentifiers, cb],
              $Array.splice(
                  $Array.slice(ruleFunctionSchemas.getRules.parameters), 1));
 
     sendRequest(
       "events.getRules",
       [this.eventName, this.webViewInstanceId, ruleIdentifiers, cb],
       ruleFunctionSchemas.getRules.parameters);
   }
 
+  unloadEvent.addListener(function() {
+    for (var i = 0; i < allAttachedEvents.length; ++i) {
+      var event = allAttachedEvents[i];
+      if (event)
+        event.detach_();
+    }
+  });
+
   var Event = utils.expose('Event', EventImpl, { functions: [
     'addListener',
     'removeListener',
     'hasListener',
     'hasListeners',
     'dispatchToListener',
     'dispatch',
     'addRules',
     'removeRules',
     'getRules'
   ] });
 
   // NOTE: Event is (lazily) exposed as chrome.Event from dispatcher.cc.
   exports.Event = Event;
 
   exports.dispatchEvent = dispatchEvent;
   exports.parseEventOptions = parseEventOptions;
   exports.registerArgumentMassager = registerArgumentMassager;