chrome/browser/extensions/menu_manager_unittest.cc

   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 namespace {
 457
 458 // A mock message service for tests of MenuManager::ExecuteCommand.
 459 class MockEventRouter : public EventRouter {
 460  public:
 461   explicit MockEventRouter(Profile* profile) : EventRouter(profile, NULL) {}
 462
 463   MOCK_METHOD6(DispatchEventToExtensionMock,
 464                void(const std::string& extension_id,
 465                     const std::string& event_name,
 466                     base::ListValue* event_args,
 467                     content::BrowserContext* source_context,
 468                     const GURL& event_url,
 469                     EventRouter::UserGestureState state));
 470
 471   virtual void DispatchEventToExtension(const std::string& extension_id,
 472                                         scoped_ptr<Event> event) {
 473     DispatchEventToExtensionMock(extension_id,
 474                                  event->event_name,
 475                                  event->event_args.release(),
 476                                  event->restrict_to_browser_context,
 477                                  event->event_url,
 478                                  event->user_gesture);
 479   }
 480
 481  private:
 482   DISALLOW_COPY_AND_ASSIGN(MockEventRouter);
 483 };
 484
 485 // A mock ExtensionSystem to serve our MockEventRouter.
 486 class MockExtensionSystem : public TestExtensionSystem {
 487  public:
 488   explicit MockExtensionSystem(Profile* profile)
 489       : TestExtensionSystem(profile) {}
 490
 491   EventRouter* event_router() override {
 492     if (!mock_event_router_)
 493       mock_event_router_.reset(new MockEventRouter(profile_));
 494     return mock_event_router_.get();
 495   }
 496
 497  private:
 498   scoped_ptr<MockEventRouter> mock_event_router_;
 499
 500   DISALLOW_COPY_AND_ASSIGN(MockExtensionSystem);
 501 };
 502
 503 KeyedService* BuildMockExtensionSystem(content::BrowserContext* profile) {
 504   return new MockExtensionSystem(static_cast<Profile*>(profile));
 505 }
 506
 507 }  // namespace
 508
 509 // Tests the RemoveAll functionality.
 510 TEST_F(MenuManagerTest, RemoveAll) {
 511   // Try removing all items for an extension id that doesn't have any items.
 512   manager_.RemoveAllContextItems(MenuItem::ExtensionKey("CCCC"));
 513
 514   // Add 2 top-level and one child item for extension 1.
 515   Extension* extension1 = AddExtension("1111");
 516   MenuItem* item1 = CreateTestItem(extension1);
 517   MenuItem* item2 = CreateTestItem(extension1);
 518   MenuItem* item3 = CreateTestItem(extension1);
 519   ASSERT_TRUE(manager_.AddContextItem(extension1, item1));
 520   ASSERT_TRUE(manager_.AddContextItem(extension1, item2));
 521   ASSERT_TRUE(manager_.AddChildItem(item1->id(), item3));
 522
 523   // Add one top-level item for extension 2.
 524   Extension* extension2 = AddExtension("2222");
 525   MenuItem* item4 = CreateTestItem(extension2);
 526   ASSERT_TRUE(manager_.AddContextItem(extension2, item4));
 527
 528   const MenuItem::ExtensionKey key1(extension1->id());
 529   const MenuItem::ExtensionKey key2(extension2->id());
 530   EXPECT_EQ(2u, manager_.MenuItems(key1)->size());
 531   EXPECT_EQ(1u, manager_.MenuItems(key2)->size());
 532
 533   // Remove extension2's item.
 534   manager_.RemoveAllContextItems(key2);
 535   EXPECT_EQ(2u, manager_.MenuItems(key1)->size());
 536   EXPECT_EQ(NULL, manager_.MenuItems(key2));
 537
 538   // Remove extension1's items.
 539   manager_.RemoveAllContextItems(key1);
 540   EXPECT_EQ(NULL, manager_.MenuItems(key1));
 541 }
 542
 543 // Tests that removing all items one-by-one doesn't leave an entry around.
 544 TEST_F(MenuManagerTest, RemoveOneByOne) {
 545   // Add 2 test items.
 546   Extension* extension1 = AddExtension("1111");
 547   MenuItem* item1 = CreateTestItem(extension1);
 548   MenuItem* item2 = CreateTestItem(extension1);
 549   MenuItem* item3 = CreateTestItemWithID(extension1, "id3");
 550   ASSERT_TRUE(manager_.AddContextItem(extension1, item1));
 551   ASSERT_TRUE(manager_.AddContextItem(extension1, item2));
 552   ASSERT_TRUE(manager_.AddContextItem(extension1, item3));
 553
 554   ASSERT_FALSE(manager_.context_items_.empty());
 555
 556   manager_.RemoveContextMenuItem(item3->id());
 557   manager_.RemoveContextMenuItem(item1->id());
 558   manager_.RemoveContextMenuItem(item2->id());
 559
 560   ASSERT_TRUE(manager_.context_items_.empty());
 561 }
 562
 563 TEST_F(MenuManagerTest, ExecuteCommand) {
 564   TestingProfile profile;
 565
 566   MockExtensionSystem* mock_extension_system =
 567       static_cast<MockExtensionSystem*>(ExtensionSystemFactory::GetInstance()->
 568           SetTestingFactoryAndUse(&profile, &BuildMockExtensionSystem));
 569   MockEventRouter* mock_event_router =
 570       static_cast<MockEventRouter*>(mock_extension_system->event_router());
 571
 572   content::ContextMenuParams params;
 573   params.media_type = blink::WebContextMenuData::MediaTypeImage;
 574   params.src_url = GURL("http://foo.bar/image.png");
 575   params.page_url = GURL("http://foo.bar");
 576   params.selection_text = base::ASCIIToUTF16("Hello World");
 577   params.is_editable = false;
 578
 579   Extension* extension = AddExtension("test");
 580   MenuItem* parent = CreateTestItem(extension);
 581   MenuItem* item = CreateTestItem(extension);
 582   MenuItem::Id parent_id = parent->id();
 583   MenuItem::Id id = item->id();
 584   ASSERT_TRUE(manager_.AddContextItem(extension, parent));
 585   ASSERT_TRUE(manager_.AddChildItem(parent->id(), item));
 586
 587   // Use the magic of googlemock to save a parameter to our mock's
 588   // DispatchEventToExtension method into event_args.
 589   base::ListValue* list = NULL;
 590   {
 591     InSequence s;
 592     EXPECT_CALL(*mock_event_router,
 593                 DispatchEventToExtensionMock(item->extension_id(),
 594                                              MenuManager::kOnContextMenus,
 595                                              _,
 596                                              &profile,
 597                                              GURL(),
 598                                              EventRouter::USER_GESTURE_ENABLED))
 599         .Times(1)
 600         .WillOnce(SaveArg<2>(&list));
 601     EXPECT_CALL(*mock_event_router,
 602               DispatchEventToExtensionMock(
 603                   item->extension_id(),
 604                   context_menus::OnClicked::kEventName,
 605                   _,
 606                   &profile,
 607                   GURL(),
 608                   EventRouter::USER_GESTURE_ENABLED))
 609       .Times(1)
 610       .WillOnce(DeleteArg<2>());
 611   }
 612   manager_.ExecuteCommand(&profile, NULL /* web_contents */, params, id);
 613
 614   ASSERT_EQ(2u, list->GetSize());
 615
 616   base::DictionaryValue* info;
 617   ASSERT_TRUE(list->GetDictionary(0, &info));
 618
 619   int tmp_id = 0;
 620   ASSERT_TRUE(info->GetInteger("menuItemId", &tmp_id));
 621   ASSERT_EQ(id.uid, tmp_id);
 622   ASSERT_TRUE(info->GetInteger("parentMenuItemId", &tmp_id));
 623   ASSERT_EQ(parent_id.uid, tmp_id);
 624
 625   std::string tmp;
 626   ASSERT_TRUE(info->GetString("mediaType", &tmp));
 627   ASSERT_EQ("image", tmp);
 628   ASSERT_TRUE(info->GetString("srcUrl", &tmp));
 629   ASSERT_EQ(params.src_url.spec(), tmp);
 630   ASSERT_TRUE(info->GetString("pageUrl", &tmp));
 631   ASSERT_EQ(params.page_url.spec(), tmp);
 632
 633   base::string16 tmp16;
 634   ASSERT_TRUE(info->GetString("selectionText", &tmp16));
 635   ASSERT_EQ(params.selection_text, tmp16);
 636
 637   bool bool_tmp = true;
 638   ASSERT_TRUE(info->GetBoolean("editable", &bool_tmp));
 639   ASSERT_EQ(params.is_editable, bool_tmp);
 640
 641   delete list;
 642 }
 643
 644 // Test that there is always only one radio item selected.
 645 TEST_F(MenuManagerTest, SanitizeRadioButtons) {
 646   Extension* extension = AddExtension("test");
 647
 648   // A single unchecked item should get checked
 649   MenuItem* item1 = CreateTestItem(extension);
 650
 651   item1->set_type(MenuItem::RADIO);
 652   item1->SetChecked(false);
 653   ASSERT_FALSE(item1->checked());
 654   manager_.AddContextItem(extension, item1);
 655   ASSERT_TRUE(item1->checked());
 656
 657   // In a run of two unchecked items, the first should get selected.
 658   item1->SetChecked(false);
 659   MenuItem* item2 = CreateTestItem(extension);
 660   item2->set_type(MenuItem::RADIO);
 661   item2->SetChecked(false);
 662   ASSERT_FALSE(item1->checked());
 663   ASSERT_FALSE(item2->checked());
 664   manager_.AddContextItem(extension, item2);
 665   ASSERT_TRUE(item1->checked());
 666   ASSERT_FALSE(item2->checked());
 667
 668   // If multiple items are checked, only the last item should get checked.
 669   item1->SetChecked(true);
 670   item2->SetChecked(true);
 671   ASSERT_TRUE(item1->checked());
 672   ASSERT_TRUE(item2->checked());
 673   manager_.ItemUpdated(item1->id());
 674   ASSERT_FALSE(item1->checked());
 675   ASSERT_TRUE(item2->checked());
 676
 677   // If the checked item is removed, the new first item should get checked.
 678   item1->SetChecked(false);
 679   item2->SetChecked(true);
 680   ASSERT_FALSE(item1->checked());
 681   ASSERT_TRUE(item2->checked());
 682   manager_.RemoveContextMenuItem(item2->id());
 683   item2 = NULL;
 684   ASSERT_TRUE(item1->checked());
 685
 686   // If a checked item is added to a run that already has a checked item,
 687   // then the new item should get checked.
 688   item1->SetChecked(true);
 689   MenuItem* new_item = CreateTestItem(extension);
 690   new_item->set_type(MenuItem::RADIO);
 691   new_item->SetChecked(true);
 692   ASSERT_TRUE(item1->checked());
 693   ASSERT_TRUE(new_item->checked());
 694   manager_.AddContextItem(extension, new_item);
 695   ASSERT_FALSE(item1->checked());
 696   ASSERT_TRUE(new_item->checked());
 697   // Make sure that children are checked as well.
 698   MenuItem* parent = CreateTestItem(extension);
 699   manager_.AddContextItem(extension, parent);
 700   MenuItem* child1 = CreateTestItem(extension);
 701   child1->set_type(MenuItem::RADIO);
 702   child1->SetChecked(false);
 703   MenuItem* child2 = CreateTestItem(extension);
 704   child2->set_type(MenuItem::RADIO);
 705   child2->SetChecked(true);
 706   ASSERT_FALSE(child1->checked());
 707   ASSERT_TRUE(child2->checked());
 708
 709   manager_.AddChildItem(parent->id(), child1);
 710   ASSERT_TRUE(child1->checked());
 711
 712   manager_.AddChildItem(parent->id(), child2);
 713   ASSERT_FALSE(child1->checked());
 714   ASSERT_TRUE(child2->checked());
 715
 716   // Removing the checked item from the children should cause the
 717   // remaining child to be checked.
 718   manager_.RemoveContextMenuItem(child2->id());
 719   child2 = NULL;
 720   ASSERT_TRUE(child1->checked());
 721
 722   // This should NOT cause |new_item| to be deseleted because
 723   // |parent| will be seperating the two runs of radio items.
 724   manager_.ChangeParent(child1->id(), NULL);
 725   ASSERT_TRUE(new_item->checked());
 726   ASSERT_TRUE(child1->checked());
 727
 728   // Removing |parent| should cause only |child1| to be selected.
 729   manager_.RemoveContextMenuItem(parent->id());
 730   parent = NULL;
 731   ASSERT_FALSE(new_item->checked());
 732   ASSERT_TRUE(child1->checked());
 733 }
 734
 735 // Tests the RemoveAllIncognitoContextItems functionality.
 736 TEST_F(MenuManagerTest, RemoveAllIncognito) {
 737   Extension* extension1 = AddExtension("1111");
 738   // Add 2 top-level and one child item for extension 1
 739   // with incognito 'true'.
 740   MenuItem* item1 = CreateTestItem(extension1, true);
 741   MenuItem* item2 = CreateTestItem(extension1, true);
 742   MenuItem* item3 = CreateTestItem(extension1, true);
 743   ASSERT_TRUE(manager_.AddContextItem(extension1, item1));
 744   ASSERT_TRUE(manager_.AddContextItem(extension1, item2));
 745   ASSERT_TRUE(manager_.AddChildItem(item1->id(), item3));
 746
 747   // Add 2 top-level and one child item for extension 1
 748   // with incognito 'false'.
 749   MenuItem* item4 = CreateTestItem(extension1);
 750   MenuItem* item5 = CreateTestItem(extension1);
 751   MenuItem* item6 = CreateTestItem(extension1);
 752   ASSERT_TRUE(manager_.AddContextItem(extension1, item4));
 753   ASSERT_TRUE(manager_.AddContextItem(extension1, item5));
 754   ASSERT_TRUE(manager_.AddChildItem(item4->id(), item6));
 755
 756   // Add one top-level item for extension 2.
 757   Extension* extension2 = AddExtension("2222");
 758   MenuItem* item7 = CreateTestItem(extension2);
 759   ASSERT_TRUE(manager_.AddContextItem(extension2, item7));
 760
 761   const MenuItem::ExtensionKey key1(extension1->id());
 762   const MenuItem::ExtensionKey key2(extension2->id());
 763   EXPECT_EQ(4u, manager_.MenuItems(key1)->size());
 764   EXPECT_EQ(1u, manager_.MenuItems(key2)->size());
 765
 766   // Remove all context menu items with incognito true.
 767   manager_.RemoveAllIncognitoContextItems();
 768   EXPECT_EQ(2u, manager_.MenuItems(key1)->size());
 769   EXPECT_EQ(1u, manager_.MenuItems(key2)->size());
 770 }
 771
 772 }  // namespace extensions