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(
+    int site_instance_id) {
+  const Extension* extension =
+      ExtensionProcessManager::GetExtensionForSiteInstance(site_instance_id);
+  if (extension && extension->incognito_split_mode()) {
+    return extension;
+  } else {
+    return original_manager_->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;
   }
 }