Fix bug where transient pages would miss events dispatched while it was

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 "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_host.h"
@@ skipping 355 matching lines @@
 }
 
 SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(const GURL& url) {
   return site_instance_->GetRelatedSiteInstance(url);
 }
 
 bool ExtensionProcessManager::HasExtensionHost(ExtensionHost* host) const {
   return all_hosts_.find(host) != all_hosts_.end();
 }
 
+bool ExtensionProcessManager::IsBackgroundHostClosing(

[Yoyo Zhou, 2012/04/19 21:47:13]

It seems like you could simplify the usage here (in OnLazyBackgroundPage*) and
in LazyBackgroundTaskQueue with something such as
ExtensionHost* GetBackgroundHostForExtensionIfNotClosing()
although this is a weird abstraction.

[Matt Perry, 2012/04/19 22:21:53]

I thought about doing something like that, but I think I prefer keeping this
check as an explicit separate step. I don't feel that strongly, though.

[Yoyo Zhou, 2012/04/19 22:32:55]

I don't either, since it's not that convenient either way.

+    const std::string& extension_id) {
+  ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
+  return (host && background_page_data_[extension_id].is_closing);
+}
+
 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) {
   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;
 }
 
 int ExtensionProcessManager::DecrementLazyKeepaliveCount(
      const Extension* extension) {
   if (!extension->has_lazy_background_page())
     return 0;
 
-  // Don't decrement the count if the background page has gone away. This can
-  // happen e.g. if an event was dispatched while unloading the page, or if
-  // the process is killed/closed while a message port remains open.
-  // TODO(mpcomplete): This might be insufficient.. what if the page goes away
-  // and comes back before we get here? Then we'll have an imbalanced
-  // keepalive count.
-  ExtensionHost* host = GetBackgroundHostForExtension(extension->id());
-  if (!host)
-    return 0;
+  // This should never be called if the background page isn't active.
+  // Otherwise, the count can get out of sync, because we reset it when the
+  // page unloads.
+  CHECK(GetBackgroundHostForExtension(extension->id()));
 
   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
   DCHECK_GT(count, 0);
   if (--count == 0)
     OnLazyBackgroundPageIdle(extension->id());
 
   return count;
 }
 
 void ExtensionProcessManager::OnLazyBackgroundPageIdle(
@@ skipping 270 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }