Keep lazy background page alive while there are pending network requests or

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/values.h"
 #include "chrome/browser/extensions/extension_devtools_manager.h"
@@ skipping 343 matching lines @@
   for (std::set<ListenerProcess>::iterator listener = listeners.begin();
        listener != listeners.end(); ++listener) {
     if (!extension_id.empty() && extension_id != listener->extension_id)
       continue;
 
     const Extension* extension = service->extensions()->GetByID(
         listener->extension_id);
 
     if (extension && !CanDispatchEventNow(extension)) {
       AppendEvent(extension->id(), event);
-      pm->CreateBackgroundHost(extension, extension->GetBackgroundURL());
+      if (!pm->GetBackgroundHostForExtension(extension->id())) {
+        // Balanced in DispatchPendingEvents, after the page has loaded.

[Yoyo Zhou, 2012/03/02 03:10:46]

Is it possible for there to be a race between loading the lazy background page
for some other reason and receiving an event?

[Matt Perry, 2012/03/02 20:25:21]

The only thing that causes a lazy bg page to load is receiving an event.

+        pm->IncrementLazyKeepaliveCount(extension);
+        pm->CreateBackgroundHost(extension, extension->GetBackgroundURL());
+      }
     }
   }
 }
 
 void ExtensionEventRouter::IncrementInFlightEvents(const Extension* extension) {
   if (!extension->background_page_persists()) {
     profile_->GetExtensionProcessManager()->IncrementLazyKeepaliveCount(
         extension);
   }
 }
@@ skipping 26 matching lines @@
 void ExtensionEventRouter::DispatchPendingEvents(
     const std::string& extension_id) {
   CHECK(!extension_id.empty());
   PendingEventsPerExtMap::const_iterator map_it =
       pending_events_.find(extension_id);
   if (map_it == pending_events_.end()) {
     NOTREACHED();  // lazy page should not load without any pending events
     return;
   }
 
-  // Temporarily increment the keepalive count while dispatching the events.
-  // This also ensures that if no events were dispatched, the extension returns
-  // to "idle" and is shut down.
-  const Extension* extension =
-      profile_->GetExtensionService()->extensions()->GetByID(extension_id);
-  ExtensionProcessManager* pm = profile_->GetExtensionProcessManager();
-  pm->IncrementLazyKeepaliveCount(extension);
-
   PendingEventsList* events_list = map_it->second.get();
   for (PendingEventsList::const_iterator it = events_list->begin();
        it != events_list->end(); ++it)
     DispatchEventImpl(extension_id, *it, true);
 
   events_list->clear();
   pending_events_.erase(extension_id);
 
+  // Balance the keepalive addref in LoadLazyBackgroundPagesForEvent.
+  const Extension* extension =
+      profile_->GetExtensionService()->extensions()->GetByID(extension_id);
+  ExtensionProcessManager* pm = profile_->GetExtensionProcessManager();
   pm->DecrementLazyKeepaliveCount(extension);
 }
 
 void ExtensionEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
@@ skipping 62 matching lines @@
           extension->id(), kOnInstalledEvent, "[]", NULL, GURL());
       break;
     }
 
     // TODO(tessamac): if background page crashed/failed clear queue.
     default:
       NOTREACHED();
       return;
   }
 }