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 418 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);
+      pm->IncrementLazyKeepaliveCount(extension, true);
   }
 }
 
 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() {
 }