Revert of Remove deprecated extension notification from ProcessManager.

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 229 matching lines @@
                                ExtensionRegistry* extension_registry)
     : site_instance_(SiteInstance::Create(context)),
       extension_registry_(extension_registry),
       startup_background_hosts_created_(false),
       devtools_callback_(base::Bind(&ProcessManager::OnDevToolsStateChanged,
                                     base::Unretained(this))),
       last_background_close_sequence_id_(0),
       weak_ptr_factory_(this) {
   // ExtensionRegistry is shared between incognito and regular contexts.
   DCHECK_EQ(original_context, extension_registry_->browser_context());
-  extension_registry_->AddObserver(this);
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this,
+                 extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
+                 content::Source<BrowserContext>(original_context));
+  registrar_.Add(this,
+                 extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
+                 content::Source<BrowserContext>(original_context));
+  registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllSources());
 
@@ skipping 14 matching lines @@
     event_page_suspending_time_ =
         base::TimeDelta::FromMilliseconds(suspending_time_msec);
   }
 
   content::DevToolsAgentHost::AddAgentStateCallback(devtools_callback_);
 
   OnKeepaliveImpulseCheck();
 }
 
 ProcessManager::~ProcessManager() {
-  extension_registry_->RemoveObserver(this);
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
   content::DevToolsAgentHost::RemoveAgentStateCallback(devtools_callback_);
 }
 
 const ProcessManager::ViewSet ProcessManager::GetAllViews() const {
   ViewSet result;
   for (ExtensionRenderViews::const_iterator iter =
            all_extension_views_.begin();
        iter != all_extension_views_.end(); ++iter) {
@@ skipping 377 matching lines @@
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED: {
       // TODO(jamescook): Convert this to use ExtensionSystem::ready() instead
       // of a notification.
       MaybeCreateStartupBackgroundHosts();
       break;
     }
 
+    case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
+      BrowserContext* context = content::Source<BrowserContext>(source).ptr();
+      ExtensionSystem* system = ExtensionSystem::Get(context);
+      if (system->ready().is_signaled()) {
+        // The extension system is ready, so create the background host.
+        const Extension* extension =
+            content::Details<const Extension>(details).ptr();
+        CreateBackgroundHostForExtensionLoad(this, extension);
+      }
+      break;
+    }
+
+    case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
+      const Extension* extension =
+          content::Details<UnloadedExtensionInfo>(details)->extension;
+      for (ExtensionHostSet::iterator iter = background_hosts_.begin();
+           iter != background_hosts_.end(); ++iter) {
+        ExtensionHost* host = *iter;
+        if (host->extension_id() == extension->id()) {
+          CloseBackgroundHost(host);
+          break;
+        }
+      }
+      UnregisterExtension(extension->id());
+      break;
+    }
+
     case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (background_hosts_.erase(host)) {
         ClearBackgroundPageData(host->extension()->id());
         background_page_data_[host->extension()->id()].since_suspended.reset(
             new base::ElapsedTimer());
       }
       break;
     }
 
@@ skipping 45 matching lines @@
           content::Source<BrowserContext>(GetBrowserContext()),
           content::Details<RenderViewHost>(contents->GetRenderViewHost()));
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
-void ProcessManager::OnExtensionLoaded(content::BrowserContext* browser_context,
-                                       const extensions::Extension* extension) {
-  ExtensionSystem* system = ExtensionSystem::Get(browser_context);
-  if (system->ready().is_signaled()) {
-    // The extension system is ready, so create the background host.
-    CreateBackgroundHostForExtensionLoad(this, extension);
-  }
-}
-
-void ProcessManager::OnExtensionUnloaded(
-    content::BrowserContext* browser_context,
-    const extensions::Extension* extension,
-    extensions::UnloadedExtensionInfo::Reason reason) {
-  for (ExtensionHostSet::iterator iter = background_hosts_.begin();
-       iter != background_hosts_.end();
-       ++iter) {
-    ExtensionHost* host = *iter;
-    if (host->extension_id() == extension->id()) {
-      CloseBackgroundHost(host);
-      break;
-    }
-  }
-  UnregisterExtension(extension->id());
-}
-
 void ProcessManager::OnDevToolsStateChanged(
     content::DevToolsAgentHost* agent_host,
     bool attached) {
   WebContents* web_contents = agent_host->GetWebContents();
   // Ignore unrelated notifications.
   if (!web_contents || web_contents->GetBrowserContext() != GetBrowserContext())
     return;
   if (GetViewType(web_contents) != VIEW_TYPE_EXTENSION_BACKGROUND_PAGE)
     return;
   const Extension* extension =
@@ skipping 152 matching lines @@
 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);
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions