Use process-per-app-instance for hosted apps without background permission.

chrome/browser/extensions/extension_process_manager.cc

 // Copyright (c) 2011 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_process_manager.h"
 
 #include "chrome/browser/ui/browser_window.h"
 #include "content/browser/browsing_instance.h"
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
@@ skipping 19 matching lines @@
   explicit IncognitoExtensionProcessManager(Profile* profile);
   virtual ~IncognitoExtensionProcessManager() {}
   virtual ExtensionHost* CreateViewHost(const Extension* extension,
                                         const GURL& url,
                                         Browser* browser,
                                         ViewType::Type view_type) OVERRIDE;
   virtual void CreateBackgroundHost(const Extension* extension,
                                     const GURL& url);
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url);
   virtual RenderProcessHost* GetExtensionProcess(const GURL& url);
+  virtual const Extension* GetExtensionForSiteInstance(int site_instance_id);
 
  private:
   // NotificationObserver:
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Returns the extension for an URL, which can either be a chrome-extension
   // URL or a web app URL.
   const Extension* GetExtensionOrAppByURL(const GURL& url);
@@ skipping 38 matching lines @@
     : browsing_instance_(new BrowsingInstance(profile)) {
   Profile* original_profile = profile->GetOriginalProfile();
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  Source<Profile>(profile));
-  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 NotificationService::AllSources());
-  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+  registrar_.Add(this, content::NOTIFICATION_SITE_INSTANCE_DELETED,
                  NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,
                  NotificationService::AllSources());
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   VLOG_IF(1, g_log_bug53991) << "~ExtensionProcessManager: " << this;
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
 }
@@ skipping 103 matching lines @@
     const Extension* extension) {
   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
        iter != background_hosts_.end(); ++iter) {
     ExtensionHost* host = *iter;
     if (host->extension() == extension)
       return host;
   }
   return NULL;
 }
 
-void ExtensionProcessManager::RegisterExtensionProcess(
-    const std::string& extension_id, int process_id) {
-  // TODO(mpcomplete): This is the only place we actually read process_ids_.
-  // Is it necessary?
-  ProcessIDMap::const_iterator it = process_ids_.find(extension_id);
-  if (it != process_ids_.end() && (*it).second == process_id)
+void ExtensionProcessManager::RegisterExtensionSiteInstance(
+    int site_instance_id, const std::string& extension_id) {
+  SiteInstanceIDMap::const_iterator it = extension_ids_.find(site_instance_id);
+  if (it != extension_ids_.end() && (*it).second == extension_id)
     return;
 
-  // Extension ids should get removed from the map before the process ids get
-  // reused from a dead renderer.
-  DCHECK(it == process_ids_.end());
-  process_ids_[extension_id] = process_id;
+  // SiteInstance ids should get removed from the map before the extension ids
+  // get used for a new SiteInstance.
+  DCHECK(it == extension_ids_.end());
+  extension_ids_[site_instance_id] = extension_id;
 }
 
-void ExtensionProcessManager::UnregisterExtensionProcess(int process_id) {
-  ProcessIDMap::iterator it = process_ids_.begin();
-  while (it != process_ids_.end()) {
-    if (it->second == process_id)
-      process_ids_.erase(it++);
-    else
-      ++it;
-  }
+void ExtensionProcessManager::UnregisterExtensionSiteInstance(
+    int site_instance_id) {
+  SiteInstanceIDMap::iterator it = extension_ids_.find(site_instance_id);
+  if (it != extension_ids_.end())
+    extension_ids_.erase(it++);
 }
 
 RenderProcessHost* ExtensionProcessManager::GetExtensionProcess(
     const GURL& url) {
   if (!browsing_instance_->HasSiteInstance(url))
     return NULL;
   scoped_refptr<SiteInstance> site(
       browsing_instance_->GetSiteInstanceForURL(url));
   if (site->HasProcess())
     return site->GetProcess();
   return NULL;
 }
 
 RenderProcessHost* ExtensionProcessManager::GetExtensionProcess(
     const std::string& extension_id) {
   return GetExtensionProcess(
       Extension::GetBaseURLFromExtensionId(extension_id));
 }
 
+const Extension* ExtensionProcessManager::GetExtensionForSiteInstance(
+    int site_instance_id) {
+  SiteInstanceIDMap::const_iterator it = extension_ids_.find(site_instance_id);
+  if (it != extension_ids_.end()) {
+    // Look up the extension by ID, including disabled extensions in case
+    // this gets called while an old process is still around.
+    ExtensionService* service =
+        browsing_instance_->profile()->GetExtensionService();
+    return service->GetExtensionById(it->second, false);
+  }
+
+  return NULL;
+}
+
 SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(const GURL& url) {
   return browsing_instance_->GetSiteInstanceForURL(url);
 }
 
 bool ExtensionProcessManager::HasExtensionHost(ExtensionHost* host) const {
   return all_hosts_.find(host) != all_hosts_.end();
 }
 
 void ExtensionProcessManager::Observe(int type,
                                       const NotificationSource& source,
@@ skipping 31 matching lines @@
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = Details<ExtensionHost>(details).ptr();
       all_hosts_.erase(host);
       background_hosts_.erase(host);
       break;
     }
 
-    case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
-    case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
-      RenderProcessHost* host = Source<RenderProcessHost>(source).ptr();
-      UnregisterExtensionProcess(host->id());
+    case content::NOTIFICATION_SITE_INSTANCE_DELETED: {
+      SiteInstance* site_instance = Source<SiteInstance>(source).ptr();
+      UnregisterExtensionSiteInstance(site_instance->id());
       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;
     }
@@ skipping 85 matching lines @@
 RenderProcessHost* IncognitoExtensionProcessManager::GetExtensionProcess(
     const GURL& url) {
   const Extension* extension = GetExtensionOrAppByURL(url);
   if (!extension || extension->incognito_split_mode()) {
     return ExtensionProcessManager::GetExtensionProcess(url);
   } else {
     return original_manager_->GetExtensionProcess(url);
   }
 }
 
+const Extension* IncognitoExtensionProcessManager::GetExtensionForSiteInstance(

[Matt Perry, 2011/07/12 00:13:02]

The logic here should match GetExtensionProcess. First check if it exists in our
map (by calling the base class' method). If so, and it is split mode, return it.
Otherwise, call through to the original manager.

[Charlie Reis, 2011/07/12 00:50:12]

Thanks-- fixed.

+    int site_instance_id) {
+  // Look for the SiteInstance ID in both original and incognito maps.
+  const Extension* extension =
+      original_manager_->GetExtensionForSiteInstance(site_instance_id);
+  if (extension && IsIncognitoEnabled(extension))
+    return extension;
+
+  return ExtensionProcessManager::GetExtensionForSiteInstance(
+      site_instance_id);
+}
+
 const Extension* IncognitoExtensionProcessManager::GetExtensionOrAppByURL(
     const GURL& url) {
   ExtensionService* service =
       browsing_instance_->profile()->GetExtensionService();
   if (!service)
     return NULL;
   return (url.SchemeIs(chrome::kExtensionScheme)) ?
       service->GetExtensionByURL(url) : service->GetExtensionByWebExtent(url);
 }
 
@@ skipping 23 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHosts(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }