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

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 "chrome/browser/extensions/extension_process_manager.h"
 
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 35 matching lines @@
   base::PropertyBag* bag =
       profile->GetExtensionService()->GetPropertyBag(extension);
   int* count = g_property_accessor.Get().GetProperty(bag);
   if (!count) {
     g_property_accessor.Get().SetProperty(bag, 0);
     count = g_property_accessor.Get().GetProperty(bag);
   }
   return *count;
 }
 
+std::string GetExtensionID(RenderViewHost* render_view_host) {
+  // This works for both apps and extensions because the site has been
+  // normalized to the extension URL for apps.
+  return render_view_host->site_instance()->GetSite().host();
+}
+
 // Incognito profiles use this process manager. It is mostly a shim that decides
 // whether to fall back on the original profile's ExtensionProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoExtensionProcessManager : public ExtensionProcessManager {
  public:
   explicit IncognitoExtensionProcessManager(Profile* profile);
   virtual ~IncognitoExtensionProcessManager() {}
   virtual ExtensionHost* CreateViewHost(
       const Extension* extension,
       const GURL& url,
@@ skipping 50 matching lines @@
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::Source<Profile>(profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
                  content::Source<Profile>(profile));
+  registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
+                 content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
 }
 
 ExtensionHost* ExtensionProcessManager::CreateShellHost(
@@ skipping 120 matching lines @@
 
 ExtensionHost* ExtensionProcessManager::GetBackgroundHostForExtension(
     const std::string& extension_id) {
   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
        iter != background_hosts_.end(); ++iter) {
     ExtensionHost* host = *iter;
     if (host->extension_id() == extension_id)
       return host;
   }
   return NULL;
-
 }
 
 std::set<RenderViewHost*>
     ExtensionProcessManager::GetRenderViewHostsForExtension(
         const std::string& extension_id) {
   std::set<RenderViewHost*> result;
 
   SiteInstance* site_instance = GetSiteInstanceForURL(
       Extension::GetBaseURLFromExtensionId(extension_id));
   if (!site_instance)
     return result;
 
   // Gather up all the views for that site.
-  for (RenderViewHostSet::iterator view = all_extension_views_.begin();
+  for (ExtensionRenderViews::iterator view = all_extension_views_.begin();
        view != all_extension_views_.end(); ++view) {
-    if ((*view)->site_instance() == site_instance)
-      result.insert(*view);
+    if (view->first->site_instance() == site_instance)
+      result.insert(view->first);
   }
 
   return result;
 }
 
 void ExtensionProcessManager::RegisterRenderViewHost(
     RenderViewHost* render_view_host,
     const Extension* extension) {
-  all_extension_views_.insert(render_view_host);
+  all_extension_views_[render_view_host] = content::VIEW_TYPE_INVALID;
 }
 
 void ExtensionProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
-  all_extension_views_.erase(render_view_host);
+  ExtensionRenderViews::iterator view =
+      all_extension_views_.find(render_view_host);
+  if (view == all_extension_views_.end())
+    return;
+
+  content::ViewType view_type = view->second;
+  all_extension_views_.erase(view);
+
+  // Keepalive count, balanced in UpdateRegisteredRenderView.
+  if (view_type != content::VIEW_TYPE_INVALID &&
+      view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+    const Extension* extension =
+        GetProfile()->GetExtensionService()->extensions()->GetByID(
+            GetExtensionID(render_view_host));
+    if (extension)
+      DecrementLazyKeepaliveCount(extension);
+  }
 }
 
-SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(
-    const GURL& url) {
+void ExtensionProcessManager::UpdateRegisteredRenderView(
+    RenderViewHost* render_view_host) {
+  ExtensionRenderViews::iterator view =
+      all_extension_views_.find(render_view_host);
+  if (view == all_extension_views_.end())
+    return;
+
+  view->second = render_view_host->delegate()->GetRenderViewType();
+
+  // Keep the lazy background page alive as long as any non-background-page
+  // extension views are visible. Keepalive count balanced in
+  // UnregisterRenderViewHost.
+  if (view->second != content::VIEW_TYPE_INVALID &&
+      view->second != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+    const Extension* extension =
+        GetProfile()->GetExtensionService()->extensions()->GetByID(
+            GetExtensionID(render_view_host));
+    if (extension)
+      IncrementLazyKeepaliveCount(extension);
+  }
+}
+
+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();
 }
 
 int ExtensionProcessManager::GetLazyKeepaliveCount(const Extension* extension) {
   if (extension->background_page_persists())
     return 0;
 
   return ::GetLazyKeepaliveCount(GetProfile(), extension);
 }
 
 int ExtensionProcessManager::IncrementLazyKeepaliveCount(
      const Extension* extension) {
   if (extension->background_page_persists())
     return 0;
 
-  // TODO(mpcomplete): Handle visible views changing.
   int& count = ::GetLazyKeepaliveCount(GetProfile(), extension);
   if (++count == 1)
     OnLazyBackgroundPageActive(extension->id());
 
   return count;
 }
 
 int ExtensionProcessManager::DecrementLazyKeepaliveCount(
      const Extension* extension) {
   if (extension->background_page_persists())
     return 0;
 
   int& count = ::GetLazyKeepaliveCount(GetProfile(), extension);
   DCHECK(count > 0);
   if (--count == 0)
     OnLazyBackgroundPageIdle(extension->id());
 
   return count;
 }
 
 void ExtensionProcessManager::OnLazyBackgroundPageIdle(
     const std::string& extension_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
-  if (host && !HasVisibleViews(extension_id))
+  if (host)
     host->SendShouldClose();
 }
 
 void ExtensionProcessManager::OnLazyBackgroundPageActive(
     const std::string& extension_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host)
     host->CancelShouldClose();
 }
 
 void ExtensionProcessManager::OnShouldCloseAck(
      const std::string& extension_id, int sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host)
     host->OnShouldCloseAck(sequence_id);
 }
 
-bool ExtensionProcessManager::HasVisibleViews(const std::string& extension_id) {
-  const std::set<RenderViewHost*>& views =
-      GetRenderViewHostsForExtension(extension_id);
-  for (std::set<RenderViewHost*>::const_iterator it = views.begin();
-       it != views.end(); ++it) {
-    const RenderViewHost* host = *it;
-    if (host->site_instance()->GetSite().host() == extension_id &&
-        host->delegate()->GetRenderViewType() !=
-        chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
-      return true;
-    }
-  }
-  return false;
+void ExtensionProcessManager::OnNetworkRequestStarted(
+    RenderViewHost* render_view_host) {
+  ExtensionHost* host = GetBackgroundHostForExtension(
+      GetExtensionID(render_view_host));
+  if (host)
+    IncrementLazyKeepaliveCount(host->extension());
+}
+
+void ExtensionProcessManager::OnNetworkRequestDone(
+    RenderViewHost* render_view_host) {
+  ExtensionHost* host = GetBackgroundHostForExtension(
+      GetExtensionID(render_view_host));
+  if (host)
+    DecrementLazyKeepaliveCount(host->extension());
 }
 
 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()->
@@ skipping 35 matching lines @@
 
     case chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (host->extension_host_type() ==
           chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         CloseBackgroundHost(host);
       }
       break;
     }
 
+    case content::NOTIFICATION_WEB_CONTENTS_CONNECTED: {
+      content::WebContents* contents =
+          content::Source<content::WebContents>(source).ptr();
+      UpdateRegisteredRenderView(contents->GetRenderViewHost());
+      break;
+    }
+
     case content::NOTIFICATION_APP_TERMINATING: {
       // Close background hosts when the last browser is closed so that they
       // have time to shutdown various objects on different threads. Our
       // destructor is called too late in the shutdown sequence.
       CloseBackgroundHosts();
       break;
     }
 
     default:
       NOTREACHED();
@@ skipping 113 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }