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 356 matching lines @@
 
 void ExtensionEventRouter::DispatchEventImpl(
     const std::string& restrict_to_extension_id,
     const linked_ptr<ExtensionEvent>& event) {
   // We don't expect to get events from a completely different profile.
   DCHECK(!event->restrict_to_profile ||
          profile_->IsSameProfile(event->restrict_to_profile));
 
   std::set<const EventListener*> listeners(
       listeners_.GetEventListeners(*event));
+
+  // We dispatch events for lazy background pages first because attempting to do
+  // so will cause those that are being suspended to cancel that suspension.
+  // As canceling a suspension entails sending an event to the affected
+  // background page, and as that event needs to be delivered before we dispatch
+  // the event we are dispatching here, we dispatch to the lazy listeners here
+  // first.
   for (std::set<const EventListener*>::iterator it = listeners.begin();
        it != listeners.end(); it++) {
     const EventListener* listener = *it;
+    if (restrict_to_extension_id.empty() ||
+        restrict_to_extension_id == listener->extension_id) {
+      if (!listener->process)
+        DispatchLazyEvent(listener->extension_id, event);
+    }
+  }
+
+  for (std::set<const EventListener*>::iterator it = listeners.begin();
+       it != listeners.end(); it++) {
+    const EventListener* listener = *it;
     if (restrict_to_extension_id.empty() ||
         restrict_to_extension_id == listener->extension_id) {
       if (listener->process) {
         DispatchEventToProcess(listener->extension_id, listener->process,
                                event);
-      } else {
-        DispatchLazyEvent(listener->extension_id, event);
       }
     }
   }
 }
 
 void ExtensionEventRouter::DispatchLazyEvent(
     const std::string& extension_id,
     const linked_ptr<ExtensionEvent>& event) {
   ExtensionService* service = profile_->GetExtensionService();
   // Check both the original and the incognito profile to see if we
@@ skipping 32 matching lines @@
       !process_map->Contains(extension->id(), process->GetID())) {
     return;
   }
 
   const Value* event_args = NULL;
   if (!CanDispatchEventToProfile(listener_profile, extension,
                                  event, &event_args)) {
     return;
   }
 
-  // We need to call IncrementInFlightEvents() before DispatchEvent() because
-  // the former may prevent this extension from getting suspended and so send
-  // the onSuspendCanceled() to the extension, which needs to arrive before the
-  // event that DispatchEvent() is dispatching.
-  IncrementInFlightEvents(listener_profile, extension);
-
   DispatchEvent(process, extension_id,
                 event->event_name, *event_args,
                 event->event_url, event->user_gesture,
                 event->info);
+  IncrementInFlightEvents(listener_profile, extension);
 }
 
 bool ExtensionEventRouter::CanDispatchEventToProfile(
     Profile* profile,
     const Extension* extension,
     const linked_ptr<ExtensionEvent>& event,
     const Value** event_args) {
   *event_args = event->event_args.get();
 
   // Is this event from a different profile than the renderer (ie, an
@@ skipping 32 matching lines @@
 
 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());
     if (host)
-      pm->IncrementLazyKeepaliveCount(
-          extension, ExtensionProcessManager::CANCEL_SUSPEND);
+      pm->IncrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionEventRouter::OnEventAck(
     Profile* profile, const std::string& extension_id) {
   ExtensionProcessManager* pm =
       extensions::ExtensionSystem::Get(profile)->process_manager();
   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id);
   // The event ACK is routed to the background host, so this should never be
   // NULL.
@@ skipping 112 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() {
 }