Add support for a "split" incognito behavior for extensions.

chrome/browser/extensions/extension_process_manager.cc

 // Copyright (c) 2010 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/browser.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/browsing_instance.h"
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
 #endif
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/site_instance.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/common/url_constants.h"
+
+namespace {
+
+// 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* CreateView(Extension* extension,
+                                    const GURL& url,
+                                    Browser* browser,
+                                    ViewType::Type view_type);
+  virtual void CreateBackgroundHost(Extension* extension, const GURL& url);
+  virtual SiteInstance* GetSiteInstanceForURL(const GURL& url);
+  virtual RenderProcessHost* GetExtensionProcess(const GURL& url);
+
+ private:
+  // NotificationObserver:
+  virtual void Observe(NotificationType 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.
+  Extension* GetExtensionOrAppByURL(const GURL& url);
+
+  ExtensionProcessManager* original_manager_;
+};
 
 static void CreateBackgroundHost(
     ExtensionProcessManager* manager, Extension* extension) {
   // Start the process for the master page, if it exists.
   if (extension->background_url().is_valid())
     manager->CreateBackgroundHost(extension, extension->background_url());
 }
 
 static void CreateBackgroundHosts(
     ExtensionProcessManager* manager, const ExtensionList* extensions) {
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     CreateBackgroundHost(manager, *extension);
   }
 }
 
+}  // namespace
+
+//
+// ExtensionProcessManager
+//
+
+// static
+ExtensionProcessManager* ExtensionProcessManager::Create(Profile* profile) {
+  return (profile->IsOffTheRecord()) ?
+      new IncognitoExtensionProcessManager(profile) :
+      new ExtensionProcessManager(profile);
+}
+
 ExtensionProcessManager::ExtensionProcessManager(Profile* profile)
     : browsing_instance_(new BrowsingInstance(profile)) {
   registrar_.Add(this, NotificationType::EXTENSIONS_READY,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_HOST_DESTROYED,
                  Source<Profile>(profile));
@@ skipping 28 matching lines @@
   OnExtensionHostCreated(host, false);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::CreateView(const GURL& url,
                                                    Browser* browser,
                                                    ViewType::Type view_type) {
   // A NULL browser may only be given for pop-up views.
   DCHECK(browser || (!browser && view_type == ViewType::EXTENSION_POPUP));
   ExtensionsService* service =
-    browsing_instance_->profile()->GetExtensionsService();
+      browsing_instance_->profile()->GetExtensionsService();
   if (service) {
     Extension* extension = service->GetExtensionByURL(url);
     if (extension)
       return CreateView(extension, url, browser, view_type);
   }
   return NULL;
 }
 
 ExtensionHost* ExtensionProcessManager::CreatePopup(Extension* extension,
                                                     const GURL& url,
@@ skipping 10 matching lines @@
                                                       const GURL& url,
                                                       Browser* browser) {
   return CreateView(extension, url, browser, ViewType::EXTENSION_INFOBAR);
 }
 
 ExtensionHost* ExtensionProcessManager::CreateInfobar(const GURL& url,
                                                       Browser* browser) {
   return CreateView(url, browser, ViewType::EXTENSION_INFOBAR);
 }
 
-ExtensionHost* ExtensionProcessManager::CreateBackgroundHost(
+void ExtensionProcessManager::CreateBackgroundHost(
     Extension* extension, const GURL& url) {
+  // Don't create multiple background hosts for an extension.
+  if (GetBackgroundHostForExtension(extension))
+    return;
+
   ExtensionHost* host =
 #if defined(OS_MACOSX)
       new ExtensionHostMac(extension, GetSiteInstanceForURL(url), url,
                            ViewType::EXTENSION_BACKGROUND_PAGE);
 #else
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url,
                         ViewType::EXTENSION_BACKGROUND_PAGE);
 #endif
 
   host->CreateRenderViewSoon(NULL);  // create a RenderViewHost with no view
   OnExtensionHostCreated(host, true);
-  return host;
 }
 
 void ExtensionProcessManager::OpenOptionsPage(Extension* extension,
                                               Browser* browser) {
   DCHECK(!extension->options_url().is_empty());
 
-  // We can't open extensions URLs in incognito windows.
-  if (!browser || browser->profile()->IsOffTheRecord())
-    browser = Browser::GetOrCreateTabbedBrowser(browsing_instance_->profile());
+  // We can't open extensions URLs in incognito windows, unless the extension
+  // uses "split" incognito mode.
+  if (!browser || (browser->profile()->IsOffTheRecord() &&
+                   !extension->incognito_split_mode())) {
+    browser = Browser::GetOrCreateTabbedBrowser(
+        browsing_instance_->profile()->GetOriginalProfile());
+  }
 
   browser->OpenURL(extension->options_url(), GURL(), SINGLETON_TAB,
                    PageTransition::LINK);
   browser->window()->Show();
   browser->GetSelectedTabContents()->Activate();
 }
 
 ExtensionHost* ExtensionProcessManager::GetBackgroundHostForExtension(
     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;
 
   ExtensionsService* extension_service =
@@ skipping 18 matching lines @@
     else
       ++it;
   }
 }
 
 RenderProcessHost* ExtensionProcessManager::GetExtensionProcess(
     const GURL& url) {
   if (!browsing_instance_->HasSiteInstance(url))
     return NULL;
   scoped_refptr<SiteInstance> site =
-    browsing_instance_->GetSiteInstanceForURL(url);
+      browsing_instance_->GetSiteInstanceForURL(url);
   if (site->HasProcess())
     return site->GetProcess();
   return NULL;
 }
 
 RenderProcessHost* ExtensionProcessManager::GetExtensionProcess(
     const std::string& extension_id) {
-  ProcessIDMap::const_iterator it = process_ids_.find(extension_id);
-  if (it == process_ids_.end())
-    return NULL;
-
-  RenderProcessHost* rph = RenderProcessHost::FromID(it->second);
-  DCHECK(rph) << "We should have unregistered this host.";
-  return rph;
+  return GetExtensionProcess(
+      Extension::GetBaseURLFromExtensionId(extension_id));
 }
 
 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();
 }
 
