Extract ProcessManager from ExtensionSystem.

extensions/browser/process_manager.cc

 // Copyright 2013 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 "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager_delegate.h"
+#include "extensions/browser/process_manager_factory.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/one_shot_event.h"
 
 using content::BrowserContext;
@@ skipping 61 matching lines @@
       content::Details<RenderViewHost>(render_view_host));
 }
 
 // Incognito profiles use this process manager. It is mostly a shim that decides
 // whether to fall back on the original profile's ProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoProcessManager : public ProcessManager {
  public:
   IncognitoProcessManager(BrowserContext* incognito_context,
                           BrowserContext* original_context,
-                          ProcessManager* original_manager,
                           ExtensionRegistry* extension_registry);
   ~IncognitoProcessManager() override {}
   bool CreateBackgroundHost(const Extension* extension,
                             const GURL& url) override;
   SiteInstance* GetSiteInstanceForURL(const GURL& url) override;
 
  private:
-  ProcessManager* original_manager_;
-
   DISALLOW_COPY_AND_ASSIGN(IncognitoProcessManager);
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ProcessManager* manager, const Extension* extension) {
   DVLOG(1) << "CreateBackgroundHostForExtensionLoad";
   if (BackgroundInfo::HasPersistentBackgroundPage(extension))
     manager->CreateBackgroundHost(extension,
                                   BackgroundInfo::GetBackgroundURL(extension));
 }
 
 }  // namespace
 
 class RenderViewHostDestructionObserver
     : public content::WebContentsObserver,
       public content::WebContentsUserData<RenderViewHostDestructionObserver> {
  public:
   ~RenderViewHostDestructionObserver() override {}
 
  private:
   explicit RenderViewHostDestructionObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents) {
     BrowserContext* context = web_contents->GetBrowserContext();
-    process_manager_ = ExtensionSystem::Get(context)->process_manager();
+    process_manager_ = ProcessManager::Get(context);
   }
 
   friend class content::WebContentsUserData<RenderViewHostDestructionObserver>;
 
   // content::WebContentsObserver overrides.
   void RenderViewDeleted(RenderViewHost* render_view_host) override {
     process_manager_->UnregisterRenderViewHost(render_view_host);
   }
 
   ProcessManager* process_manager_;
@@ skipping 31 matching lines @@
         previous_keepalive_impulse(false),
         is_closing(false),
         close_sequence_id(0) {}
 };
 
 //
 // ProcessManager
 //
 
 // static
+ProcessManager* ProcessManager::Get(BrowserContext* context) {
+  return ProcessManagerFactory::GetForBrowserContext(context);
+}
+
+// static
 ProcessManager* ProcessManager::Create(BrowserContext* context) {
   ExtensionRegistry* extension_registry = ExtensionRegistry::Get(context);
   ExtensionsBrowserClient* client = ExtensionsBrowserClient::Get();
   if (client->IsGuestSession(context)) {
     // In the guest session, there is a single off-the-record context.  Unlike
     // a regular incognito mode, background pages of extensions must be
     // created regardless of whether extensions use "spanning" or "split"
     // incognito behavior.
     BrowserContext* original_context = client->GetOriginalContext(context);
     return new ProcessManager(context, original_context, extension_registry);
   }
 
   if (context->IsOffTheRecord()) {
     BrowserContext* original_context = client->GetOriginalContext(context);
-    ProcessManager* original_manager =
-        ExtensionSystem::Get(original_context)->process_manager();
     return new IncognitoProcessManager(
-        context, original_context, original_manager, extension_registry);
+        context, original_context, extension_registry);
   }
 
   return new ProcessManager(context, context, extension_registry);
 }
 
 // static
 ProcessManager* ProcessManager::CreateForTesting(
     BrowserContext* context,
     ExtensionRegistry* extension_registry) {
   DCHECK(!context->IsOffTheRecord());
   return new ProcessManager(context, context, extension_registry);
 }
 
 // static
 ProcessManager* ProcessManager::CreateIncognitoForTesting(
     BrowserContext* incognito_context,
     BrowserContext* original_context,
-    ProcessManager* original_manager,
     ExtensionRegistry* extension_registry) {
   DCHECK(incognito_context->IsOffTheRecord());
   DCHECK(!original_context->IsOffTheRecord());
   return new IncognitoProcessManager(incognito_context,
                                      original_context,
-                                     original_manager,
                                      extension_registry);
 }
 
 ProcessManager::ProcessManager(BrowserContext* context,
                                BrowserContext* original_context,
                                ExtensionRegistry* extension_registry)
     : site_instance_(SiteInstance::Create(context)),
       extension_registry_(extension_registry),
       startup_background_hosts_created_(false),
       devtools_callback_(base::Bind(&ProcessManager::OnDevToolsStateChanged,
@@ skipping 256 matching lines @@
   if (!site_instance)
     return;
 
   BrowserContext* browser_context = site_instance->GetBrowserContext();
   const Extension* extension =
       ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
           extension_id);
   if (!extension)
     return;
 
-  ProcessManager* pm = ExtensionSystem::Get(browser_context)->process_manager();
-  if (!pm)
-    return;
-
-  pm->KeepaliveImpulse(extension);
+  ProcessManager::Get(browser_context)->KeepaliveImpulse(extension);
 }
 
 // DecrementLazyKeepaliveCount is called when no calls to KeepaliveImpulse
 // have been made for at least g_event_page_idle_time_msec. In the best case an
 // impulse was made just before being cleared, and the decrement will occur
 // g_event_page_idle_time_msec later, causing a 2 * g_event_page_idle_time_msec
 // total time for extension to be shut down based on impulses. Worst case is
 // an impulse just after a clear, adding one check cycle and resulting in 3x
 // total time.
 void ProcessManager::OnKeepaliveImpulseCheck() {
@@ skipping 378 matching lines @@
   }
 }
 
 //
 // IncognitoProcessManager
 //
 
 IncognitoProcessManager::IncognitoProcessManager(
     BrowserContext* incognito_context,
     BrowserContext* original_context,
-    ProcessManager* original_manager,
     ExtensionRegistry* extension_registry)
-    : ProcessManager(incognito_context, original_context, extension_registry),
-      original_manager_(original_manager) {
+    : ProcessManager(incognito_context, original_context, extension_registry) {
   DCHECK(incognito_context->IsOffTheRecord());
 
   // The original profile will have its own ProcessManager to
   // load the background pages of the spanning extensions. This process
   // manager need only worry about the split mode extensions, which is handled
   // in the NOTIFICATION_BROWSER_WINDOW_READY notification handler.
   registrar_.Remove(this,
                     extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                     content::Source<BrowserContext>(original_context));
 }
 
 bool IncognitoProcessManager::CreateBackgroundHost(const Extension* extension,
                                                    const GURL& url) {
   if (IncognitoInfo::IsSplitMode(extension)) {
     if (ExtensionsBrowserClient::Get()->IsExtensionIncognitoEnabled(
             extension->id(), GetBrowserContext()))
       return ProcessManager::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.
   }
   return false;
 }
 
 SiteInstance* IncognitoProcessManager::GetSiteInstanceForURL(const GURL& url) {
   const Extension* extension =
       extension_registry_->enabled_extensions().GetExtensionOrAppByURL(url);
-  if (extension && !IncognitoInfo::IsSplitMode(extension))
-    return original_manager_->GetSiteInstanceForURL(url);
+  if (extension && !IncognitoInfo::IsSplitMode(extension)) {
+    BrowserContext* original_context =
+        ExtensionsBrowserClient::Get()->GetOriginalContext(GetBrowserContext());
+    return ProcessManager::Get(original_context)->GetSiteInstanceForURL(url);
+  }
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions