[Extensions Toolbar] Only include relevant items in component extensions' menus

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/chromium_strings.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_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/manifest_handlers/options_page_info.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/image/image.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,
                                               Manifest::Location location) {
@@ skipping 47 matching lines @@
   // Returns the number of extension menu items that show up in |model|.
   int CountExtensionItems(ExtensionContextMenuModel* model);
 
  private:
   int cur_id_;
 };
 
 ExtensionContextMenuModelTest::ExtensionContextMenuModelTest() : cur_id_(0) {
 }
 
-
 void ExtensionContextMenuModelTest::AddContextItemAndRefreshModel(
     MenuManager* manager,
     const Extension* extension,
     MenuItem::Context context,
     ExtensionContextMenuModel* model) {
   MenuItem::Type type = MenuItem::NORMAL;
   MenuItem::ContextList contexts(context);
   const MenuItem::ExtensionKey key(extension->id());
   MenuItem::Id id(false, key);
   id.uid = ++cur_id_;
@@ skipping 15 matching lines @@
 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, RequiredInstallationsDisablesItems) {
   InitializeEmptyExtensionService();
 
-  // First, test that a component extension cannot be uninstalled by the
-  // standard management policy.
+  // Test that management policy can determine whether or not policy-installed
+  // extensions can be installed/uninstalled.
   scoped_refptr<const Extension> extension =
-      BuildExtension("component",
-                     manifest_keys::kBrowserAction,
-                     Manifest::COMPONENT);
+      BuildExtension("extension",
+                     manifest_keys::kPageAction,
+                     Manifest::EXTERNAL_POLICY);
   ASSERT_TRUE(extension.get());
   service()->AddExtension(extension.get());
 
   scoped_ptr<Browser> browser = CreateBrowser(profile());
+  scoped_refptr<ExtensionContextMenuModel> menu(
+      new ExtensionContextMenuModel(extension.get(), browser.get()));
+
+  ExtensionSystem* system = ExtensionSystem::Get(profile());
+  system->management_policy()->UnregisterAllProviders();
+
+  // Uninstallation should be, by default, enabled.
+  ASSERT_TRUE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL));
+
+  TestManagementPolicyProvider policy_provider(
+      TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
+  system->management_policy()->RegisterProvider(&policy_provider);
+
+  // If there's a policy provider that requires the extension stay enabled, then
+  // uninstallation should be disabled.
+  ASSERT_FALSE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL));
+
+  // Don't leave |policy_provider| dangling.
+  system->management_policy()->UnregisterProvider(&policy_provider);
+}
+
+// Tests the context menu for a component extension.
+TEST_F(ExtensionContextMenuModelTest, ComponentExtensionContextMenu) {
+  InitializeEmptyExtensionService();
+
+  std::string name("component");
+  scoped_ptr<base::DictionaryValue> manifest =
+      DictionaryBuilder().Set("name", name)
+                         .Set("version", "1")
+                         .Set("manifest_version", 2)
+                         .Set("browser_action", DictionaryBuilder().Pass())
+                         .Build();
+
+  scoped_refptr<const Extension> extension =
+      ExtensionBuilder().SetManifest(make_scoped_ptr(manifest->DeepCopy()))
+                        .SetID(crx_file::id_util::GenerateId("component"))
+                        .SetLocation(Manifest::COMPONENT)
+                        .Build();
+  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));
+  // A component extension's context menu should not include options for
+  // managing extensions or removing it, and should only include an option for
+  // the options page if the extension has one (which this one doesn't).
+  EXPECT_EQ(-1,
+            menu->GetIndexOfCommandId(ExtensionContextMenuModel::CONFIGURE));
+  EXPECT_EQ(-1,
+            menu->GetIndexOfCommandId(ExtensionContextMenuModel::UNINSTALL));
+  EXPECT_EQ(-1, menu->GetIndexOfCommandId(ExtensionContextMenuModel::MANAGE));
+  // The "name" option should be present, but not enabled for component
+  // extensions.
+  EXPECT_NE(-1, menu->GetIndexOfCommandId(ExtensionContextMenuModel::NAME));
+  EXPECT_FALSE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::NAME));
 
-  // 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());
+  // Check that a component extension with an options page does have the options
+  // menu item, and it is enabled.
+  manifest->SetString("options_page", "options_page.html");
+  extension =
+      ExtensionBuilder().SetManifest(manifest.Pass())
+                        .SetID(crx_file::id_util::GenerateId("component_opts"))
+                        .SetLocation(Manifest::COMPONENT)
+                        .Build();
+  menu = new ExtensionContextMenuModel(extension.get(), browser.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()->UnregisterProvider(&policy_provider);
+  EXPECT_TRUE(extensions::OptionsPageInfo::HasOptionsPage(extension.get()));
+  EXPECT_NE(-1,
+            menu->GetIndexOfCommandId(ExtensionContextMenuModel::CONFIGURE));
+  EXPECT_TRUE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::CONFIGURE));
 }
 
 TEST_F(ExtensionContextMenuModelTest, ExtensionItemTest) {
   InitializeEmptyExtensionService();
   scoped_refptr<const Extension> extension =
       BuildExtension("extension",
                      manifest_keys::kPageAction,
                      Manifest::INTERNAL);
   ASSERT_TRUE(extension.get());
   service()->AddExtension(extension.get());
@@ skipping 129 matching lines @@
              browser_action.get(),
              browser.get(),
              ExtensionContextMenuModel::TRANSITIVELY_VISIBLE,
              nullptr);
   index = GetCommandIndex(menu, visibility_command);
   EXPECT_NE(-1, index);
   EXPECT_EQ(redesign_keep_string, menu->GetLabelAt(index));
 }
 
 }  // namespace extensions