Hook up runtime API to implement ExtensionRegistryObserver.

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"
@@ skipping 119 matching lines @@
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<RuntimeAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<RuntimeAPI>* RuntimeAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 RuntimeAPI::RuntimeAPI(content::BrowserContext* context)
-    : browser_context_(context), dispatch_chrome_updated_event_(false) {
+    : browser_context_(context),
+      extension_registry_observer_(this),
+      dispatch_chrome_updated_event_(false) {
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<BrowserContext>(context));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
-                 content::Source<BrowserContext>(context));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
-                 content::Source<BrowserContext>(context));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
-                 content::Source<BrowserContext>(context));
+  extension_registry_observer_.Add(ExtensionRegistry::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) {
-  switch (type) {
-    case chrome::NOTIFICATION_EXTENSIONS_READY: {
-      OnExtensionsReady();
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
-      const Extension* extension =
-          content::Details<const Extension>(details).ptr();
-      OnExtensionLoaded(extension);
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
-      const Extension* extension =
-          content::Details<const InstalledExtensionInfo>(details)->extension;
-      OnExtensionInstalled(extension);
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED: {
-      const Extension* extension =
-          content::Details<const Extension>(details).ptr();
-      OnExtensionUninstalled(extension);
-      break;
-    }
-    default:
-      NOTREACHED();
-      break;
-  }
+  DCHECK_EQ(chrome::NOTIFICATION_EXTENSIONS_READY, type);
+  OnExtensionsReady();
 }
 
 void RuntimeAPI::OnExtensionsReady() {
   // 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(const Extension* extension) {
+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,
       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
                  browser_context_,
                  extension->id(),
                  Version(),
                  true));
 }
 
-void RuntimeAPI::OnExtensionInstalled(const Extension* extension) {
+void RuntimeAPI::OnExtensionWillBeInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update,
+    bool from_ephemeral,
+    const std::string& old_name) {
   // Ephemeral apps are not considered to be installed and do not receive
   // the onInstalled() event.
   if (util::IsEphemeralApp(extension->id(), browser_context_))
     return;
 
   Version old_version = delegate_->GetPreviousExtensionVersion(extension);
 
   // Dispatch the onInstalled event.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
                  browser_context_,
                  extension->id(),
                  old_version,
                  false));
 }
 
-void RuntimeAPI::OnExtensionUninstalled(const Extension* extension) {
+void RuntimeAPI::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    UninstallReason reason) {
   // 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());
+  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);
@@ skipping 141 matching lines @@
       new Event(runtime::OnRestartRequired::kEventName,
                 core_api::runtime::OnRestartRequired::Create(reason)));
 
   DCHECK(system->event_router());
   system->event_router()->DispatchEventToExtension(app_id, event.Pass());
 }
 
 // static
 void RuntimeEventRouter::OnExtensionUninstalled(
     content::BrowserContext* context,
-    const std::string& extension_id) {
+    const std::string& extension_id,
+    UninstallReason reason) {
+  if (!(reason == UNINSTALL_REASON_USER_INITIATED ||
+        reason == UNINSTALL_REASON_MANAGEMENT_API)) {
+    return;
+  }
+
   GURL uninstall_url(
       GetUninstallURL(ExtensionPrefs::Get(context), extension_id));
 
   if (uninstall_url.is_empty())
     return;
 
   RuntimeAPI::GetFactoryInstance()->Get(context)->OpenURL(uninstall_url);
 }
 
 ExtensionFunction::ResponseAction RuntimeGetBackgroundPageFunction::Run() {
@@ skipping 104 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