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 77 matching lines @@
     : browsing_instance_(new BrowsingInstance(profile)) {
   Profile* original_profile = profile->GetOriginalProfile();
   registrar_.Add(this, NotificationType::EXTENSIONS_READY,
                  Source<Profile>(original_profile));
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                  Source<Profile>(original_profile));
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  Source<Profile>(original_profile));
   registrar_.Add(this, NotificationType::EXTENSION_HOST_DESTROYED,
                  Source<Profile>(profile));
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_TERMINATED,
-                 NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_CLOSED,
-                 NotificationService::AllSources());
   registrar_.Add(this, NotificationType::APP_TERMINATING,
                  NotificationService::AllSources());
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   VLOG_IF(1, g_log_bug53991) << "~ExtensionProcessManager: " << this;
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
 }
 
@@ skipping 101 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)
-    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;
-}
-
-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;
-  }
-}
-
 RenderProcessHost* ExtensionProcessManager::GetExtensionProcess(
     const GURL& url) {
   if (!browsing_instance_->HasSiteInstance(url))
     return NULL;
   scoped_refptr<SiteInstance> site(
       browsing_instance_->GetSiteInstanceForURL(url));

[Matt Perry, 2011/07/08 22:18:35]

What will happen here for hosted apps?

[Charlie Reis, 2011/07/08 22:49:50]

This doesn't appear to be called for hosted apps-- they hit the logic in
BrowsingInstance::ShouldUseProcessPerSite.  Do you know of a case where it's
possible?

   if (site->HasProcess())
     return site->GetProcess();
   return NULL;
 }
 
 RenderProcessHost* ExtensionProcessManager::GetExtensionProcess(
     const std::string& extension_id) {
   return GetExtensionProcess(
       Extension::GetBaseURLFromExtensionId(extension_id));
 }
@@ skipping 42 matching lines @@
       break;
     }
 
     case NotificationType::EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = Details<ExtensionHost>(details).ptr();
       all_hosts_.erase(host);
       background_hosts_.erase(host);
       break;
     }
 
-    case NotificationType::RENDERER_PROCESS_TERMINATED:
-    case NotificationType::RENDERER_PROCESS_CLOSED: {
-      RenderProcessHost* host = Source<RenderProcessHost>(source).ptr();
-      UnregisterExtensionProcess(host->id());
-      break;
-    }
-
     case NotificationType::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 125 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHosts(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }