Replace "external_install" boolean parameter with explicit enumeration in ExtensionUninstall method.

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 "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 1028 matching lines @@
   void UninstallExtension(const std::string& id, bool use_helper) {
     // 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));
+      EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(
+          service_, id, ExtensionService::kUninstallReasonDefault));
     } else {
-      EXPECT_TRUE(service_->UninstallExtension(id, false, NULL));
+      EXPECT_TRUE(service_->UninstallExtension(
+          id, ExtensionService::kUninstallReasonDefault, 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 2731 matching lines @@
   extensions::ExtensionInfo extension_info(
       &manifest, std::string(), path, Manifest::UNPACKED);
 
   // Ensure we can load it with no management policy in place.
   management_policy_->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(), false, NULL));
+  EXPECT_TRUE(service_->UninstallExtension(
+      extension->id(), ExtensionService::kUninstallReasonDefault, 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);
   management_policy_->RegisterProvider(&provider_);
 
   extensions::InstalledLoader(service_).Load(extension_info, false);
   EXPECT_EQ(0u, registry_->enabled_extensions().size());
 }
@@ skipping 26 matching lines @@
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
   EXPECT_EQ(0u, registry_->disabled_extensions().size());
 
   management_policy_->UnregisterAllProviders();
   extensions::TestManagementPolicyProvider provider(
       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
   management_policy_->RegisterProvider(&provider);
 
   // Attempt to uninstall it.
-  EXPECT_FALSE(service_->UninstallExtension(good_crx, false, NULL));
+  EXPECT_FALSE(service_->UninstallExtension(
+      good_crx, ExtensionService::kUninstallReasonDefault, 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 521 matching lines @@
   IndexedDBContext* idb_context =
       BrowserContext::GetDefaultStoragePartition(profile_.get())->
           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, false, NULL);
+  service_->UninstallExtension(
+      good_crx, ExtensionService::kUninstallReasonDefault, 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 168 matching lines @@
       .AppendASCII("1");
   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, false, NULL);
+  service_->UninstallExtension(
+      id, ExtensionService::kUninstallReasonDefault, 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 91 matching lines @@
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
   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 =
       management_policy_->MustRemainEnabled(loaded_[0].get(), NULL);
-  service_->UninstallExtension(id, false, NULL);
+  service_->UninstallExtension(
+      id, ExtensionService::kUninstallReasonDefault, 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 43 matching lines @@
         content::NotificationService::AllSources());
     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, false, NULL);
+    service_->UninstallExtension(
+        id, ExtensionService::kUninstallReasonDefault, 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 2142 matching lines @@
   // ReconcileKnownDisabled().
   service_->EnableExtension(good2);
   service_->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
   EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             registry_->disabled_extensions().GetIDs());
 }