@@ skipping 53 matching lines @@
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
+  DCHECK_EQ(browsing_instance_->profile(), host->profile());
+
   all_hosts_.insert(host);
   if (is_background)
     background_hosts_.insert(host);
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_HOST_CREATED,
       Source<ExtensionProcessManager>(this),
       Details<ExtensionHost>(host));
 }
 
 void ExtensionProcessManager::CloseBackgroundHosts() {
   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
        iter != background_hosts_.end(); ) {
     ExtensionHostSet::iterator current = iter++;
     delete *current;
   }
 }
+
+//
+// IncognitoExtensionProcessManager
+//
+
+IncognitoExtensionProcessManager::IncognitoExtensionProcessManager(
+    Profile* profile)
+    : ExtensionProcessManager(profile),
+      original_manager_(profile->GetOriginalProfile()->
+                            GetExtensionProcessManager()) {
+  DCHECK(profile->IsOffTheRecord());
+
+  registrar_.Add(this, NotificationType::BROWSER_WINDOW_READY,
+                 NotificationService::AllSources());
+}
+
+ExtensionHost* IncognitoExtensionProcessManager::CreateView(
+    Extension* extension,
+    const GURL& url,
+    Browser* browser,
+    ViewType::Type view_type) {
+  if (extension->incognito_split_mode()) {
+    return ExtensionProcessManager::CreateView(extension, url,
+                                               browser, view_type);
+  } else {
+    return original_manager_->CreateView(extension, url, browser, view_type);
+  }
+}
+
+void IncognitoExtensionProcessManager::CreateBackgroundHost(
+    Extension* extension, const GURL& url) {
+  if (extension->incognito_split_mode()) {
+    ExtensionProcessManager::CreateBackgroundHost(extension, url);
+  } else {
+    // Do nothing. If an extension is spanning, then its original-profile
+    // background page is shared with incognito, so we don't create another.
+  }
+}
+
+SiteInstance* IncognitoExtensionProcessManager::GetSiteInstanceForURL(
+    const GURL& url) {
+  Extension* extension = GetExtensionOrAppByURL(url);
+  if (!extension || extension->incognito_split_mode()) {
+    return ExtensionProcessManager::GetSiteInstanceForURL(url);
+  } else {
+    return original_manager_->GetSiteInstanceForURL(url);
+  }
+}
+
+RenderProcessHost* IncognitoExtensionProcessManager::GetExtensionProcess(
+    const GURL& url) {
+  Extension* extension = GetExtensionOrAppByURL(url);
+  if (!extension || extension->incognito_split_mode()) {
+    return ExtensionProcessManager::GetExtensionProcess(url);
+  } else {
+    return original_manager_->GetExtensionProcess(url);
+  }
+}
+
+Extension* IncognitoExtensionProcessManager::GetExtensionOrAppByURL(
+    const GURL& url) {
+  ExtensionsService* service =
+      browsing_instance_->profile()->GetExtensionsService();
+  return (url.SchemeIs(chrome::kExtensionScheme)) ?
+      service->GetExtensionByURL(url) : service->GetExtensionByWebExtent(url);
+}
+
+void IncognitoExtensionProcessManager::Observe(
+    NotificationType type,
+    const NotificationSource& source,
+    const NotificationDetails& details) {
+  switch (type.value) {
+    case NotificationType::BROWSER_WINDOW_READY: {
+      // We want to spawn our background hosts as soon as the user opens an
+      // incognito window. Watch for new browsers and create the hosts if
+      // it matches our profile.
+      Browser* browser = Source<Browser>(source).ptr();
+      if (browser->profile() == browsing_instance_->profile()) {
+        ExtensionsService* service =
+            browsing_instance_->profile()->GetExtensionsService();
+        if (service && service->is_ready())
+          CreateBackgroundHosts(this, service->extensions());
+      }
+      break;
+    }
+    default:
+      ExtensionProcessManager::Observe(type, source, details);
+      break;
+  }
+}