Add "UninstallReason" parameter to ExtensionRegistryObserver::OnExtensionUninstalled.

chrome/browser/extensions/extension_service_unittest.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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 71 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/browser/test_management_policy.h"
+#include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ skipping 749 matching lines @@
     // Verify that the extension is installed.
     base::FilePath extension_path = extensions_install_dir().AppendASCII(id);
     EXPECT_TRUE(base::PathExists(extension_path));
     size_t pref_key_count = GetPrefKeyCount();
     EXPECT_GT(pref_key_count, 0u);
     ValidateIntegerPref(id, "state", Extension::ENABLED);
 
     // Uninstall it.
     if (use_helper) {
       EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(
-          service(), id, ExtensionService::UNINSTALL_REASON_FOR_TESTING));
+          service(), id, extensions::UNINSTALL_REASON_FOR_TESTING));
     } else {
       EXPECT_TRUE(service()->UninstallExtension(
-          id, ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL));
+          id, extensions::UNINSTALL_REASON_FOR_TESTING, NULL));
     }
     --expected_extensions_count_;
 
     // We should get an unload notification.
     EXPECT_FALSE(unloaded_id_.empty());
     EXPECT_EQ(id, unloaded_id_);
 
     // Verify uninstalled state.
     size_t new_pref_key_count = GetPrefKeyCount();
     if (new_pref_key_count == pref_key_count) {
@@ skipping 553 matching lines @@
     : public extensions::ExtensionRegistryObserver {
   virtual void OnExtensionWillBeInstalled(
       content::BrowserContext* browser_context,
       const Extension* extension,
       bool is_update,
       bool from_ephemeral,
       const std::string& old_name) OVERRIDE {
     last_extension_installed = extension->id();
   }
 
-  virtual void OnExtensionUninstalled(content::BrowserContext* browser_context,
-                                      const Extension* extension) OVERRIDE {
+  virtual void OnExtensionUninstalled(
+      content::BrowserContext* browser_context,
+      const Extension* extension,
+      extensions::UninstallReason reason) OVERRIDE {
     last_extension_uninstalled = extension->id();
   }
 
   std::string last_extension_installed;
   std::string last_extension_uninstalled;
 };
 
 // Test that correct notifications are sent to ExtensionRegistryObserver on
 // extension install and uninstall.
 TEST_F(ExtensionServiceTest, InstallObserverNotified) {
@@ skipping 2283 matching lines @@
 
   // Ensure we can load it with no management policy in place.
   GetManagementPolicy()->UnregisterAllProviders();
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   extensions::InstalledLoader(service()).Load(extension_info, false);
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
 
   const Extension* extension =
       (registry()->enabled_extensions().begin())->get();
   EXPECT_TRUE(service()->UninstallExtension(
-      extension->id(), ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL));
+      extension->id(), extensions::UNINSTALL_REASON_FOR_TESTING, NULL));
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
 
   // Ensure we cannot load it if management policy prohibits installation.
   extensions::TestManagementPolicyProvider provider_(
       extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
   GetManagementPolicy()->RegisterProvider(&provider_);
 
   extensions::InstalledLoader(service()).Load(extension_info, false);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
 }
@@ skipping 27 matching lines @@
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
 
   GetManagementPolicy()->UnregisterAllProviders();
   extensions::TestManagementPolicyProvider provider(
       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
   GetManagementPolicy()->RegisterProvider(&provider);
 
   // Attempt to uninstall it.
   EXPECT_FALSE(service()->UninstallExtension(
-      good_crx, ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL));
+      good_crx, extensions::UNINSTALL_REASON_FOR_TESTING, NULL));
 
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
 }
 
 // Tests that previously installed extensions that are now prohibited from
 // being installed are removed.
 TEST_F(ExtensionServiceTest, ManagementPolicyUnloadsAllProhibited) {
   InitializeEmptyExtensionService();
 
@@ skipping 524 matching lines @@
   IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
                                       profile())->GetIndexedDBContext();
   idb_context->SetTaskRunnerForTesting(
       base::MessageLoop::current()->message_loop_proxy().get());
   base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
   EXPECT_TRUE(base::CreateDirectory(idb_path));
   EXPECT_TRUE(base::DirectoryExists(idb_path));
 
   // Uninstall the extension.
   service()->UninstallExtension(
-      good_crx, ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL);
+      good_crx, extensions::UNINSTALL_REASON_FOR_TESTING, NULL);
   base::RunLoop().RunUntilIdle();
 
   // Check that the cookie is gone.
   cookie_monster->GetAllCookiesForURLAsync(
        ext_url,
        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
                   base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0U, callback.list_.size());
 
@@ skipping 172 matching lines @@
   extensions::UnpackedInstaller::Create(service())->Load(no_manifest);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
 
   // Test uninstall.
   std::string id = loaded_[0]->id();
   EXPECT_FALSE(unloaded_id_.length());
   service()->UninstallExtension(
-      id, ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL);
+      id, extensions::UNINSTALL_REASON_FOR_TESTING, NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(id, unloaded_id_);
   ASSERT_EQ(0u, loaded_.size());
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
 }
 
 // Tests that we generate IDs when they are not specified in the manifest for
 // --load-extension.
 TEST_F(ExtensionServiceTest, GenerateID) {
   InitializeEmptyExtensionService();
@@ skipping 92 matching lines @@
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
   // Uninstall the extension and reload. Nothing should happen because the
   // preference should prevent us from reinstalling.
   std::string id = loaded_[0]->id();
   bool no_uninstall =
       GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL);
   service()->UninstallExtension(
-      id, ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL);
+      id, extensions::UNINSTALL_REASON_FOR_TESTING, NULL);
   base::RunLoop().RunUntilIdle();
 
   base::FilePath install_path = extensions_install_dir().AppendASCII(id);
   if (no_uninstall) {
     // Policy controlled extensions should not have been touched by uninstall.
     ASSERT_TRUE(base::PathExists(install_path));
   } else {
     // The extension should also be gone from the install directory.
     ASSERT_FALSE(base::PathExists(install_path));
     loaded_.clear();
@@ skipping 44 matching lines @@
     provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
     service()->CheckForExternalUpdates();
     observer.Wait();
 
     ASSERT_EQ(1u, loaded_.size());
     ASSERT_EQ(0u, GetErrors().size());
 
     // User uninstalls.
     loaded_.clear();
     service()->UninstallExtension(
-        id, ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL);
+        id, extensions::UNINSTALL_REASON_FOR_TESTING, NULL);
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(0u, loaded_.size());
 
     // Then remove the extension from the extension provider.
     provider->RemoveExtension(good_crx);
 
     // Should still be at 0.
     loaded_.clear();
     extensions::InstalledLoader(service()).LoadAllExtensions();
     base::RunLoop().RunUntilIdle();
@@ skipping 2241 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }