OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/extensions/extension_context_menu_model.h" | 5 #include "chrome/browser/extensions/extension_context_menu_model.h" |
6 | 6 |
7 #include "chrome/browser/extensions/context_menu_matcher.h" | |
7 #include "chrome/browser/extensions/extension_service.h" | 8 #include "chrome/browser/extensions/extension_service.h" |
8 #include "chrome/browser/extensions/extension_service_test_base.h" | 9 #include "chrome/browser/extensions/extension_service_test_base.h" |
10 #include "chrome/browser/extensions/menu_manager.h" | |
11 #include "chrome/browser/extensions/menu_manager_factory.h" | |
9 #include "chrome/browser/ui/browser.h" | 12 #include "chrome/browser/ui/browser.h" |
10 #include "chrome/browser/ui/host_desktop.h" | 13 #include "chrome/browser/ui/host_desktop.h" |
14 #include "chrome/common/extensions/api/context_menus.h" | |
11 #include "chrome/test/base/test_browser_window.h" | 15 #include "chrome/test/base/test_browser_window.h" |
12 #include "chrome/test/base/testing_profile.h" | 16 #include "chrome/test/base/testing_profile.h" |
13 #include "extensions/browser/extension_system.h" | 17 #include "extensions/browser/extension_system.h" |
14 #include "extensions/browser/test_management_policy.h" | 18 #include "extensions/browser/test_management_policy.h" |
15 #include "extensions/common/extension_builder.h" | 19 #include "extensions/common/extension_builder.h" |
16 #include "extensions/common/value_builder.h" | 20 #include "extensions/common/value_builder.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 21 #include "testing/gtest/include/gtest/gtest.h" |
18 | 22 |
19 namespace extensions { | 23 namespace extensions { |
20 namespace { | 24 |
25 const char kPageAction[] = "page_action"; | |
21 | 26 |
22 class ExtensionContextMenuModelTest : public ExtensionServiceTestBase { | 27 class ExtensionContextMenuModelTest : public ExtensionServiceTestBase { |
28 public: | |
29 ExtensionContextMenuModelTest(); | |
30 | |
31 // Build an extension to pass to the menu constructor. It needs an | |
32 // ExtensionAction. | |
33 scoped_refptr<Extension> BuildExtension(const char* action_type); | |
34 | |
35 // Creates an extension menu item for |extension| with the given |context| | |
36 // and adds it to |manager|. | |
37 void AddContextItem(MenuManager* manager, | |
38 Extension* extension, | |
39 MenuItem::Context context); | |
40 | |
41 // Reinitializes the given |model|. | |
42 void RefreshMenu(ExtensionContextMenuModel* model); | |
43 | |
44 // Returns the number of extension menu items that show up in |model|. | |
45 int CountExtensionItems(ExtensionContextMenuModel* model); | |
46 | |
47 static KeyedService* BuildInstanceForTesting( | |
Yoyo Zhou
2014/07/29 01:38:18
nit: Add function documentation.
| |
48 content::BrowserContext* context); | |
49 | |
50 private: | |
51 int cur_id_; | |
23 }; | 52 }; |
24 | 53 |
54 ExtensionContextMenuModelTest::ExtensionContextMenuModelTest() | |
55 : cur_id_(0) {} | |
56 | |
57 scoped_refptr<Extension> ExtensionContextMenuModelTest::BuildExtension( | |
58 const char* action_type) { | |
59 return ExtensionBuilder() | |
60 .SetManifest( | |
61 DictionaryBuilder() | |
62 .Set("name", "Page Action Extension") | |
63 .Set("version", "1") | |
64 .Set("manifest_version", 2) | |
65 .Set(action_type, | |
66 DictionaryBuilder().Set("default_title", "Hello"))) | |
67 .Build(); | |
68 } | |
69 | |
70 void ExtensionContextMenuModelTest::AddContextItem(MenuManager* manager, | |
71 Extension* extension, | |
72 MenuItem::Context context) { | |
73 MenuItem::Type type = MenuItem::NORMAL; | |
74 MenuItem::ContextList contexts(context); | |
75 const MenuItem::ExtensionKey key(extension->id()); | |
76 MenuItem::Id id(false, key); | |
77 id.uid = ++cur_id_; | |
78 manager->AddContextItem( | |
79 extension, new MenuItem(id, | |
80 "test", | |
81 false, // checked | |
82 true, // enabled | |
83 type, | |
84 contexts)); | |
85 } | |
86 | |
87 void ExtensionContextMenuModelTest::RefreshMenu( | |
88 ExtensionContextMenuModel* model) { | |
89 model->InitMenu(model->GetExtension()); | |
90 } | |
91 | |
92 int ExtensionContextMenuModelTest::CountExtensionItems( | |
93 ExtensionContextMenuModel* model) { | |
94 return model->extension_items_count_; | |
95 } | |
96 | |
97 // static | |
98 KeyedService* ExtensionContextMenuModelTest::BuildInstanceForTesting( | |
99 content::BrowserContext* context) { | |
100 return MenuManagerFactory::GetInstance()->BuildServiceInstanceFor(context); | |
101 } | |
102 | |
103 namespace { | |
104 | |
25 // Tests that applicable menu items are disabled when a ManagementPolicy | 105 // Tests that applicable menu items are disabled when a ManagementPolicy |
26 // prohibits them. | 106 // prohibits them. |
27 TEST_F(ExtensionContextMenuModelTest, PolicyDisablesItems) { | 107 TEST_F(ExtensionContextMenuModelTest, PolicyDisablesItems) { |
28 InitializeEmptyExtensionService(); | 108 InitializeEmptyExtensionService(); |
29 // Build an extension to pass to the menu constructor. It needs an | 109 scoped_refptr<Extension> extension = BuildExtension(kPageAction); |
30 // ExtensionAction. | |
31 scoped_refptr<Extension> extension = ExtensionBuilder() | |
32 .SetManifest(DictionaryBuilder() | |
33 .Set("name", "Page Action Extension") | |
34 .Set("version", "1") | |
35 .Set("manifest_version", 2) | |
36 .Set("page_action", DictionaryBuilder() | |
37 .Set("default_title", "Hello"))) | |
38 .Build(); | |
39 ASSERT_TRUE(extension.get()); | 110 ASSERT_TRUE(extension.get()); |
40 service_->AddExtension(extension.get()); | 111 service_->AddExtension(extension.get()); |
41 | 112 |
42 // Create a Browser for the ExtensionContextMenuModel to use. | 113 // Create a Browser for the ExtensionContextMenuModel to use. |
43 Browser::CreateParams params(profile_.get(), chrome::GetActiveDesktop()); | 114 Browser::CreateParams params(profile_.get(), chrome::GetActiveDesktop()); |
44 TestBrowserWindow test_window; | 115 TestBrowserWindow test_window; |
45 params.window = &test_window; | 116 params.window = &test_window; |
46 Browser browser(params); | 117 Browser browser(params); |
47 | 118 |
48 scoped_refptr<ExtensionContextMenuModel> menu( | 119 scoped_refptr<ExtensionContextMenuModel> menu( |
49 new ExtensionContextMenuModel(extension.get(), &browser, NULL)); | 120 new ExtensionContextMenuModel(extension.get(), &browser)); |
50 | 121 |
51 extensions::ExtensionSystem* system = | 122 extensions::ExtensionSystem* system = |
52 extensions::ExtensionSystem::Get(profile_.get()); | 123 extensions::ExtensionSystem::Get(profile_.get()); |
53 system->management_policy()->UnregisterAllProviders(); | 124 system->management_policy()->UnregisterAllProviders(); |
54 | 125 |
55 // Actions should be enabled. | 126 // Actions should be enabled. |
56 ASSERT_TRUE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL)); | 127 ASSERT_TRUE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL)); |
57 | 128 |
58 extensions::TestManagementPolicyProvider policy_provider( | 129 extensions::TestManagementPolicyProvider policy_provider( |
59 extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS); | 130 extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS); |
60 system->management_policy()->RegisterProvider(&policy_provider); | 131 system->management_policy()->RegisterProvider(&policy_provider); |
61 | 132 |
62 // Now the actions are disabled. | 133 // Now the actions are disabled. |
63 ASSERT_FALSE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL)); | 134 ASSERT_FALSE(menu->IsCommandIdEnabled(ExtensionContextMenuModel::UNINSTALL)); |
64 | 135 |
65 // Don't leave |policy_provider| dangling. | 136 // Don't leave |policy_provider| dangling. |
66 system->management_policy()->UnregisterAllProviders(); | 137 system->management_policy()->UnregisterAllProviders(); |
67 } | 138 } |
68 | 139 |
140 TEST_F(ExtensionContextMenuModelTest, ExtensionItemTest) { | |
141 InitializeEmptyExtensionService(); | |
142 scoped_refptr<Extension> extension = BuildExtension(kPageAction); | |
143 ASSERT_TRUE(extension.get()); | |
144 service_->AddExtension(extension.get()); | |
145 | |
146 // Create a Browser for the ExtensionContextMenuModel to use. | |
147 Browser::CreateParams params(profile_.get(), chrome::GetActiveDesktop()); | |
148 TestBrowserWindow test_window; | |
149 params.window = &test_window; | |
150 Browser browser(params); | |
151 | |
152 // Create a MenuManager for adding context items. | |
153 MenuManager* manager = static_cast<MenuManager*>( | |
154 (MenuManagerFactory::GetInstance()->SetTestingFactoryAndUse( | |
155 profile_.get(), &BuildInstanceForTesting))); | |
156 ASSERT_TRUE(manager); | |
157 | |
158 scoped_refptr<ExtensionContextMenuModel> menu( | |
159 new ExtensionContextMenuModel(extension.get(), &browser)); | |
160 | |
161 // There should be no extension items yet. | |
162 EXPECT_EQ(0, CountExtensionItems(menu)); | |
163 | |
164 // Add a browser action menu item for |extension| to |manager|. | |
165 AddContextItem(manager, extension.get(), MenuItem::BROWSER_ACTION); | |
166 RefreshMenu(menu); | |
167 | |
168 // Since |extension| has a page action, the browser action menu item should | |
169 // not be present. | |
170 EXPECT_EQ(0, CountExtensionItems(menu)); | |
171 | |
172 // Add a page action menu item and reset the context menu. | |
173 AddContextItem(manager, extension.get(), MenuItem::PAGE_ACTION); | |
174 RefreshMenu(menu); | |
175 | |
176 // The page action item should be present because |extension| has a page | |
177 // action. | |
178 EXPECT_EQ(1, CountExtensionItems(menu)); | |
179 | |
180 // Create more page action items to test top level menu item limitations. | |
181 for (int i = 0; i < api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT; ++i) | |
182 AddContextItem(manager, extension.get(), MenuItem::PAGE_ACTION); | |
183 RefreshMenu(menu); | |
184 | |
185 // The menu should only have a limited number of extension items, since they | |
186 // are all top level items, and we limit the number of top level extension | |
187 // items. | |
188 EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, | |
189 CountExtensionItems(menu)); | |
190 | |
191 AddContextItem(manager, extension.get(), MenuItem::PAGE_ACTION); | |
192 RefreshMenu(menu); | |
193 | |
194 // Adding another top level item should not increase the count. | |
195 EXPECT_EQ(api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT, | |
196 CountExtensionItems(menu)); | |
197 } | |
198 | |
69 } // namespace | 199 } // namespace |
70 } // namespace extensions | 200 } // namespace extensions |
OLD | NEW |