Introduce runtime.onSuspendCanceled() event.

chrome/browser/extensions/extension_event_router.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 196 matching lines @@
   // Ensures that all lazy background pages that are interested in the given
   // event are loaded, and queues the event if the page is not ready yet.
   void DispatchLazyEvent(const std::string& extension_id,
                          const linked_ptr<ExtensionEvent>& event);
 
   // Dispatches the event to the specified extension running in |process|.
   void DispatchEventToProcess(const std::string& extension_id,
                               content::RenderProcessHost* process,
                               const linked_ptr<ExtensionEvent>& event);
 
+  // Dispatch "onSuspendCanceled" to a particular extension.
+  void DispatchOnSuspendCanceled(
+      content::RenderProcessHost* process, const std::string& extension_id);
+
+  // Returns true if the given extension is in the process of unloading. More
+  // specifically, this will return true in the phase where the onSuspend event
+  // has been fired, but before the extension's background page has been
+  // unloaded. During this period other events that arrive for the extension
+  // cause the unload process to be canceled and an onSuspendCanceled event to
+  // be sent.
+  bool IsClosing(Profile* profile, const extensions::Extension* extension);

[benwells, 2012/07/19 04:01:21]

Could we rename this to MightBeClosing, MaybeClosing, FlaggedToClose... or
something to indicate it might not be closed?

[koz (OOO until 15th September), 2012/07/19 06:52:11]

Hm, I don't think IsClosing() is such a bad name. The fact that it's
IsClosing(), not IsClosed() implies that it is in the process of closing, and
that it's cancelable is not something we need to document in the name of the
function.

In other words, closing is the five second process, not the thing that happens
instantaneously after a delay.

+
   // Returns false when the event is scoped to a profile and the listening
   // extension does not have access to events from that profile. Also fills
   // |event_args| with the proper arguments to send, which may differ if
   // the event crosses the incognito boundary.
   bool CanDispatchEventToProfile(
       Profile* profile,
       const extensions::Extension* extension,
       const linked_ptr<ExtensionEvent>& event,
       const base::Value** event_args);
 
@@ skipping 59 matching lines @@
                  const GURL& event_url,
                  Profile* restrict_to_profile,
                  ExtensionEventRouter::UserGestureState user_gesture,
                  const extensions::EventFilteringInfo& info);
 
   ~ExtensionEvent();
 };
 
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_