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 3 // found in the LICENSE file. 4 5 #include <vector> 6 7 #include "base/files/scoped_temp_dir.h" 8 #include "base/json/json_reader.h" 9 #include "base/memory/scoped_vector.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/path_service.h" 12 #include "base/prefs/pref_service.h" 13 #include "base/strings/utf_string_conversions.h" 14 #include "base/values.h" 15 #include "chrome/browser/chrome_notification_types.h" 16 #include "chrome/browser/extensions/extension_system_factory.h" 17 #include "chrome/browser/extensions/menu_manager.h" 18 #include "chrome/browser/extensions/test_extension_prefs.h" 19 #include "chrome/browser/extensions/test_extension_system.h" 20 #include "chrome/browser/prefs/pref_service_syncable.h" 21 #include "chrome/common/chrome_paths.h" 22 #include "chrome/common/extensions/api/context_menus.h" 23 #include "chrome/test/base/testing_profile.h" 24 #include "content/public/browser/notification_service.h" 25 #include "content/public/common/context_menu_params.h" 26 #include "content/public/test/test_browser_thread.h" 27 #include "extensions/browser/event_router.h" 28 #include "extensions/browser/extension_registry.h" 29 #include "extensions/browser/extension_system.h" 30 #include "extensions/common/extension.h" 31 #include "testing/gmock/include/gmock/gmock.h" 32 #include "testing/gtest/include/gtest/gtest.h" 33 34 using content::BrowserThread; 35 using testing::_; 36 using testing::AtLeast; 37 using testing::DeleteArg; 38 using testing::InSequence; 39 using testing::Return; 40 using testing::SaveArg; 41 42 namespace extensions { 43 44 namespace context_menus = api::context_menus; 45 46 // Base class for tests. 47 class MenuManagerTest : public testing::Test { 48 public: 49 MenuManagerTest() 50 : ui_thread_(BrowserThread::UI, &message_loop_), 51 file_thread_(BrowserThread::FILE, &message_loop_), 52 profile_(new TestingProfile()), 53 manager_(profile_.get(), 54 ExtensionSystem::Get(profile_.get())->state_store()), 55 prefs_(message_loop_.message_loop_proxy().get()), 56 next_id_(1) {} 57 58 virtual void TearDown() OVERRIDE { 59 prefs_.pref_service()->CommitPendingWrite(); 60 message_loop_.RunUntilIdle(); 61 } 62 63 // Returns a test item. 64 MenuItem* CreateTestItem(Extension* extension, bool incognito = false) { 65 MenuItem::Type type = MenuItem::NORMAL; 66 MenuItem::ContextList contexts(MenuItem::ALL); 67 const MenuItem::ExtensionKey key(extension->id()); 68 MenuItem::Id id(incognito, key); 69 id.uid = next_id_++; 70 return new MenuItem(id, "test", false, true, type, contexts); 71 } 72 73 // Returns a test item with the given string ID. 74 MenuItem* CreateTestItemWithID(Extension* extension, 75 const std::string& string_id) { 76 MenuItem::Type type = MenuItem::NORMAL; 77 MenuItem::ContextList contexts(MenuItem::ALL); 78 const MenuItem::ExtensionKey key(extension->id()); 79 MenuItem::Id id(false, key); 80 id.string_uid = string_id; 81 return new MenuItem(id, "test", false, true, type, contexts); 82 } 83 84 // Creates and returns a test Extension. The caller does *not* own the return 85 // value. 86 Extension* AddExtension(const std::string& name) { 87 scoped_refptr<Extension> extension = prefs_.AddExtension(name); 88 extensions_.push_back(extension); 89 return extension.get(); 90 } 91 92 protected: 93 base::MessageLoopForUI message_loop_; 94 content::TestBrowserThread ui_thread_; 95 content::TestBrowserThread file_thread_; 96 scoped_ptr<TestingProfile> profile_; 97 98 MenuManager manager_; 99 ExtensionList extensions_; 100 TestExtensionPrefs prefs_; 101 int next_id_; 102 103 private: 104 DISALLOW_COPY_AND_ASSIGN(MenuManagerTest); 105 }; 106 107 // Tests adding, getting, and removing items. 108 TEST_F(MenuManagerTest, AddGetRemoveItems) { 109 Extension* extension = AddExtension("test"); 110 111 // Add a new item, make sure you can get it back. 112 MenuItem* item1 = CreateTestItem(extension); 113 ASSERT_TRUE(item1 != NULL); 114 ASSERT_TRUE(manager_.AddContextItem(extension, item1)); 115 ASSERT_EQ(item1, manager_.GetItemById(item1->id())); 116 const MenuItem::List* items = manager_.MenuItems(item1->id().extension_key); 117 ASSERT_EQ(1u, items->size()); 118 ASSERT_EQ(item1, items->at(0)); 119 120 // Add a second item, make sure it comes back too. 121 MenuItem* item2 = CreateTestItemWithID(extension, "id2"); 122 ASSERT_TRUE(manager_.AddContextItem(extension, item2)); 123 ASSERT_EQ(item2, manager_.GetItemById(item2->id())); 124 items = manager_.MenuItems(item2->id().extension_key); 125 ASSERT_EQ(2u, items->size()); 126 ASSERT_EQ(item1, items->at(0)); 127 ASSERT_EQ(item2, items->at(1)); 128 129 // Try adding item 3, then removing it. 130 MenuItem* item3 = CreateTestItem(extension); 131 MenuItem::Id id3 = item3->id(); 132 const MenuItem::ExtensionKey extension_key3(item3->id().extension_key); 133 ASSERT_TRUE(manager_.AddContextItem(extension, item3)); 134 ASSERT_EQ(item3, manager_.GetItemById(id3)); 135 ASSERT_EQ(3u, manager_.MenuItems(extension_key3)->size()); 136 ASSERT_TRUE(manager_.RemoveContextMenuItem(id3)); 137 ASSERT_EQ(NULL, manager_.GetItemById(id3)); 138 ASSERT_EQ(2u, manager_.MenuItems(extension_key3)->size()); 139 140 // Make sure removing a non-existent item returns false. 141 const MenuItem::ExtensionKey key(extension->id()); 142 MenuItem::Id id(false, key); 143 id.uid = id3.uid + 50; 144 ASSERT_FALSE(manager_.RemoveContextMenuItem(id)); 145 146 // Make sure adding an item with the same string ID returns false. 147 scoped_ptr<MenuItem> item2too(CreateTestItemWithID(extension, "id2")); 148 ASSERT_FALSE(manager_.AddContextItem(extension, item2too.get())); 149 150 // But the same string ID should not collide with another extension. 151 Extension* extension2 = AddExtension("test2"); 152 MenuItem* item2other = CreateTestItemWithID(extension2, "id2"); 153 ASSERT_TRUE(manager_.AddContextItem(extension2, item2other)); 154 } 155 156 // Test adding/removing child items. 157 TEST_F(MenuManagerTest, ChildFunctions) { 158 Extension* extension1 = AddExtension("1111"); 159 Extension* extension2 = AddExtension("2222"); 160 Extension* extension3 = AddExtension("3333"); 161 162 MenuItem* item1 = CreateTestItem(extension1); 163 MenuItem* item2 = CreateTestItem(extension2); 164 MenuItem* item2_child = CreateTestItemWithID(extension2, "2child"); 165 MenuItem* item2_grandchild = CreateTestItem(extension2); 166 167 // This third item we expect to fail inserting, so we use a scoped_ptr to make 168 // sure it gets deleted. 169 scoped_ptr<MenuItem> item3(CreateTestItem(extension3)); 170 171 // Add in the first two items. 172 ASSERT_TRUE(manager_.AddContextItem(extension1, item1)); 173 ASSERT_TRUE(manager_.AddContextItem(extension2, item2)); 174 175 MenuItem::Id id1 = item1->id(); 176 MenuItem::Id id2 = item2->id(); 177 178 // Try adding item3 as a child of item2 - this should fail because item3 has 179 // a different extension id. 180 ASSERT_FALSE(manager_.AddChildItem(id2, item3.get())); 181 182 // Add item2_child as a child of item2. 183 MenuItem::Id id2_child = item2_child->id(); 184 ASSERT_TRUE(manager_.AddChildItem(id2, item2_child)); 185 ASSERT_EQ(1, item2->child_count()); 186 ASSERT_EQ(0, item1->child_count()); 187 ASSERT_EQ(item2_child, manager_.GetItemById(id2_child)); 188 189 ASSERT_EQ(1u, manager_.MenuItems(item1->id().extension_key)->size()); 190 ASSERT_EQ(item1, manager_.MenuItems(item1->id().extension_key)->at(0)); 191 192 // Add item2_grandchild as a child of item2_child, then remove it. 193 MenuItem::Id id2_grandchild = item2_grandchild->id(); 194 ASSERT_TRUE(manager_.AddChildItem(id2_child, item2_grandchild)); 195 ASSERT_EQ(1, item2->child_count()); 196 ASSERT_EQ(1, item2_child->child_count()); 197 ASSERT_TRUE(manager_.RemoveContextMenuItem(id2_grandchild)); 198 199 // We should only get 1 thing back when asking for item2's extension id, since 200 // it has a child item. 201 ASSERT_EQ(1u, manager_.MenuItems(item2->id().extension_key)->size()); 202 ASSERT_EQ(item2, manager_.MenuItems(item2->id().extension_key)->at(0)); 203 204 // Remove child2_item. 205 ASSERT_TRUE(manager_.RemoveContextMenuItem(id2_child)); 206 ASSERT_EQ(1u, manager_.MenuItems(item2->id().extension_key)->size()); 207 ASSERT_EQ(item2, manager_.MenuItems(item2->id().extension_key)->at(0)); 208 ASSERT_EQ(0, item2->child_count()); 209 } 210 211 TEST_F(MenuManagerTest, PopulateFromValue) { 212 Extension* extension = AddExtension("test"); 213 214 bool incognito = true; 215 int type = MenuItem::CHECKBOX; 216 std::string title("TITLE"); 217 bool checked = true; 218 bool enabled = true; 219 MenuItem::ContextList contexts; 220 contexts.Add(MenuItem::PAGE); 221 contexts.Add(MenuItem::SELECTION); 222 int contexts_value = 0; 223 ASSERT_TRUE(contexts.ToValue()->GetAsInteger(&contexts_value)); 224 225 base::ListValue* document_url_patterns(new base::ListValue()); 226 document_url_patterns->Append( 227 new base::StringValue("http://www.google.com/*")); 228 document_url_patterns->Append( 229 new base::StringValue("http://www.reddit.com/*")); 230 231 base::ListValue* target_url_patterns(new base::ListValue()); 232 target_url_patterns->Append( 233 new base::StringValue("http://www.yahoo.com/*")); 234 target_url_patterns->Append( 235 new base::StringValue("http://www.facebook.com/*")); 236 237 base::DictionaryValue value; 238 value.SetBoolean("incognito", incognito); 239 value.SetString("string_uid", std::string()); 240 value.SetInteger("type", type); 241 value.SetString("title", title); 242 value.SetBoolean("checked", checked); 243 value.SetBoolean("enabled", enabled); 244 value.SetInteger("contexts", contexts_value); 245 value.Set("document_url_patterns", document_url_patterns); 246 value.Set("target_url_patterns", target_url_patterns); 247 248 std::string error; 249 scoped_ptr<MenuItem> item(MenuItem::Populate(extension->id(), value, &error)); 250 ASSERT_TRUE(item.get()); 251 252 EXPECT_EQ(extension->id(), item->extension_id()); 253 EXPECT_EQ(incognito, item->incognito()); 254 EXPECT_EQ(title, item->title()); 255 EXPECT_EQ(checked, item->checked()); 256 EXPECT_EQ(item->checked(), item->checked()); 257 EXPECT_EQ(enabled, item->enabled()); 258 EXPECT_EQ(contexts, item->contexts()); 259 260 URLPatternSet document_url_pattern_set; 261 document_url_pattern_set.Populate(*document_url_patterns, 262 URLPattern::SCHEME_ALL, 263 true, 264 &error); 265 EXPECT_EQ(document_url_pattern_set, item->document_url_patterns()); 266 267 URLPatternSet target_url_pattern_set; 268 target_url_pattern_set.Populate(*target_url_patterns, 269 URLPattern::SCHEME_ALL, 270 true, 271 &error); 272 EXPECT_EQ(target_url_pattern_set, item->target_url_patterns()); 273 } 274 275 // Tests that deleting a parent properly removes descendants. 276 TEST_F(MenuManagerTest, DeleteParent) { 277 Extension* extension = AddExtension("1111"); 278 279 // Set up 5 items to add. 280 MenuItem* item1 = CreateTestItem(extension); 281 MenuItem* item2 = CreateTestItem(extension); 282 MenuItem* item3 = CreateTestItemWithID(extension, "id3"); 283 MenuItem* item4 = CreateTestItemWithID(extension, "id4"); 284 MenuItem* item5 = CreateTestItem(extension); 285 MenuItem* item6 = CreateTestItem(extension); 286 MenuItem::Id item1_id = item1->id(); 287 MenuItem::Id item2_id = item2->id(); 288 MenuItem::Id item3_id = item3->id(); 289 MenuItem::Id item4_id = item4->id(); 290 MenuItem::Id item5_id = item5->id(); 291 MenuItem::Id item6_id = item6->id(); 292 const MenuItem::ExtensionKey key(extension->id()); 293 294 // Add the items in the hierarchy 295 // item1 -> item2 -> item3 -> item4 -> item5 -> item6. 296 ASSERT_TRUE(manager_.AddContextItem(extension, item1)); 297 ASSERT_TRUE(manager_.AddChildItem(item1_id, item2)); 298 ASSERT_TRUE(manager_.AddChildItem(item2_id, item3)); 299 ASSERT_TRUE(manager_.AddChildItem(item3_id, item4)); 300 ASSERT_TRUE(manager_.AddChildItem(item4_id, item5)); 301 ASSERT_TRUE(manager_.AddChildItem(item5_id, item6)); 302 ASSERT_EQ(item1, manager_.GetItemById(item1_id)); 303 ASSERT_EQ(item2, manager_.GetItemById(item2_id)); 304 ASSERT_EQ(item3, manager_.GetItemById(item3_id)); 305 ASSERT_EQ(item4, manager_.GetItemById(item4_id)); 306 ASSERT_EQ(item5, manager_.GetItemById(item5_id)); 307 ASSERT_EQ(item6, manager_.GetItemById(item6_id)); 308 ASSERT_EQ(1u, manager_.MenuItems(key)->size()); 309 ASSERT_EQ(6u, manager_.items_by_id_.size()); 310 311 // Remove item6 (a leaf node). 312 ASSERT_TRUE(manager_.RemoveContextMenuItem(item6_id)); 313 ASSERT_EQ(item1, manager_.GetItemById(item1_id)); 314 ASSERT_EQ(item2, manager_.GetItemById(item2_id)); 315 ASSERT_EQ(item3, manager_.GetItemById(item3_id)); 316 ASSERT_EQ(item4, manager_.GetItemById(item4_id)); 317 ASSERT_EQ(item5, manager_.GetItemById(item5_id)); 318 ASSERT_EQ(NULL, manager_.GetItemById(item6_id)); 319 ASSERT_EQ(1u, manager_.MenuItems(key)->size()); 320 ASSERT_EQ(5u, manager_.items_by_id_.size()); 321 322 // Remove item4 and make sure item5 is gone as well. 323 ASSERT_TRUE(manager_.RemoveContextMenuItem(item4_id)); 324 ASSERT_EQ(item1, manager_.GetItemById(item1_id)); 325 ASSERT_EQ(item2, manager_.GetItemById(item2_id)); 326 ASSERT_EQ(item3, manager_.GetItemById(item3_id)); 327 ASSERT_EQ(NULL, manager_.GetItemById(item4_id)); 328 ASSERT_EQ(NULL, manager_.GetItemById(item5_id)); 329 ASSERT_EQ(1u, manager_.MenuItems(key)->size()); 330 ASSERT_EQ(3u, manager_.items_by_id_.size()); 331 332 // Now remove item1 and make sure item2 and item3 are gone as well. 333 ASSERT_TRUE(manager_.RemoveContextMenuItem(item1_id)); 334 ASSERT_EQ(NULL, manager_.MenuItems(key)); 335 ASSERT_EQ(0u, manager_.items_by_id_.size()); 336 ASSERT_EQ(NULL, manager_.GetItemById(item1_id)); 337 ASSERT_EQ(NULL, manager_.GetItemById(item2_id)); 338 ASSERT_EQ(NULL, manager_.GetItemById(item3_id)); 339 } 340 341 // Tests changing parents. 342 TEST_F(MenuManagerTest, ChangeParent) { 343 Extension* extension1 = AddExtension("1111"); 344 345 // First create two items and add them both to the manager. 346 MenuItem* item1 = CreateTestItem(extension1); 347 MenuItem* item2 = CreateTestItem(extension1); 348 349 ASSERT_TRUE(manager_.AddContextItem(extension1, item1)); 350 ASSERT_TRUE(manager_.AddContextItem(extension1, item2)); 351 352 const MenuItem::List* items = manager_.MenuItems(item1->id().extension_key); 353 ASSERT_EQ(2u, items->size()); 354 ASSERT_EQ(item1, items->at(0)); 355 ASSERT_EQ(item2, items->at(1)); 356 357 // Now create a third item, initially add it as a child of item1, then move 358 // it to be a child of item2. 359 MenuItem* item3 = CreateTestItem(extension1); 360 361 ASSERT_TRUE(manager_.AddChildItem(item1->id(), item3)); 362 ASSERT_EQ(1, item1->child_count()); 363 ASSERT_EQ(item3, item1->children()[0]); 364 365 ASSERT_TRUE(manager_.ChangeParent(item3->id(), &item2->id())); 366 ASSERT_EQ(0, item1->child_count()); 367 ASSERT_EQ(1, item2->child_count()); 368 ASSERT_EQ(item3, item2->children()[0]); 369 370 // Move item2 to be a child of item1. 371 ASSERT_TRUE(manager_.ChangeParent(item2->id(), &item1->id())); 372 ASSERT_EQ(1, item1->child_count()); 373 ASSERT_EQ(item2, item1->children()[0]); 374 ASSERT_EQ(1, item2->child_count()); 375 ASSERT_EQ(item3, item2->children()[0]); 376 377 // Since item2 was a top-level item but is no longer, we should only have 1 378 // top-level item. 379 items = manager_.MenuItems(item1->id().extension_key); 380 ASSERT_EQ(1u, items->size()); 381 ASSERT_EQ(item1, items->at(0)); 382 383 // Move item3 back to being a child of item1, so it's now a sibling of item2. 384 ASSERT_TRUE(manager_.ChangeParent(item3->id(), &item1->id())); 385 ASSERT_EQ(2, item1->child_count()); 386 ASSERT_EQ(item2, item1->children()[0]); 387 ASSERT_EQ(item3, item1->children()[1]); 388 389 // Try switching item3 to be the parent of item1 - this should fail. 390 ASSERT_FALSE(manager_.ChangeParent(item1->id(), &item3->id())); 391 ASSERT_EQ(0, item3->child_count()); 392 ASSERT_EQ(2, item1->child_count()); 393 ASSERT_EQ(item2, item1->children()[0]); 394 ASSERT_EQ(item3, item1->children()[1]); 395 items = manager_.MenuItems(item1->id().extension_key); 396 ASSERT_EQ(1u, items->size()); 397 ASSERT_EQ(item1, items->at(0)); 398 399 // Move item2 to be a top-level item. 400 ASSERT_TRUE(manager_.ChangeParent(item2->id(), NULL)); 401 items = manager_.MenuItems(item1->id().extension_key); 402 ASSERT_EQ(2u, items->size()); 403 ASSERT_EQ(item1, items->at(0)); 404 ASSERT_EQ(item2, items->at(1)); 405 ASSERT_EQ(1, item1->child_count()); 406 ASSERT_EQ(item3, item1->children()[0]); 407 408 // Make sure you can't move a node to be a child of another extension's item. 409 Extension* extension2 = AddExtension("2222"); 410 MenuItem* item4 = CreateTestItem(extension2); 411 ASSERT_TRUE(manager_.AddContextItem(extension2, item4)); 412 ASSERT_FALSE(manager_.ChangeParent(item4->id(), &item1->id())); 413 ASSERT_FALSE(manager_.ChangeParent(item1->id(), &item4->id())); 414 415 // Make sure you can't make an item be it's own parent. 416 ASSERT_FALSE(manager_.ChangeParent(item1->id(), &item1->id())); 417 } 418 419 // Tests that we properly remove an extension's menu item when that extension is 420 // unloaded. 421 TEST_F(MenuManagerTest, ExtensionUnloadRemovesMenuItems) { 422 content::NotificationService* notifier = 423 content::NotificationService::current(); 424 ASSERT_TRUE(notifier != NULL); 425 426 // Create a test extension. 427 Extension* extension1 = AddExtension("1111"); 428 429 // Create an MenuItem and put it into the manager. 430 MenuItem* item1 = CreateTestItem(extension1); 431 MenuItem::Id id1 = item1->id(); 432 ASSERT_EQ(extension1->id(), item1->extension_id()); 433 ASSERT_TRUE(manager_.AddContextItem(extension1, item1)); 434 ASSERT_EQ( 435 1u, manager_.MenuItems(MenuItem::ExtensionKey(extension1->id()))->size()); 436 437 // Create a menu item with a different extension id and add it to the manager. 438 Extension* extension2 = AddExtension("2222"); 439 MenuItem* item2 = CreateTestItem(extension2); 440 ASSERT_NE(item1->extension_id(), item2->extension_id()); 441 ASSERT_TRUE(manager_.AddContextItem(extension2, item2)); 442 443 // Notify that the extension was unloaded, and make sure the right item is 444 // gone. 445 ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get()); 446 registry->TriggerOnUnloaded(extension1, 447 UnloadedExtensionInfo::REASON_DISABLE); 448 449 ASSERT_EQ(NULL, manager_.MenuItems(MenuItem::ExtensionKey(extension1->id()))); 450 ASSERT_EQ( 451 1u, manager_.MenuItems(MenuItem::ExtensionKey(extension2->id()))->size()); 452 ASSERT_TRUE(manager_.GetItemById(id1) == NULL); 453 ASSERT_TRUE(manager_.GetItemById(item2->id()) != NULL); 454 } 455 456 // A mock message service for tests of MenuManager::ExecuteCommand. 457 class MockEventRouter : public EventRouter { 458 public: 459 explicit MockEventRouter(Profile* profile) : EventRouter(profile, NULL) {} 460 461 MOCK_METHOD6(DispatchEventToExtensionMock, 462 void(const std::string& extension_id, 463 const std::string& event_name, 464 base::ListValue* event_args, 465 content::BrowserContext* source_context, 466 const GURL& event_url, 467 EventRouter::UserGestureState state)); 468 469 virtual void DispatchEventToExtension(const std::string& extension_id, 470 scoped_ptr<Event> event) { 471 DispatchEventToExtensionMock(extension_id, 472 event->event_name, 473 event->event_args.release(), 474 event->restrict_to_browser_context, 475 event->event_url, 476 event->user_gesture); 477 } 478 479 private: 480 DISALLOW_COPY_AND_ASSIGN(MockEventRouter); 481 }; 482 483 // A mock ExtensionSystem to serve our MockEventRouter. 484 class MockExtensionSystem : public TestExtensionSystem { 485 public: 486 explicit MockExtensionSystem(Profile* profile) 487 : TestExtensionSystem(profile) {} 488 489 virtual EventRouter* event_router() OVERRIDE { 490 if (!mock_event_router_) 491 mock_event_router_.reset(new MockEventRouter(profile_)); 492 return mock_event_router_.get(); 493 } 494 495 private: 496 scoped_ptr<MockEventRouter> mock_event_router_; 497 498 DISALLOW_COPY_AND_ASSIGN(MockExtensionSystem); 499 }; 500 501 KeyedService* BuildMockExtensionSystem(content::BrowserContext* profile) { 502 return new MockExtensionSystem(static_cast<Profile*>(profile)); 503 } 504 505 // Tests the RemoveAll functionality. 506 TEST_F(MenuManagerTest, RemoveAll) { 507 // Try removing all items for an extension id that doesn't have any items. 508 manager_.RemoveAllContextItems(MenuItem::ExtensionKey("CCCC")); 509 510 // Add 2 top-level and one child item for extension 1. 511 Extension* extension1 = AddExtension("1111"); 512 MenuItem* item1 = CreateTestItem(extension1); 513 MenuItem* item2 = CreateTestItem(extension1); 514 MenuItem* item3 = CreateTestItem(extension1); 515 ASSERT_TRUE(manager_.AddContextItem(extension1, item1)); 516 ASSERT_TRUE(manager_.AddContextItem(extension1, item2)); 517 ASSERT_TRUE(manager_.AddChildItem(item1->id(), item3)); 518 519 // Add one top-level item for extension 2. 520 Extension* extension2 = AddExtension("2222"); 521 MenuItem* item4 = CreateTestItem(extension2); 522 ASSERT_TRUE(manager_.AddContextItem(extension2, item4)); 523 524 const MenuItem::ExtensionKey key1(extension1->id()); 525 const MenuItem::ExtensionKey key2(extension2->id()); 526 EXPECT_EQ(2u, manager_.MenuItems(key1)->size()); 527 EXPECT_EQ(1u, manager_.MenuItems(key2)->size()); 528 529 // Remove extension2's item. 530 manager_.RemoveAllContextItems(key2); 531 EXPECT_EQ(2u, manager_.MenuItems(key1)->size()); 532 EXPECT_EQ(NULL, manager_.MenuItems(key2)); 533 534 // Remove extension1's items. 535 manager_.RemoveAllContextItems(key1); 536 EXPECT_EQ(NULL, manager_.MenuItems(key1)); 537 } 538 539 // Tests that removing all items one-by-one doesn't leave an entry around. 540 TEST_F(MenuManagerTest, RemoveOneByOne) { 541 // Add 2 test items. 542 Extension* extension1 = AddExtension("1111"); 543 MenuItem* item1 = CreateTestItem(extension1); 544 MenuItem* item2 = CreateTestItem(extension1); 545 MenuItem* item3 = CreateTestItemWithID(extension1, "id3"); 546 ASSERT_TRUE(manager_.AddContextItem(extension1, item1)); 547 ASSERT_TRUE(manager_.AddContextItem(extension1, item2)); 548 ASSERT_TRUE(manager_.AddContextItem(extension1, item3)); 549 550 ASSERT_FALSE(manager_.context_items_.empty()); 551 552 manager_.RemoveContextMenuItem(item3->id()); 553 manager_.RemoveContextMenuItem(item1->id()); 554 manager_.RemoveContextMenuItem(item2->id()); 555 556 ASSERT_TRUE(manager_.context_items_.empty()); 557 } 558 559 TEST_F(MenuManagerTest, ExecuteCommand) { 560 TestingProfile profile; 561 562 MockExtensionSystem* mock_extension_system = 563 static_cast<MockExtensionSystem*>(ExtensionSystemFactory::GetInstance()-> 564 SetTestingFactoryAndUse(&profile, &BuildMockExtensionSystem)); 565 MockEventRouter* mock_event_router = 566 static_cast<MockEventRouter*>(mock_extension_system->event_router()); 567 568 content::ContextMenuParams params; 569 params.media_type = blink::WebContextMenuData::MediaTypeImage; 570 params.src_url = GURL("http://foo.bar/image.png"); 571 params.page_url = GURL("http://foo.bar"); 572 params.selection_text = base::ASCIIToUTF16("Hello World"); 573 params.is_editable = false; 574 575 Extension* extension = AddExtension("test"); 576 MenuItem* parent = CreateTestItem(extension); 577 MenuItem* item = CreateTestItem(extension); 578 MenuItem::Id parent_id = parent->id(); 579 MenuItem::Id id = item->id(); 580 ASSERT_TRUE(manager_.AddContextItem(extension, parent)); 581 ASSERT_TRUE(manager_.AddChildItem(parent->id(), item)); 582 583 // Use the magic of googlemock to save a parameter to our mock's 584 // DispatchEventToExtension method into event_args. 585 base::ListValue* list = NULL; 586 { 587 InSequence s; 588 EXPECT_CALL(*mock_event_router, 589 DispatchEventToExtensionMock(item->extension_id(), 590 MenuManager::kOnContextMenus, 591 _, 592 &profile, 593 GURL(), 594 EventRouter::USER_GESTURE_ENABLED)) 595 .Times(1) 596 .WillOnce(SaveArg<2>(&list)); 597 EXPECT_CALL(*mock_event_router, 598 DispatchEventToExtensionMock( 599 item->extension_id(), 600 context_menus::OnClicked::kEventName, 601 _, 602 &profile, 603 GURL(), 604 EventRouter::USER_GESTURE_ENABLED)) 605 .Times(1) 606 .WillOnce(DeleteArg<2>()); 607 } 608 manager_.ExecuteCommand(&profile, NULL /* web_contents */, params, id); 609 610 ASSERT_EQ(2u, list->GetSize()); 611 612 base::DictionaryValue* info; 613 ASSERT_TRUE(list->GetDictionary(0, &info)); 614 615 int tmp_id = 0; 616 ASSERT_TRUE(info->GetInteger("menuItemId", &tmp_id)); 617 ASSERT_EQ(id.uid, tmp_id); 618 ASSERT_TRUE(info->GetInteger("parentMenuItemId", &tmp_id)); 619 ASSERT_EQ(parent_id.uid, tmp_id); 620 621 std::string tmp; 622 ASSERT_TRUE(info->GetString("mediaType", &tmp)); 623 ASSERT_EQ("image", tmp); 624 ASSERT_TRUE(info->GetString("srcUrl", &tmp)); 625 ASSERT_EQ(params.src_url.spec(), tmp); 626 ASSERT_TRUE(info->GetString("pageUrl", &tmp)); 627 ASSERT_EQ(params.page_url.spec(), tmp); 628 629 base::string16 tmp16; 630 ASSERT_TRUE(info->GetString("selectionText", &tmp16)); 631 ASSERT_EQ(params.selection_text, tmp16); 632 633 bool bool_tmp = true; 634 ASSERT_TRUE(info->GetBoolean("editable", &bool_tmp)); 635 ASSERT_EQ(params.is_editable, bool_tmp); 636 637 delete list; 638 } 639 640 // Test that there is always only one radio item selected. 641 TEST_F(MenuManagerTest, SanitizeRadioButtons) { 642 Extension* extension = AddExtension("test"); 643 644 // A single unchecked item should get checked 645 MenuItem* item1 = CreateTestItem(extension); 646 647 item1->set_type(MenuItem::RADIO); 648 item1->SetChecked(false); 649 ASSERT_FALSE(item1->checked()); 650 manager_.AddContextItem(extension, item1); 651 ASSERT_TRUE(item1->checked()); 652 653 // In a run of two unchecked items, the first should get selected. 654 item1->SetChecked(false); 655 MenuItem* item2 = CreateTestItem(extension); 656 item2->set_type(MenuItem::RADIO); 657 item2->SetChecked(false); 658 ASSERT_FALSE(item1->checked()); 659 ASSERT_FALSE(item2->checked()); 660 manager_.AddContextItem(extension, item2); 661 ASSERT_TRUE(item1->checked()); 662 ASSERT_FALSE(item2->checked()); 663 664 // If multiple items are checked, only the last item should get checked. 665 item1->SetChecked(true); 666 item2->SetChecked(true); 667 ASSERT_TRUE(item1->checked()); 668 ASSERT_TRUE(item2->checked()); 669 manager_.ItemUpdated(item1->id()); 670 ASSERT_FALSE(item1->checked()); 671 ASSERT_TRUE(item2->checked()); 672 673 // If the checked item is removed, the new first item should get checked. 674 item1->SetChecked(false); 675 item2->SetChecked(true); 676 ASSERT_FALSE(item1->checked()); 677 ASSERT_TRUE(item2->checked()); 678 manager_.RemoveContextMenuItem(item2->id()); 679 item2 = NULL; 680 ASSERT_TRUE(item1->checked()); 681 682 // If a checked item is added to a run that already has a checked item, 683 // then the new item should get checked. 684 item1->SetChecked(true); 685 MenuItem* new_item = CreateTestItem(extension); 686 new_item->set_type(MenuItem::RADIO); 687 new_item->SetChecked(true); 688 ASSERT_TRUE(item1->checked()); 689 ASSERT_TRUE(new_item->checked()); 690 manager_.AddContextItem(extension, new_item); 691 ASSERT_FALSE(item1->checked()); 692 ASSERT_TRUE(new_item->checked()); 693 // Make sure that children are checked as well. 694 MenuItem* parent = CreateTestItem(extension); 695 manager_.AddContextItem(extension, parent); 696 MenuItem* child1 = CreateTestItem(extension); 697 child1->set_type(MenuItem::RADIO); 698 child1->SetChecked(false); 699 MenuItem* child2 = CreateTestItem(extension); 700 child2->set_type(MenuItem::RADIO); 701 child2->SetChecked(true); 702 ASSERT_FALSE(child1->checked()); 703 ASSERT_TRUE(child2->checked()); 704 705 manager_.AddChildItem(parent->id(), child1); 706 ASSERT_TRUE(child1->checked()); 707 708 manager_.AddChildItem(parent->id(), child2); 709 ASSERT_FALSE(child1->checked()); 710 ASSERT_TRUE(child2->checked()); 711 712 // Removing the checked item from the children should cause the 713 // remaining child to be checked. 714 manager_.RemoveContextMenuItem(child2->id()); 715 child2 = NULL; 716 ASSERT_TRUE(child1->checked()); 717 718 // This should NOT cause |new_item| to be deseleted because 719 // |parent| will be seperating the two runs of radio items. 720 manager_.ChangeParent(child1->id(), NULL); 721 ASSERT_TRUE(new_item->checked()); 722 ASSERT_TRUE(child1->checked()); 723 724 // Removing |parent| should cause only |child1| to be selected. 725 manager_.RemoveContextMenuItem(parent->id()); 726 parent = NULL; 727 ASSERT_FALSE(new_item->checked()); 728 ASSERT_TRUE(child1->checked()); 729 } 730 731 // Tests the RemoveAllIncognitoContextItems functionality. 732 TEST_F(MenuManagerTest, RemoveAllIncognito) { 733 Extension* extension1 = AddExtension("1111"); 734 // Add 2 top-level and one child item for extension 1 735 // with incognito 'true'. 736 MenuItem* item1 = CreateTestItem(extension1, true); 737 MenuItem* item2 = CreateTestItem(extension1, true); 738 MenuItem* item3 = CreateTestItem(extension1, true); 739 ASSERT_TRUE(manager_.AddContextItem(extension1, item1)); 740 ASSERT_TRUE(manager_.AddContextItem(extension1, item2)); 741 ASSERT_TRUE(manager_.AddChildItem(item1->id(), item3)); 742 743 // Add 2 top-level and one child item for extension 1 744 // with incognito 'false'. 745 MenuItem* item4 = CreateTestItem(extension1); 746 MenuItem* item5 = CreateTestItem(extension1); 747 MenuItem* item6 = CreateTestItem(extension1); 748 ASSERT_TRUE(manager_.AddContextItem(extension1, item4)); 749 ASSERT_TRUE(manager_.AddContextItem(extension1, item5)); 750 ASSERT_TRUE(manager_.AddChildItem(item4->id(), item6)); 751 752 // Add one top-level item for extension 2. 753 Extension* extension2 = AddExtension("2222"); 754 MenuItem* item7 = CreateTestItem(extension2); 755 ASSERT_TRUE(manager_.AddContextItem(extension2, item7)); 756 757 const MenuItem::ExtensionKey key1(extension1->id()); 758 const MenuItem::ExtensionKey key2(extension2->id()); 759 EXPECT_EQ(4u, manager_.MenuItems(key1)->size()); 760 EXPECT_EQ(1u, manager_.MenuItems(key2)->size()); 761 762 // Remove all context menu items with incognito true. 763 manager_.RemoveAllIncognitoContextItems(); 764 EXPECT_EQ(2u, manager_.MenuItems(key1)->size()); 765 EXPECT_EQ(1u, manager_.MenuItems(key2)->size()); 766 } 767 768 } // namespace extensions 769