Extract ProcessManager from ExtensionSystem.

extensions/browser/api/runtime/runtime_api.cc

 // Copyright 2014 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/api/runtime/runtime_api.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "extensions/browser/api/runtime/runtime_api_delegate.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/notification_types.h"
-#include "extensions/browser/process_manager.h"
+#include "extensions/browser/process_manager_factory.h"
 #include "extensions/common/api/runtime.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "url/gurl.h"
 
 using content::BrowserContext;
 
@@ skipping 88 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<RuntimeAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<RuntimeAPI>* RuntimeAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
+template <>
+void BrowserContextKeyedAPIFactory<RuntimeAPI>::DeclareFactoryDependencies() {
+  DependsOn(ProcessManagerFactory::GetInstance());
+}
+
 RuntimeAPI::RuntimeAPI(content::BrowserContext* context)
     : browser_context_(context),
       dispatch_chrome_updated_event_(false),
-      extension_registry_observer_(this) {
+      extension_registry_observer_(this),
+      process_manager_observer_(this) {
+  // RuntimeAPI is redirected in incognito, so |browser_context_| is never
+  // incognito.
+  DCHECK(!browser_context_->IsOffTheRecord());
+
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                  content::Source<BrowserContext>(context));
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
+  process_manager_observer_.Add(ProcessManager::Get(browser_context_));
 
   delegate_ = ExtensionsBrowserClient::Get()->CreateRuntimeAPIDelegate(
       browser_context_);
 
   // Check if registered events are up-to-date. We can only do this once
   // per browser context, since it updates internal state when called.
   dispatch_chrome_updated_event_ =
       ExtensionsBrowserClient::Get()->DidVersionUpdate(browser_context_);
 }
 
 RuntimeAPI::~RuntimeAPI() {
-  delegate_->RemoveUpdateObserver(this);
 }
 
 void RuntimeAPI::Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) {
   DCHECK_EQ(extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED, type);
   // We're done restarting Chrome after an update.
   dispatch_chrome_updated_event_ = false;
 
   delegate_->AddUpdateObserver(this);
-
-  // RuntimeAPI is redirected in incognito, so |browser_context_| is never
-  // incognito. We don't observe incognito ProcessManagers but that is OK
-  // because we don't send onStartup events to incognito browser contexts.
-  DCHECK(!browser_context_->IsOffTheRecord());
-  // Some tests use partially constructed Profiles without a process manager.
-  ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context_);
-  if (extension_system->process_manager())
-    extension_system->process_manager()->AddObserver(this);
 }
 
 void RuntimeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
                                    const Extension* extension) {
   if (!dispatch_chrome_updated_event_)
     return;
 
   // Dispatch the onInstalled event with reason "chrome_update".
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
@@ skipping 34 matching lines @@
   // Ephemeral apps are not considered to be installed, so the uninstall URL
   // is not invoked when they are removed.
   if (util::IsEphemeralApp(extension->id(), browser_context_))
     return;
 
   RuntimeEventRouter::OnExtensionUninstalled(
       browser_context_, extension->id(), reason);
 }
 
 void RuntimeAPI::Shutdown() {
-  // ExtensionSystem deletes its ProcessManager during the Shutdown() phase, so
-  // the observer must be removed here and not in the RuntimeAPI destructor.
-  ProcessManager* process_manager =
-      ExtensionSystem::Get(browser_context_)->process_manager();
-  // Some tests use partially constructed Profiles without a process manager.
-  if (process_manager)
-    process_manager->RemoveObserver(this);
+  delegate_->RemoveUpdateObserver(this);
 }
 
 void RuntimeAPI::OnAppUpdateAvailable(const Extension* extension) {
   RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
       browser_context_, extension->id(), extension->manifest()->value());
 }
 
 void RuntimeAPI::OnChromeUpdateAvailable() {
   RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(browser_context_);
 }
@@ skipping 149 matching lines @@
       GetUninstallURL(ExtensionPrefs::Get(context), extension_id));
 
   if (uninstall_url.is_empty())
     return;
 
   RuntimeAPI::GetFactoryInstance()->Get(context)->OpenURL(uninstall_url);
 }
 
 ExtensionFunction::ResponseAction RuntimeGetBackgroundPageFunction::Run() {
   ExtensionSystem* system = ExtensionSystem::Get(browser_context());
-  ExtensionHost* host =
-      system->process_manager()->GetBackgroundHostForExtension(extension_id());
+  ExtensionHost* host = ProcessManager::Get(browser_context())
+                            ->GetBackgroundHostForExtension(extension_id());
   if (system->lazy_background_task_queue()->ShouldEnqueueTask(browser_context(),
                                                               extension())) {
     system->lazy_background_task_queue()->AddPendingTask(
         browser_context(),
         extension_id(),
         base::Bind(&RuntimeGetBackgroundPageFunction::OnPageLoaded, this));
   } else if (host) {
     OnPageLoaded(host);
   } else {
     return RespondNow(Error(kNoBackgroundPageError));
@@ skipping 91 matching lines @@
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return RespondNow(OneArgument(dict));
 }
 
 }  // namespace extensions