[Extensions Toolbar] Have all extensions in the toolbar show a context menu

chrome/browser/extensions/extension_context_menu_model_unittest.cc

 // Copyright (c) 2012 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_context_menu_model.h"
 
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/extensions/menu_manager_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/extensions/api/context_menus.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/test_browser_window.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/crx_file/id_util.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/test_management_policy.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/feature_switch.h"
+#include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 
 namespace {
 
 // Build an extension to pass to the menu constructor, with the an action
 // specified by |action_key|.
 scoped_refptr<const Extension> BuildExtension(const std::string& name,
-                                              const char* action_key) {
+                                              const char* action_key,
+                                              Manifest::Location location) {
   return ExtensionBuilder()
       .SetManifest(DictionaryBuilder()
                        .Set("name", name)
                        .Set("version", "1")
                        .Set("manifest_version", 2)
                        .Set(action_key, DictionaryBuilder().Pass()))
       .SetID(crx_file::id_util::GenerateId(name))
+      .SetLocation(location)
       .Build();
 }
 
 // Create a Browser for the ExtensionContextMenuModel to use.
 scoped_ptr<Browser> CreateBrowser(Profile* profile) {
   Browser::CreateParams params(profile, chrome::GetActiveDesktop());
   TestBrowserWindow test_window;
   params.window = &test_window;
   return scoped_ptr<Browser>(new Browser(params));
 }
@@ skipping 62 matching lines @@
   model->InitMenu(model->GetExtension());
 }
 
 int ExtensionContextMenuModelTest::CountExtensionItems(
     ExtensionContextMenuModel* model) {
   return model->extension_items_count_;
 }
 
 // Tests that applicable menu items are disabled when a ManagementPolicy
 // prohibits them.
-TEST_F(ExtensionContextMenuModelTest, PolicyDisablesItems) {
+TEST_F(ExtensionContextMenuModelTest, RequiredInstallationsDisablesItems) {
   InitializeEmptyExtensionService();
+
+  // First, test that a component extension cannot be uninstalled by the
+  // standard management policy.
   scoped_refptr<const Extension> extension =
-      BuildExtension("extension", manifest_keys::kPageAction);
+      BuildExtension("component",
+                     manifest_keys::kBrowserAction,
+                     Manifest::COMPONENT);
   ASSERT_TRUE(extension.get());
   service()->AddExtension(extension.get());
 
   scoped_ptr<Browser> browser = CreateBrowser(profile());
 
   scoped_refptr<ExtensionContextMenuModel> menu(
       new ExtensionContextMenuModel(extension.get(), browser.get()));
 
+  // Uninstallation should be disabled.
+  EXPECT_FALSE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL));
+
+  // Also test that management policy can determine whether or not
+  // policy-installed extensions can be installed/uninstalled.
+  extension = BuildExtension("extension",
+                             manifest_keys::kPageAction,
+                             Manifest::INTERNAL);
+  ASSERT_TRUE(extension.get());
+  service()->AddExtension(extension.get());
+
+  menu = new ExtensionContextMenuModel(extension.get(), browser.get());
+
   ExtensionSystem* system = ExtensionSystem::Get(profile());
   system->management_policy()->UnregisterAllProviders();
 
   // Actions should be enabled.
   ASSERT_TRUE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL));
 
   TestManagementPolicyProvider policy_provider(
       TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
   system->management_policy()->RegisterProvider(&policy_provider);
 
   // Now the actions are disabled.
   ASSERT_FALSE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL));
 
   // Don't leave |policy_provider| dangling.
-  system->management_policy()->UnregisterAllProviders();
+  system->management_policy()->UnregisterProvider(&policy_provider);
 }
 
 TEST_F(ExtensionContextMenuModelTest, ExtensionItemTest) {
   InitializeEmptyExtensionService();
   scoped_refptr<const Extension> extension =
-      BuildExtension("extension", manifest_keys::kPageAction);
+      BuildExtension("extension",
+                     manifest_keys::kPageAction,
+                     Manifest::INTERNAL);
   ASSERT_TRUE(extension.get());
   service()->AddExtension(extension.get());
 
   scoped_ptr<Browser> browser = CreateBrowser(profile());
 
   // Create a MenuManager for adding context items.
   MenuManager* manager = static_cast<MenuManager*>(
       (MenuManagerFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(),
           &MenuManagerFactory::BuildServiceInstanceForTesting)));
@@ skipping 38 matching lines @@
   // Adding another top level item should not increase the count.
   EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT,
             CountExtensionItems(menu.get()));
 }
 
 // Test that the "show" and "hide" menu items appear correctly in the extension
 // context menu.
 TEST_F(ExtensionContextMenuModelTest, ExtensionContextMenuShowAndHide) {
   InitializeEmptyExtensionService();
   scoped_refptr<const Extension> page_action =
-      BuildExtension("page_action_extension", manifest_keys::kPageAction);
+      BuildExtension("page_action_extension",
+                     manifest_keys::kPageAction,
+                     Manifest::INTERNAL);
   ASSERT_TRUE(page_action.get());
   scoped_refptr<const Extension> browser_action =
-      BuildExtension("browser_action_extension", manifest_keys::kBrowserAction);
+      BuildExtension("browser_action_extension",
+                     manifest_keys::kBrowserAction,
+                     Manifest::INTERNAL);
   ASSERT_TRUE(browser_action.get());
 
   service()->AddExtension(page_action.get());
   service()->AddExtension(browser_action.get());
 
   scoped_ptr<Browser> browser = CreateBrowser(profile());
 
   scoped_refptr<ExtensionContextMenuModel> menu(
       new ExtensionContextMenuModel(page_action.get(), browser.get()));
 
@@ skipping 35 matching lines @@
   // Hide the browser action. This should mean the string is "show".
   ExtensionActionAPI::SetBrowserActionVisibility(
       prefs, browser_action->id(), false);
   menu = new ExtensionContextMenuModel(browser_action.get(), browser.get());
   index = GetCommandIndex(menu, visibility_command);
   EXPECT_NE(-1, index);
   EXPECT_EQ(show_string, menu->GetLabelAt(index));
 }
 
 }  // namespace extensions