Introduce runtime.onSuspendCanceled() event.

chrome/browser/extensions/extension_process_manager.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 396 matching lines @@
 }
 
 int ExtensionProcessManager::GetLazyKeepaliveCount(const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
   return background_page_data_[extension->id()].lazy_keepalive_count;
 }
 
 int ExtensionProcessManager::IncrementLazyKeepaliveCount(
-     const Extension* extension, ShouldCancelSuspend should_cancel_suspend) {
+     const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
-  bool& is_closing = background_page_data_[extension->id()].is_closing;
-  if (++count == 1) {
-    if (should_cancel_suspend == CANCEL_SUSPEND && is_closing) {
-      is_closing = false;
-      ExtensionHost* host = GetBackgroundHostForExtension(extension->id());
-      if (host)
-        host->render_view_host()->Send(
-            new ExtensionMsg_CancelUnload(extension->id()));
-    }
+  if (++count == 1)
     OnLazyBackgroundPageActive(extension->id());
-  }
 
   return count;
 }
 
 int ExtensionProcessManager::DecrementLazyKeepaliveCount(
      const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
@@ skipping 13 matching lines @@
 void ExtensionProcessManager::IncrementLazyKeepaliveCountForView(
     RenderViewHost* render_view_host) {
   WebContents* web_contents =
       WebContents::FromRenderViewHost(render_view_host);
   chrome::ViewType view_type = chrome::GetViewType(web_contents);
   if (view_type != chrome::VIEW_TYPE_INVALID &&
       view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
-      IncrementLazyKeepaliveCount(extension, DONT_CANCEL_SUSPEND);
+      IncrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::OnLazyBackgroundPageIdle(
     const std::string& extension_id, int sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host && !background_page_data_[extension_id].is_closing &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     // Tell the renderer we are about to close. This is a simple ping that the
     // renderer will respond to. The purpose is to control sequencing: if the
@@ skipping 44 matching lines @@
     if (host)
       CloseBackgroundHost(host);
   }
 }
 
 void ExtensionProcessManager::OnNetworkRequestStarted(
     RenderViewHost* render_view_host) {
   ExtensionHost* host = GetBackgroundHostForExtension(
       GetExtensionID(render_view_host));
   if (host && host->render_view_host() == render_view_host)
-    IncrementLazyKeepaliveCount(host->extension(), DONT_CANCEL_SUSPEND);
+    IncrementLazyKeepaliveCount(host->extension());
 }
 
 void ExtensionProcessManager::OnNetworkRequestDone(
     RenderViewHost* render_view_host) {
   ExtensionHost* host = GetBackgroundHostForExtension(
       GetExtensionID(render_view_host));
   if (host && host->render_view_host() == render_view_host)
     DecrementLazyKeepaliveCount(host->extension());
 }
 
+void ExtensionProcessManager::CancelSuspend(const Extension* extension) {
+  bool& is_closing = background_page_data_[extension->id()].is_closing;
+  ExtensionHost* host = GetBackgroundHostForExtension(extension->id());
+  if (host && is_closing) {
+    is_closing = false;
+    host->render_view_host()->Send(
+        new ExtensionMsg_CancelUnload(extension->id()));
+  }
+  IncrementLazyKeepaliveCount(extension);
+  DecrementLazyKeepaliveCount(extension);

[Matt Perry, 2012/07/25 19:21:55]

Could you add a comment why this is necessary?

(The ugliness of this makes me slightly prefer the approach of passing
should_cancel_suspend to IncrementLazyKeepaliveCount, but both approaches are
fine.)

[koz (OOO until 15th September), 2012/07/26 00:40:08]

I've added a comment and will leave it this way, because leveraging the existing
code's behaviour seems like a win.

(I also moved it to inside the conditional because it's unnecessary to do it if
the extension isn't closing).

+}
+
 void ExtensionProcessManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       CreateBackgroundHostsForProfileStartup(this,
           content::Source<Profile>(source).ptr()->
               GetExtensionService()->extensions());
       break;
@@ skipping 65 matching lines @@
           content::Details<RenderViewHost>(details).ptr();
       WebContents* web_contents =
           WebContents::FromRenderViewHost(render_view_host);
       // Keep the lazy background page alive while it's being inspected.
       // Balanced in response to the CLOSING notification.
       if (chrome::GetViewType(web_contents) ==
               chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         const Extension* extension = GetExtensionForRenderViewHost(
             render_view_host);
         if (extension)
-          IncrementLazyKeepaliveCount(extension, CANCEL_SUSPEND);
+          IncrementLazyKeepaliveCount(extension);
       }
       break;
     }
 
     case content::NOTIFICATION_DEVTOOLS_WINDOW_CLOSING: {
       RenderViewHost* render_view_host =
           content::Details<RenderViewHost>(details).ptr();
       WebContents* web_contents =
           WebContents::FromRenderViewHost(render_view_host);
       // Balanced in response to the OPENING notification.
@@ skipping 157 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }