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"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 87 matching lines @@
 
 struct ExtensionProcessManager::BackgroundPageData {
   // The count of things keeping the lazy background page alive.
   int lazy_keepalive_count;
 
   // This is used with the ShouldUnload message, to ensure that the extension
   // remained idle between sending the message and receiving the ack.
   int close_sequence_id;
 
   // True if the page responded to the ShouldUnload message and is currently
-  // dispatching the unload event. We use this to ignore any activity
-  // generated during the unload event that would otherwise keep the
-  // extension alive.
+  // dispatching the unload event. During this time any events that arrive will
+  // cancel the unload process and an onSuspendCanceled event will be dispatched
+  // to the page.
   bool is_closing;
 
   // Keeps track of when this page was last unloaded. Used for perf metrics.
   linked_ptr<PerfTimer> since_unloaded;
 
   BackgroundPageData()
       : lazy_keepalive_count(0), close_sequence_id(0), is_closing(false) {}
 };
 
 //
@@ skipping 278 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, bool cancel_suspend) {
+  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 (cancel_suspend && is_closing) {
+      is_closing = false;
+      ExtensionHost* host = GetBackgroundHostForExtension(extension->id());
+      if (host)
+        host->render_view_host()->Send(
+            new ExtensionMsg_CancelUnload(extension->id()));

[benwells, 2012/07/20 10:57:00]

Nit: braces around the if body as there is more than one physical line.

+    }
+    OnLazyBackgroundPageActive(extension->id());
+  }
+
+  return count;
+}
+
+int ExtensionProcessManager::IncrementLazyKeepaliveCount(
      const Extension* extension) {
-  if (!extension->has_lazy_background_page())
-    return 0;
-
-  int& count = background_page_data_[extension->id()].lazy_keepalive_count;
-  if (++count == 1)
-    OnLazyBackgroundPageActive(extension->id());
-
-  return count;
+  return IncrementLazyKeepaliveCount(extension, false);
 }
 
 int ExtensionProcessManager::DecrementLazyKeepaliveCount(
      const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
   DCHECK_GT(count, 0);
   if (--count == 0) {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ExtensionProcessManager::OnLazyBackgroundPageIdle,
                    weak_ptr_factory_.GetWeakPtr(), extension->id(),
                    ++background_page_data_[extension->id()].close_sequence_id),
         event_page_idle_time_);
   }
 
   return count;
 }
+
 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)
@@ skipping 30 matching lines @@
 void ExtensionProcessManager::OnShouldUnloadAck(
      const std::string& extension_id, int sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     host->render_view_host()->Send(new ExtensionMsg_Unload(extension_id));
   }
 }
 
 void ExtensionProcessManager::OnUnloadAck(const std::string& extension_id) {
+  background_page_data_[extension_id].is_closing = true;
+  int sequence_id = background_page_data_[extension_id].close_sequence_id;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ExtensionProcessManager::CloseLazyBackgroundPageNow,
-                 weak_ptr_factory_.GetWeakPtr(), extension_id),
+                 weak_ptr_factory_.GetWeakPtr(), extension_id, sequence_id),
       event_page_unloading_time_);
 }
 
 void ExtensionProcessManager::CloseLazyBackgroundPageNow(
-    const std::string& extension_id) {
-  background_page_data_[extension_id].is_closing = true;
+    const std::string& extension_id, int sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
-  if (host)
-    CloseBackgroundHost(host);
+  if (host &&
+      sequence_id == background_page_data_[extension_id].close_sequence_id) {
+    ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
+    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());
 }
 
@@ skipping 83 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);
+          IncrementLazyKeepaliveCount(extension, true);
       }
       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;
   }
 }