Add "UninstallReason" parameter to ExtensionRegistryObserver::OnExtensionUninstalled.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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 "chrome/browser/extensions/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 85 matching lines @@
 using extensions::ExtensionSet;
 using extensions::FeatureSwitch;
 using extensions::InstallVerifier;
 using extensions::ManagementPolicy;
 using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 using extensions::SharedModuleInfo;
 using extensions::SharedModuleService;
+using extensions::UninstalledExtensionInfo;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extensions::manifest_errors;
 
 namespace {
 
 // Wait this many seconds after an extensions becomes idle before updating it.
 const int kUpdateIdleDelay = 5;
 
 bool IsCWSSharedModule(const Extension* extension) {
@@ skipping 45 matching lines @@
   // For example, an extension that requires experimental permissions
   // will not be loaded if the experimental command line flag is not used.
   // In this case, do not uninstall.
   if (!GetInstalledExtension(id)) {
     // We can't call UninstallExtension with an unloaded/invalid
     // extension ID.
     LOG(WARNING) << "Attempted uninstallation of unloaded/invalid extension "
                  << "with id: " << id;
     return;
   }
-  UninstallExtension(id, UNINSTALL_REASON_ORPHANED_EXTERNAL_EXTENSION, NULL);
+  UninstallExtension(
+      id, UninstalledExtensionInfo::REASON_ORPHANED_EXTERNAL_EXTENSION, NULL);
 }
 
 void ExtensionService::SetFileTaskRunnerForTesting(
     base::SequencedTaskRunner* task_runner) {
   file_task_runner_ = task_runner;
 }
 
 void ExtensionService::ClearProvidersForTesting() {
   external_extension_providers_.clear();
 }
@@ skipping 48 matching lines @@
   return true;
 }
 
 // static
 // This function is used to uninstall an extension via sync.  The LOG statements
 // within this function are used to inform the user if the uninstall cannot be
 // done.
 bool ExtensionService::UninstallExtensionHelper(
     ExtensionService* extensions_service,
     const std::string& extension_id,
-    UninstallReason reason) {
+    UninstalledExtensionInfo::Reason reason) {
   // We can't call UninstallExtension with an invalid extension ID.
   if (!extensions_service->GetInstalledExtension(extension_id)) {
     LOG(WARNING) << "Attempted uninstallation of non-existent extension with "
                  << "id: " << extension_id;
     return false;
   }
 
   // The following call to UninstallExtension will not allow an uninstall of a
   // policy-controlled extension.
   base::string16 error;
@@ skipping 436 matching lines @@
   }
   // When reloading is done, mark this extension as done reloading.
   SetBeingReloaded(extension_id, false);
 #endif  // defined(ENABLE_EXTENSIONS)
 }
 
 bool ExtensionService::UninstallExtension(
     // "transient" because the process of uninstalling may cause the reference
     // to become invalid. Instead, use |extenson->id()|.
     const std::string& transient_extension_id,
-    UninstallReason reason,
+    UninstalledExtensionInfo::Reason reason,
     base::string16* error) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_refptr<const Extension> extension =
       GetInstalledExtension(transient_extension_id);
 
   // Callers should not send us nonexistent extensions.
   CHECK(extension.get());
 
   // Policy change which triggers an uninstall will always set
   // |external_uninstall| to true so this is the only way to uninstall
   // managed extensions.
   // Shared modules being uninstalled will also set |external_uninstall| to true
   // so that we can guarantee users don't uninstall a shared module.
   // (crbug.com/273300)
   // TODO(rdevlin.cronin): This is probably not right. We should do something
   // else, like include an enum IS_INTERNAL_UNINSTALL or IS_USER_UNINSTALL so
   // we don't do this.
   bool external_uninstall =
-      (reason == UNINSTALL_REASON_INTERNAL_MANAGEMENT) ||
-      (reason == UNINSTALL_REASON_ORPHANED_EXTERNAL_EXTENSION) ||
-      (reason == UNINSTALL_REASON_ORPHANED_SHARED_MODULE);
+      (reason == UninstalledExtensionInfo::REASON_INTERNAL_MANAGEMENT) ||
+      (reason ==
+       UninstalledExtensionInfo::REASON_ORPHANED_EXTERNAL_EXTENSION) ||

[Devlin, 2014/07/16 20:05:43]

nit: please extra-indent this line.

[rpaquay, 2014/07/16 21:16:45]

Done.

+      (reason == UninstalledExtensionInfo::REASON_ORPHANED_SHARED_MODULE);
   if (!external_uninstall &&
       !system_->management_policy()->UserMayModifySettings(
         extension.get(), error)) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension.get()));
     return false;
   }
 
@@ skipping 24 matching lines @@
                        install_directory_,
                        extension->path())))
       NOTREACHED();
   }
 
   extensions::DataDeleter::StartDeleting(profile_, extension.get());
 
   UntrackTerminatedExtension(extension->id());
 
   // Notify interested parties that we've uninstalled this extension.
+  UninstalledExtensionInfo details(extension, reason);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
       content::Source<Profile>(profile_),
-      content::Details<const Extension>(extension.get()));
+      content::Details<UninstalledExtensionInfo>(&details));
   ExtensionRegistry::Get(profile_)->TriggerOnUninstalled(extension.get());
 
   if (extension_sync_service_) {
     extension_sync_service_->ProcessSyncUninstallExtension(extension->id(),
                                                            sync_change);
   }
 
   delayed_installs_.Remove(extension->id());
 
   extension_prefs_->OnExtensionUninstalled(
@@ skipping 518 matching lines @@
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension.get()));
 }
 
 void ExtensionService::RemoveComponentExtension(
     const std::string& extension_id) {
   scoped_refptr<const Extension> extension(
       GetExtensionById(extension_id, false));
   UnloadExtension(extension_id, UnloadedExtensionInfo::REASON_UNINSTALL);
   if (extension.get()) {
+    UninstalledExtensionInfo details(
+        extension, UninstalledExtensionInfo::REASON_INTERNAL_MANAGEMENT);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
         content::Source<Profile>(profile_),
-        content::Details<const Extension>(extension.get()));
+        content::Details<UninstalledExtensionInfo>(&details));
     ExtensionRegistry::Get(profile_)->TriggerOnUninstalled(extension.get());
   }
 }
 
 void ExtensionService::UnloadAllExtensionsForTest() {
   UnloadAllExtensionsInternal();
 }
 
 void ExtensionService::ReloadExtensionsForTest() {
   // Calling UnloadAllExtensionsForTest here triggers a false-positive presubmit
@@ skipping 1026 matching lines @@
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }