Hide BrowsingInstance from all but SiteInstance, as intended by design.

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/ui/browser_window.h"
-#include "content/browser/browsing_instance.h"
 #include "chrome/browser/extensions/extension_event_router.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/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 68 matching lines @@
 //
 
 // static
 ExtensionProcessManager* ExtensionProcessManager::Create(Profile* profile) {
   return (profile->IsOffTheRecord()) ?
       new IncognitoExtensionProcessManager(profile) :
       new ExtensionProcessManager(profile);
 }
 
 ExtensionProcessManager::ExtensionProcessManager(Profile* profile)
-    : browsing_instance_(new BrowsingInstance(profile)) {
+    : site_instance_(SiteInstance::CreateSiteInstance(profile)) {
   Profile* original_profile = profile->GetOriginalProfile();
   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,
@@ skipping 39 matching lines @@
   host->CreateView(browser);
   OnExtensionHostCreated(host, false);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
     const GURL& url, Browser* browser, content::ViewType view_type) {
   // A NULL browser may only be given for pop-up views.
   DCHECK(browser ||
          (!browser && view_type == chrome::VIEW_TYPE_EXTENSION_POPUP));
-  Profile* profile =
-      Profile::FromBrowserContext(browsing_instance_->browser_context());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service = GetProfile()->GetExtensionService();
   if (service) {
     const Extension* extension =
         service->extensions()->GetByID(url.host());
     if (extension)
       return CreateViewHost(extension, url, browser, view_type);
   }
   return NULL;
 }
 
 ExtensionHost* ExtensionProcessManager::CreatePopupHost(
@@ skipping 47 matching lines @@
   OnExtensionHostCreated(host, true);
 }
 
 void ExtensionProcessManager::OpenOptionsPage(const Extension* extension,
                                               Browser* browser) {
   DCHECK(!extension->options_url().is_empty());
 
   // Force the options page to open in non-OTR window, because it won't be
   // able to save settings from OTR.
   if (!browser || browser->profile()->IsOffTheRecord()) {
-    Profile* profile =
-        Profile::FromBrowserContext(browsing_instance_->browser_context());
+    Profile* profile = GetProfile();
     browser = Browser::GetOrCreateTabbedBrowser(profile->GetOriginalProfile());
   }
 
   OpenURLParams params(extension->options_url(), Referrer(), SINGLETON_TAB,
                        content::PAGE_TRANSITION_LINK, false);
   browser->OpenURL(params);
   browser->window()->Show();
   browser->GetSelectedWebContents()->GetRenderViewHost()->delegate()->
       Activate();
 }
@@ skipping 35 matching lines @@
     const Extension* extension) {
   all_extension_views_.insert(render_view_host);
 }
 
 void ExtensionProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
   all_extension_views_.erase(render_view_host);
 }
 
 SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(const GURL& url) {
-  return browsing_instance_->GetSiteInstanceForURL(url);
+  return site_instance_->GetRelatedSiteInstance(url);
 }
 
 bool ExtensionProcessManager::HasExtensionHost(ExtensionHost* host) const {
   return all_hosts_.find(host) != all_hosts_.end();
 }
 
 void ExtensionProcessManager::OnExtensionIdle(const std::string& extension_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host && !HasVisibleViews(extension_id)) {
-    Profile* profile =
-        Profile::FromBrowserContext(browsing_instance_->browser_context());
+    Profile* profile = GetProfile();
     if (!profile->GetExtensionEventRouter()->HasInFlightEvents(extension_id))
       CloseBackgroundHost(host);
   }
 }
 
 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) {
@@ skipping 66 matching lines @@
       // destructor is called too late in the shutdown sequence.
       CloseBackgroundHosts();
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
+Profile* ExtensionProcessManager::GetProfile() const {
+  return Profile::FromBrowserContext(site_instance_->GetBrowserContext());
+}
+
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
-  DCHECK_EQ(browsing_instance_->browser_context(), host->profile());
+  DCHECK_EQ(site_instance_->GetBrowserContext(), host->profile());
 
   all_hosts_.insert(host);
   if (is_background)
     background_hosts_.insert(host);
 }
 
 void ExtensionProcessManager::CloseBackgroundHost(ExtensionHost* host) {
   CHECK(host->extension_host_type() ==
         chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   delete host;
@@ skipping 51 matching lines @@
     if (IsIncognitoEnabled(extension))
       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) {
-  Profile* profile =
-      Profile::FromBrowserContext(browsing_instance_->browser_context());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service = GetProfile()->GetExtensionService();
   if (service) {
     const Extension* extension = service->extensions()->GetExtensionOrAppByURL(
         ExtensionURLInfo(url));
     if (extension && !extension->incognito_split_mode())
       return original_manager_->GetSiteInstanceForURL(url);
   }
   return ExtensionProcessManager::GetSiteInstanceForURL(url);
 }
 
 bool IncognitoExtensionProcessManager::IsIncognitoEnabled(
     const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
-  Profile* profile =
-      Profile::FromBrowserContext(browsing_instance_->browser_context());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service = GetProfile()->GetExtensionService();
   return service && service->IsIncognitoEnabled(extension->id());
 }
 
 void IncognitoExtensionProcessManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
       if (CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableLazyBackgroundPages))
         break;
       // 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 = content::Source<Browser>(source).ptr();
-      if (browser->profile() == browsing_instance_->browser_context()) {
+      if (browser->profile() == site_instance_->GetBrowserContext()) {
         // On Chrome OS, a login screen is implemented as a browser.
         // This browser has no extension service.  In this case,
         // service will be NULL.
-        Profile* profile =
-            Profile::FromBrowserContext(browsing_instance_->browser_context());
-        ExtensionService* service = profile->GetExtensionService();
+        ExtensionService* service = GetProfile()->GetExtensionService();
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }