[Extensions] Make chrome://extensions use management.uninstall

chrome/browser/extensions/api/management/management_api_unittest.cc

 // Copyright 2015 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_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/host_desktop.h"
@@ skipping 87 matching lines @@
   std::string extension_id = extension->id();
   scoped_refptr<ManagementSetEnabledFunction> function(
       new ManagementSetEnabledFunction());
 
   base::ListValue disable_args;
   disable_args.AppendString(extension_id);
   disable_args.AppendBoolean(false);
 
   // Test disabling an (enabled) extension.
   EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
-  EXPECT_TRUE(RunFunction(function, disable_args));
+  EXPECT_TRUE(RunFunction(function, disable_args)) << function->GetError();
   EXPECT_TRUE(registry()->disabled_extensions().Contains(extension_id));
 
   base::ListValue enable_args;
   enable_args.AppendString(extension_id);
   enable_args.AppendBoolean(true);
 
   // Test re-enabling it.
   function = new ManagementSetEnabledFunction();
-  EXPECT_TRUE(RunFunction(function, enable_args));
+  EXPECT_TRUE(RunFunction(function, enable_args)) << function->GetError();
   EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
 
   // Test that the enable function checks management policy, so that we can't
   // disable an extension that is required.
   TestManagementPolicyProvider provider(
       TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
   ManagementPolicy* policy =
       ExtensionSystem::Get(profile())->management_policy();
   policy->RegisterProvider(&provider);
 
   function = new ManagementSetEnabledFunction();
   EXPECT_FALSE(RunFunction(function, disable_args));
   EXPECT_EQ(ErrorUtils::FormatErrorMessage(constants::kUserCantModifyError,
                                            extension_id),
             function->GetError());
   policy->UnregisterProvider(&provider);
 
   // TODO(devlin): We should also test enabling an extenion that has escalated
   // permissions, but that needs a web contents (which is a bit of a pain in a
   // unit test).
 }
 
+// Tests management.uninstall.
+TEST_F(ManagementApiUnitTest, ManagementUninstall) {
+  // We need to be on the UI thread for this.
+  ResetThreadBundle(content::TestBrowserThreadBundle::DEFAULT);
+  scoped_refptr<const Extension> extension = test_util::CreateEmptyExtension();
+  service()->AddExtension(extension.get());
+  std::string extension_id = extension->id();
+
+  base::ListValue uninstall_args;
+  uninstall_args.AppendString(extension->id());
+
+  // Auto-accept any uninstalls.
+  ManagementUninstallFunctionBase::SetAutoConfirmForTest(true);
+
+  // Uninstall requires a user gesture, so this should fail.
+  scoped_refptr<UIThreadExtensionFunction> function(
+      new ManagementUninstallFunction());
+  EXPECT_FALSE(RunFunction(function, uninstall_args));
+  EXPECT_EQ(std::string(constants::kGestureNeededForUninstallError),
+            function->GetError());
+
+  ExtensionFunction::ScopedUserGestureForTests scoped_user_gesture;
+
+  function = new ManagementUninstallFunction();
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
+  EXPECT_TRUE(RunFunction(function, uninstall_args)) << function->GetError();
+  // The extension should be uninstalled.
+  EXPECT_FALSE(registry()->GetExtensionById(
+      extension_id, ExtensionRegistry::EVERYTHING));
+
+  // Install the extension again, and try uninstalling, auto-canceling the
+  // dialog.
+  service()->AddExtension(extension.get());
+  function = new ManagementUninstallFunction();
+  ManagementUninstallFunctionBase::SetAutoConfirmForTest(false);
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
+  EXPECT_FALSE(RunFunction(function, uninstall_args));
+  // The uninstall should have failed.
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
+  EXPECT_EQ(ErrorUtils::FormatErrorMessage(constants::kUninstallCanceledError,
+                                           extension_id),
+            function->GetError());
+
+  // Try again, using showConfirmDialog: false.
+  scoped_ptr<base::DictionaryValue> options(new base::DictionaryValue());
+  options->SetBoolean("showConfirmDialog", false);
+  uninstall_args.Append(options.release());
+  function = new ManagementUninstallFunction();
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
+  EXPECT_FALSE(RunFunction(function, uninstall_args));
+  // This should still fail, since extensions can only suppress the dialog for
+  // uninstalling themselves.
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
+  EXPECT_EQ(ErrorUtils::FormatErrorMessage(constants::kUninstallCanceledError,
+                                           extension_id),
+            function->GetError());
+
+  // If we try uninstall the extension itself, the uninstall should succeed
+  // (even though we auto-cancel any dialog), because the dialog is never shown.
+  uninstall_args.Remove(0u, nullptr);
+  function = new ManagementUninstallSelfFunction();
+  function->set_extension(extension);
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_id));
+  EXPECT_TRUE(RunFunction(function, uninstall_args)) << function->GetError();
+  EXPECT_FALSE(registry()->GetExtensionById(
+      extension_id, ExtensionRegistry::EVERYTHING));
+}
+
 }  // namespace extensions