Introduce runtime.onSuspendCanceled() event.

chrome/browser/extensions/extension_event_router.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_event_router.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 201 matching lines @@
     prefs->SetRegisteredEvents(extension_id, events);
   }
 }
 
 void ExtensionEventRouter::AddFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const std::string& extension_id,
     const base::DictionaryValue& filter,
     bool add_lazy_listener) {
-  listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
-      event_name, extension_id, process,
-      scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
-
   if (add_lazy_listener) {
     bool added = listeners_.AddListener(scoped_ptr<EventListener>(
         new EventListener(event_name, extension_id, NULL,
         scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 
     if (added) {
       extensions::ExtensionPrefs* prefs =
           profile_->GetExtensionService()->extension_prefs();
       prefs->AddFilterToEvent(event_name, extension_id, &filter);
     }
+  } else {

[Matt Perry, 2012/07/24 19:25:15]

Did you mean to make this change? It seems unrelated.

+    listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
+        event_name, extension_id, process,
+        scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
   }
 }
 
 void ExtensionEventRouter::RemoveFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const std::string& extension_id,
     const base::DictionaryValue& filter,
     bool remove_lazy_listener) {
   EventListener listener(event_name, extension_id, process,
@@ skipping 223 matching lines @@
 void ExtensionEventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
     Profile* profile,
     const Extension* extension,
     const linked_ptr<ExtensionEvent>& event) {
   const Value* event_args = NULL;
   if (!CanDispatchEventToProfile(profile, extension, event, &event_args))
     return;
 
   extensions::LazyBackgroundTaskQueue* queue =
       extensions::ExtensionSystem::Get(profile)->lazy_background_task_queue();
-  if (queue->ShouldEnqueueTask(profile, extension)) {

[Matt Perry, 2012/07/24 19:25:15]

Doesn't removing this result in a double dispatch of the event? It means we'd
always call DispatchPendingEvent, even if we *shouldn't* enqueue the task - i.e.
if the event page is already loaded. Since a regular listener has been
registered in that case, we'll dispatch to the regular listener, then dispatch
again for this lazy listener.

[koz (OOO until 15th September), 2012/07/25 07:48:31]

The idea here was to make it so lazy background pages don't register non-lazy
event handlers, so the lazy dispatch will always either send to a currently
existing ExtensionHost or add a pending task.

-    queue->AddPendingTask(
-        profile, extension->id(),
-        base::Bind(&ExtensionEventRouter::DispatchPendingEvent,
-                   base::Unretained(this), event));
-  }
+  queue->AddPendingTask(
+      profile, extension->id(),
+      base::Bind(&ExtensionEventRouter::DispatchPendingEvent,
+                  base::Unretained(this), event));
 }
 
 void ExtensionEventRouter::IncrementInFlightEvents(
     Profile* profile, const Extension* extension) {
   // Only increment in-flight events if the lazy background page is active,
   // because that's the only time we'll get an ACK.
   if (extension->has_lazy_background_page()) {
     ExtensionProcessManager* pm =
         extensions::ExtensionSystem::Get(profile)->process_manager();
     ExtensionHost* host = pm->GetBackgroundHostForExtension(extension->id());
@@ skipping 124 matching lines @@
       event_args(event_args.DeepCopy()),
       event_url(event_url),
       restrict_to_profile(restrict_to_profile),
       cross_incognito_args(NULL),
       user_gesture(user_gesture),
       info(info) {
 }
 
 ExtensionEvent::~ExtensionEvent() {
 }