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/extension_service.h" | 7 #include "chrome/browser/extensions/extension_service.h" |
8 #include "chrome/browser/extensions/extension_service_test_base.h" | 8 #include "chrome/browser/extensions/extension_service_test_base.h" |
9 #include "chrome/browser/extensions/menu_manager.h" | |
10 #include "chrome/browser/extensions/menu_manager_factory.h" | |
9 #include "chrome/browser/ui/browser.h" | 11 #include "chrome/browser/ui/browser.h" |
10 #include "chrome/browser/ui/host_desktop.h" | 12 #include "chrome/browser/ui/host_desktop.h" |
13 #include "chrome/common/extensions/api/context_menus.h" | |
11 #include "chrome/test/base/test_browser_window.h" | 14 #include "chrome/test/base/test_browser_window.h" |
12 #include "chrome/test/base/testing_profile.h" | 15 #include "chrome/test/base/testing_profile.h" |
13 #include "extensions/browser/extension_system.h" | 16 #include "extensions/browser/extension_system.h" |
14 #include "extensions/browser/test_management_policy.h" | 17 #include "extensions/browser/test_management_policy.h" |
15 #include "extensions/common/extension_builder.h" | 18 #include "extensions/common/extension_builder.h" |
16 #include "extensions/common/value_builder.h" | 19 #include "extensions/common/value_builder.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
18 | 21 |
19 namespace extensions { | 22 namespace extensions { |
20 namespace { | |
21 | 23 |
22 class ExtensionContextMenuModelTest : public ExtensionServiceTestBase { | 24 class ExtensionContextMenuModelTest : public ExtensionServiceTestBase { |
25 public: | |
26 ExtensionContextMenuModelTest(); | |
27 | |
28 // Build an extension to pass to the menu constructor. It needs an | |
29 // ExtensionAction. | |
30 scoped_refptr<Extension> BuildExtension(); | |
31 | |
32 // Creates an extension menu item for |extension| with the given |context| | |
33 // and adds it to |manager|. Refreshes |model| to show new item. | |
34 void AddContextItemAndRefreshModel(MenuManager* manager, | |
35 Extension* extension, | |
36 MenuItem::Context context, | |
37 ExtensionContextMenuModel* model); | |
38 | |
39 // Reinitializes the given |model|. | |
40 void RefreshMenu(ExtensionContextMenuModel* model); | |
41 | |
42 // Returns the number of extension menu items that show up in |model|. | |
43 int CountExtensionItems(ExtensionContextMenuModel* model); | |
44 | |
45 // TestingFactoryFunction for setting up a MenuManager for testing. | |
46 static KeyedService* BuildMenuManagerForTesting( | |
Devlin
2014/07/30 21:32:57
May as well just have this in an anon namespace ra
| |
47 content::BrowserContext* context); | |
48 | |
49 private: | |
50 int cur_id_; | |
23 }; | 51 }; |
24 | 52 |
53 ExtensionContextMenuModelTest::ExtensionContextMenuModelTest() | |
54 : cur_id_(0) {} | |
55 | |
56 scoped_refptr<Extension> ExtensionContextMenuModelTest::BuildExtension() { | |
57 return ExtensionBuilder() | |
58 .SetManifest( | |
59 DictionaryBuilder() | |
60 .Set("name", "Page Action Extension") | |
61 .Set("version", "1") | |
62 .Set("manifest_version", 2) | |
63 .Set("page_action", | |
64 DictionaryBuilder().Set("default_title", "Hello"))) | |
65 .Build(); | |
66 } | |
67 | |
68 void ExtensionContextMenuModelTest::AddContextItemAndRefreshModel( | |
69 MenuManager* manager, | |
70 Extension* extension, | |
71 MenuItem::Context context, | |
72 ExtensionContextMenuModel* model) { | |
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(extension, new MenuItem(id, | |
79 "test", | |
80 false, // checked | |
81 true, // enabled | |
82 type, | |
83 contexts)); | |
84 RefreshMenu(model); | |
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::BuildMenuManagerForTesting( | |
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(); |
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(); | |
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(), &BuildMenuManagerForTesting))); | |
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 AddContextItemAndRefreshModel( | |
166 manager, extension.get(), MenuItem::BROWSER_ACTION, 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 AddContextItemAndRefreshModel( | |
174 manager, extension.get(), MenuItem::PAGE_ACTION, 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 AddContextItemAndRefreshModel( | |
183 manager, extension.get(), MenuItem::PAGE_ACTION, 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 AddContextItemAndRefreshModel( | |
192 manager, extension.get(), MenuItem::PAGE_ACTION, 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 |