Define the public interface for content browser SiteInstance. This interface is implemented by th...

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/extensions/extension_event_router.h"
 #include "chrome/browser/ui/browser_window.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"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/renderer_host/render_view_host.h"
-#include "content/browser/site_instance.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host_delegate.h"
+#include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/renderer_preferences.h"
 
 using content::BrowserThread;
 using content::OpenURLParams;
 using content::Referrer;
 
 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* CreateViewHost(
       const Extension* extension,
       const GURL& url,
       Browser* browser,
       content::ViewType view_type) OVERRIDE;
   virtual void CreateBackgroundHost(const Extension* extension,
                                     const GURL& url);
-  virtual SiteInstance* GetSiteInstanceForURL(const GURL& url);
+  virtual content::SiteInstance* GetSiteInstanceForURL(const GURL& url);
 
  private:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details);
 
   // Returns true if the extension is allowed to run in incognito mode.
   bool IsIncognitoEnabled(const Extension* extension);
 
@@ skipping 25 matching lines @@
 //
 
 // static
 ExtensionProcessManager* ExtensionProcessManager::Create(Profile* profile) {
   return (profile->IsOffTheRecord()) ?
       new IncognitoExtensionProcessManager(profile) :
       new ExtensionProcessManager(profile);
 }
 
 ExtensionProcessManager::ExtensionProcessManager(Profile* profile)
-    : site_instance_(SiteInstance::CreateSiteInstance(profile)) {
+    : site_instance_(content::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 139 matching lines @@
   }
   return NULL;
 
 }
 
 std::set<RenderViewHost*>
     ExtensionProcessManager::GetRenderViewHostsForExtension(
         const std::string& extension_id) {
   std::set<RenderViewHost*> result;
 
-  SiteInstance* site_instance = GetSiteInstanceForURL(
+  content::SiteInstance* site_instance = GetSiteInstanceForURL(
       Extension::GetBaseURLFromExtensionId(extension_id));
   if (!site_instance)
     return result;
 
   // Gather up all the views for that site.
   for (RenderViewHostSet::iterator view = all_extension_views_.begin();
        view != all_extension_views_.end(); ++view) {
     if ((*view)->site_instance() == site_instance)
       result.insert(*view);
   }
 
   return result;
 }
 
 void ExtensionProcessManager::RegisterRenderViewHost(
     RenderViewHost* render_view_host,
     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) {
+content::SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(
+    const GURL& 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 = 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) {
     const RenderViewHost* host = *it;
-    if (host->site_instance()->site().host() == extension_id &&
+    if (host->site_instance()->GetSite().host() == extension_id &&
         host->delegate()->GetRenderViewType() !=
         chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
       return true;
     }
   }
   return false;
 }
 
 void ExtensionProcessManager::Observe(
     int type,
@@ skipping 130 matching lines @@
     const Extension* extension, const GURL& url) {
   if (extension->incognito_split_mode()) {
     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(
+content::SiteInstance* IncognitoExtensionProcessManager::GetSiteInstanceForURL(
     const GURL& url) {
   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);
 }
@@ skipping 26 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }