Remove NOTIFICATION_EXTENSION_ENABLED.

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 <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 50 matching lines @@
 const char kInstallReasonSharedModuleUpdate[] = "shared_module_update";
 const char kInstallPreviousVersion[] = "previousVersion";
 const char kInvalidUrlError[] = "Invalid URL: \"*\".";
 const char kPlatformInfoUnavailable[] = "Platform information unavailable.";
 
 const char kUpdatesDisabledError[] = "Autoupdate is not enabled.";
 
 // A preference key storing the url loaded when an extension is uninstalled.
 const char kUninstallUrl[] = "uninstall_url";
 
-// A preference key storing the information about an extension that was
-// installed but not loaded. We keep the pending info here so that we can send
-// chrome.runtime.onInstalled event during the extension load.
-const char kPrefPendingOnInstalledEventDispatchInfo[] =
-    "pending_on_installed_event_dispatch_info";
-
-// Previously installed version number.
-const char kPrefPreviousVersion[] = "previous_version";
-
 // The name of the directory to be returned by getPackageDirectoryEntry. This
 // particular value does not matter to user code, but is chosen for consistency
 // with the equivalent Pepper API.
 const char kPackageDirectoryPath[] = "crxfs";
 
 // Preference key for storing the last successful restart due to a call to
 // chrome.runtime.restartAfterDelay().
 constexpr char kPrefLastRestartAfterDelayTime[] =
     "last_restart_after_delay_time";
 // Preference key for storing whether the most recent restart was due to a
@@ skipping 121 matching lines @@
   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_);
+
+  EventRouter::Get(browser_context_)

[Devlin, 2017/05/25 21:08:44]

Add this as a dependency, and remove the observer in the destructor

[lazyboy, 2017/05/30 23:38:35]

Done.

The observer is removed in ::Shutdown as we can't do this in the destructor.
(EventRouter::Get triggers a BrowserContextKeyedAPI get during
DestroyContextServices).

+      ->lazy_event_dispatch_util()
+      ->AddObserver(this);
 }
 
 RuntimeAPI::~RuntimeAPI() {
 }
 
 void RuntimeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
                                    const Extension* extension) {
-  base::Version previous_version;
-  if (ReadPendingOnInstallInfoFromPref(extension->id(), &previous_version)) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
-                   browser_context_, extension->id(), previous_version, false));
-    RemovePendingOnInstallInfoFromPref(extension->id());
-  }
-
   if (!dispatch_chrome_updated_event_)
     return;
 
   // Dispatch the onInstalled event with reason "chrome_update".
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
                  browser_context_, extension->id(), base::Version(), true));
 }
 
-void RuntimeAPI::OnExtensionWillBeInstalled(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    bool is_update,
-    const std::string& old_name) {
-  // This extension might be disabled before it has a chance to load, e.g. if
-  // the extension increased its permissions. So instead of trying to send the
-  // onInstalled event here, we remember the fact in prefs and fire the event
-  // when the extension is actually loaded.
-  StorePendingOnInstallInfoToPref(extension);
-}
-
 void RuntimeAPI::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UninstallReason reason) {
-  RemovePendingOnInstallInfoFromPref(extension->id());
-
   RuntimeEventRouter::OnExtensionUninstalled(
       browser_context_, extension->id(), reason);
 }
 
 void RuntimeAPI::Shutdown() {
   delegate_->RemoveUpdateObserver(this);
+  EventRouter::Get(browser_context_)
+      ->lazy_event_dispatch_util()
+      ->RemoveObserver(this);
 }
 
 void RuntimeAPI::OnAppUpdateAvailable(const Extension* extension) {
   RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
       browser_context_, extension->id(), extension->manifest()->value());
 }
 
 void RuntimeAPI::OnChromeUpdateAvailable() {
   RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(browser_context_);
 }
 
 void RuntimeAPI::OnBackgroundHostStartup(const Extension* extension) {
   RuntimeEventRouter::DispatchOnStartupEvent(browser_context_, extension->id());
 }
 
-bool RuntimeAPI::ReadPendingOnInstallInfoFromPref(
-    const ExtensionId& extension_id,
-    base::Version* previous_version) {
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
-  DCHECK(prefs);
-
-  const base::DictionaryValue* info = nullptr;
-  if (!prefs->ReadPrefAsDictionary(
-          extension_id, kPrefPendingOnInstalledEventDispatchInfo, &info)) {
-    return false;
-  }
-
-  std::string previous_version_string;
-  info->GetString(kPrefPreviousVersion, &previous_version_string);
-  // |previous_version_string| can be empty.
-  *previous_version = base::Version(previous_version_string);
-  return true;
-}
-
-void RuntimeAPI::RemovePendingOnInstallInfoFromPref(
-    const ExtensionId& extension_id) {
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
-  DCHECK(prefs);
-
-  prefs->UpdateExtensionPref(extension_id,
-                             kPrefPendingOnInstalledEventDispatchInfo, nullptr);
-}
-
-void RuntimeAPI::StorePendingOnInstallInfoToPref(const Extension* extension) {
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
-  DCHECK(prefs);
-
-  // |pending_on_install_info| currently only contains a version string. Instead
-  // of making the pref hold a plain string, we store it as a dictionary value
-  // so that we can add more stuff to it in the future if necessary.
-  std::unique_ptr<base::DictionaryValue> pending_on_install_info(
-      new base::DictionaryValue());
-  base::Version previous_version = ExtensionRegistry::Get(browser_context_)
-                                       ->GetStoredVersion(extension->id());
-  pending_on_install_info->SetString(
-      kPrefPreviousVersion,
-      previous_version.IsValid() ? previous_version.GetString() : "");
-  prefs->UpdateExtensionPref(extension->id(),
-                             kPrefPendingOnInstalledEventDispatchInfo,
-                             std::move(pending_on_install_info));
-}
-
 void RuntimeAPI::ReloadExtension(const std::string& extension_id) {
   delegate_->ReloadExtension(extension_id);
 }
 
 bool RuntimeAPI::CheckForUpdates(
     const std::string& extension_id,
     const RuntimeAPIDelegate::UpdateCheckCallback& callback) {
   return delegate_->CheckForUpdates(extension_id, callback);
 }
 
@@ skipping 284 matching lines @@
 
   if (!uninstall_url.SchemeIsHTTPOrHTTPS()) {
     // Previous versions of Chrome allowed non-http(s) URLs to be stored in the
     // prefs. Now they're disallowed, but the old data may still exist.
     return;
   }
 
   RuntimeAPI::GetFactoryInstance()->Get(context)->OpenURL(uninstall_url);
 }
 
+void RuntimeAPI::OnExtensionInstalledAndLoaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    const base::Version& previous_version) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
+                 browser_context_, extension->id(), previous_version, false));
+}
+
 ExtensionFunction::ResponseAction RuntimeGetBackgroundPageFunction::Run() {
   ExtensionHost* host = ProcessManager::Get(browser_context())
                             ->GetBackgroundHostForExtension(extension_id());
   if (LazyBackgroundTaskQueue::Get(browser_context())
           ->ShouldEnqueueTask(browser_context(), extension())) {
     LazyBackgroundTaskQueue::Get(browser_context())
         ->AddPendingTask(
             browser_context(), extension_id(),
             base::Bind(&RuntimeGetBackgroundPageFunction::OnPageLoaded, this));
   } else if (host) {
@@ skipping 135 matching lines @@
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return RespondNow(OneArgument(std::move(dict)));
 }
 
 }  // namespace extensions