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