Extend contextMenus API to support browser/page actions

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/context_menu_matcher.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/test/base/test_browser_window.h"
 #include "chrome/test/base/testing_profile.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/test_management_policy.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
-namespace {
+namespace api {
+namespace context_menus {
+
+extern const int ACTION_MENU_TOP_LEVEL_LIMIT;
+
+}  // namespace context_menus
+}  // namespace api
 
 class ExtensionContextMenuModelTest : public ExtensionServiceTestBase {
+ public:
+  // Build an extension to pass to the menu constructor.  It needs an
+  // ExtensionAction.
+  scoped_refptr<Extension> BuildExtension(std::string action_type) {
+    return ExtensionBuilder()
+        .SetManifest(
+             DictionaryBuilder()
+                 .Set("name", "Page Action Extension")
+                 .Set("version", "1")
+                 .Set("manifest_version", 2)
+                 .Set(action_type,
+                      DictionaryBuilder().Set("default_title", "Hello")))
+        .Build();
+  }
+
+  // Creates an extension menu item for |extension| with the given |context|
+  // and adds it to |manager|.
+  void AddContextItem(MenuManager* manager,
+                      Extension* extension,
+                      MenuItem::Context context) {
+    MenuItem::Type type = MenuItem::NORMAL;
+    MenuItem::ContextList contexts(context);
+    const MenuItem::ExtensionKey key(extension->id());
+    MenuItem::Id id(false, key);
+    id.uid = ++cur_id;
+    manager->AddContextItem(
+        extension, new MenuItem(id, "test", false, true, type, contexts));
+  }
+
+  // Reinitializes the given |model|.
+  void RefreshMenu(ExtensionContextMenuModel* model) {
+    model->InitMenu(model->GetExtension());
+  }
+
+  // Returns the number of extension menu items that show up in |model|.
+  int CountExtensionItems(ExtensionContextMenuModel* model) {
+    return model->extension_items_count_;
+  }
+
+  int cur_id = 0;
 };
 
+namespace {
+
 // Tests that applicable menu items are disabled when a ManagementPolicy
 // prohibits them.
 TEST_F(ExtensionContextMenuModelTest, PolicyDisablesItems) {
   InitializeEmptyExtensionService();
-  // Build an extension to pass to the menu constructor.  It needs an
-  // ExtensionAction.
-  scoped_refptr<Extension> extension = ExtensionBuilder()
-      .SetManifest(DictionaryBuilder()
-                   .Set("name", "Page Action Extension")
-                   .Set("version", "1")
-                   .Set("manifest_version", 2)
-                   .Set("page_action", DictionaryBuilder()
-                        .Set("default_title", "Hello")))
-      .Build();
+  scoped_refptr<Extension> extension = BuildExtension("page_action");
   ASSERT_TRUE(extension.get());
   service_->AddExtension(extension.get());
 
   // Create a Browser for the ExtensionContextMenuModel to use.
   Browser::CreateParams params(profile_.get(), chrome::GetActiveDesktop());
   TestBrowserWindow test_window;
   params.window = &test_window;
   Browser browser(params);
 
   scoped_refptr<ExtensionContextMenuModel> menu(
@@ skipping 10 matching lines @@
     extensions::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();
 }
 
+TEST_F(ExtensionContextMenuModelTest, ExtensionItemTest) {
+  InitializeEmptyExtensionService();
+  scoped_refptr<Extension> extension = BuildExtension("page_action");
+  ASSERT_TRUE(extension.get());
+  service_->AddExtension(extension.get());
+
+  // Create a Browser for the ExtensionContextMenuModel to use.
+  Browser::CreateParams params(profile_.get(), chrome::GetActiveDesktop());
+  TestBrowserWindow test_window;
+  params.window = &test_window;
+  Browser browser(params);
+
+  // Create a MenuManager for adding context items.
+  MenuManager* manager = static_cast<MenuManager*>(
+      (MenuManagerFactory::GetInstance()->SetTestingFactoryAndUse(
+          profile_.get(), &MenuManagerFactory::BuildInstanceFor)));
+  ASSERT_TRUE(manager);
+
+  scoped_refptr<ExtensionContextMenuModel> menu(
+      new ExtensionContextMenuModel(extension.get(), &browser, NULL));
+
+  // There should be no extension items yet.
+  ASSERT_TRUE(CountExtensionItems(menu) == 0);
+
+  // Add a browser action menu item for |extension| to |manager|.
+  AddContextItem(manager, extension.get(), MenuItem::BROWSER_ACTION);
+  RefreshMenu(menu);
+
+  // Since |extension| has a page action, the browser action menu item should
+  // not be present.
+  ASSERT_TRUE(CountExtensionItems(menu) == 0);
+
+  // Add a page action menu item and reset the context menu.
+  AddContextItem(manager, extension.get(), MenuItem::PAGE_ACTION);
+  RefreshMenu(menu);
+
+  // The page action item should be present because |extension| has a page
+  // action.
+  ASSERT_TRUE(CountExtensionItems(menu) == 1);
+
+  // Create more page action items to test top level menu item limitations.
+  for (int i = 0; i < api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT; ++i) {
+    AddContextItem(manager, extension.get(), MenuItem::PAGE_ACTION);
+  }
+  RefreshMenu(menu);
+
+  // The menu should only have a limited number of extension items, since they
+  // are all top level items, and we limit the number of top level extension
+  // items.
+  ASSERT_TRUE(CountExtensionItems(menu) ==
+              api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT);
+
+  AddContextItem(manager, extension.get(), MenuItem::PAGE_ACTION);
+  RefreshMenu(menu);
+
+  // Adding another top level item should not increase the count.
+  ASSERT_TRUE(CountExtensionItems(menu) ==
+              api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT);
+}
+
 }  // namespace
 }  // namespace extensions