Give platform apps control over launcher right-click context menu.

chrome/browser/extensions/extension_context_menu_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 21 matching lines @@
 // real context menu, while still running through the actual code in
 // RenderViewContextMenu where extension items get added and executed.
 class TestRenderViewContextMenu : public RenderViewContextMenu {
  public:
   TestRenderViewContextMenu(WebContents* web_contents,
                             const content::ContextMenuParams& params)
       : RenderViewContextMenu(web_contents, params) {}
 
   virtual ~TestRenderViewContextMenu() {}
 
-  bool HasExtensionItemWithLabel(const std::string& label) {
-    string16 label16 = UTF8ToUTF16(label);
-    std::map<int, MenuItem::Id>::iterator i;
-    for (i = extension_item_map_.begin(); i != extension_item_map_.end(); ++i) {
-      const MenuItem::Id& id = i->second;
-      string16 tmp_label;
-      EXPECT_TRUE(GetItemLabel(id, &tmp_label));
-      if (tmp_label == label16)
-        return true;
-    }
-    return false;
-  }
-
-  // Looks in the menu for an extension item with |id|, and if it is found and
-  // has a label, that is put in |result| and we return true. Otherwise returns
-  // false.
-  bool GetItemLabel(const MenuItem::Id& id, string16* result) {
-    int command_id = 0;
-    if (!FindCommandId(id, &command_id))
-      return false;
-
-    MenuModel* model = NULL;
-    int index = -1;
-    if (!GetMenuModelAndItemIndex(command_id, &model, &index)) {
-      return false;
-    }
-    *result = model->GetLabelAt(index);
-    return true;
-  }
-
   // Searches for an menu item with |command_id|. If it's found, the return
   // value is true and the model and index where it appears in that model are
   // returned in |found_model| and |found_index|. Otherwise returns false.
   bool GetMenuModelAndItemIndex(int command_id,
                                 MenuModel** found_model,
                                 int *found_index) {
     std::vector<MenuModel*> models_to_search;
     models_to_search.push_back(&menu_model_);
 
     while (!models_to_search.empty()) {
       MenuModel* model = models_to_search.back();
       models_to_search.pop_back();
       for (int i = 0; i < model->GetItemCount(); i++) {
         if (model->GetCommandIdAt(i) == command_id) {
           *found_model = model;
           *found_index = i;
           return true;
         } else if (model->GetTypeAt(i) == MenuModel::TYPE_SUBMENU) {
           models_to_search.push_back(model->GetSubmenuModelAt(i));
         }
       }
     }
 
     return false;
   }
 
-  // Given an extension menu item id, tries to find the corresponding command id
-  // in the menu.
-  bool FindCommandId(const MenuItem::Id& id, int* command_id) {
-    std::map<int, MenuItem::Id>::const_iterator i;
-    for (i = extension_item_map_.begin(); i != extension_item_map_.end(); ++i) {
-      if (i->second == id) {
-        *command_id = i->first;
-        return true;
-      }
-    }
-    return false;
+  extensions::ContextMenuMatcher& extension_items() {
+    return extension_items_;
   }
 
  protected:
   // These two functions implement pure virtual methods of
   // RenderViewContextMenu.
   virtual bool GetAcceleratorForCommandId(int command_id,
                                           ui::Accelerator* accelerator) {
     // None of our commands have accelerators, so always return false.
     return false;
   }
@@ skipping 71 matching lines @@
 
   // This creates a test menu for a page with |page_url| and |link_url|, looks
   // for an extension item with the given |label|, and returns true if the item
   // was found.
   bool MenuHasItemWithLabel(const GURL& page_url,
                             const GURL& link_url,
                             const GURL& frame_url,
                             const std::string& label) {
     scoped_ptr<TestRenderViewContextMenu> menu(
         CreateMenu(browser(), page_url, link_url, frame_url));
-    return menu->HasExtensionItemWithLabel(label);
+    return MenuHasExtensionItemWithLabel(menu.get(), label);
   }
 
   // This creates an extension that starts |enabled| and then switches to
   // |!enabled|.
   void TestEnabledContextMenu(bool enabled) {
     ExtensionTestMessageListener begin("begin", true);
     ExtensionTestMessageListener create("create", true);
     ExtensionTestMessageListener update("update", false);
     ASSERT_TRUE(LoadContextMenuExtension("enabled"));
 
@@ skipping 15 matching lines @@
         CreateMenu(browser(), page_url, GURL(), GURL()));
 
     // Look for the extension item in the menu, and make sure it's |enabled|.
     int command_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
     ASSERT_EQ(enabled, menu->IsCommandIdEnabled(command_id));
 
     // Update the item and make sure it is now |!enabled|.
     ASSERT_TRUE(update.WaitUntilSatisfied());
     ASSERT_EQ(!enabled, menu->IsCommandIdEnabled(command_id));
   }
+
+ bool MenuHasExtensionItemWithLabel(TestRenderViewContextMenu* menu,
+                                     const std::string& label) {
+    string16 label16 = UTF8ToUTF16(label);
+    std::map<int, MenuItem::Id>::iterator i;
+    for (i = menu->extension_items().extension_item_map_.begin();
+         i != menu->extension_items().extension_item_map_.end(); ++i) {
+      const MenuItem::Id& id = i->second;
+      string16 tmp_label;
+      EXPECT_TRUE(GetItemLabel(menu, id, &tmp_label));
+      if (tmp_label == label16)
+        return true;
+    }
+    return false;
+  }
+
+  // Looks in the menu for an extension item with |id|, and if it is found and
+  // has a label, that is put in |result| and we return true. Otherwise returns
+  // false.
+  bool GetItemLabel(TestRenderViewContextMenu* menu,
+                    const MenuItem::Id& id,
+                    string16* result) {
+    int command_id = 0;
+    if (!FindCommandId(menu, id, &command_id))
+      return false;
+
+    MenuModel* model = NULL;
+    int index = -1;
+    if (!menu->GetMenuModelAndItemIndex(command_id, &model, &index)) {
+      return false;
+    }
+    *result = model->GetLabelAt(index);
+    return true;
+  }
+
+  // Given an extension menu item id, tries to find the corresponding command id
+  // in the menu.
+  bool FindCommandId(TestRenderViewContextMenu* menu,
+                     const MenuItem::Id& id,
+                     int* command_id) {
+    std::map<int, MenuItem::Id>::const_iterator i;
+    for (i = menu->extension_items().extension_item_map_.begin();
+         i != menu->extension_items().extension_item_map_.end(); ++i) {
+      if (i->second == id) {
+        *command_id = i->first;
+        return true;
+      }
+    }
+    return false;
+  }
 };
 
 // Tests adding a simple context menu item.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, Simple) {
   ExtensionTestMessageListener listener1("created item", false);
   ExtensionTestMessageListener listener2("onclick fired", false);
   ASSERT_TRUE(LoadContextMenuExtension("simple"));
 
   // Wait for the extension to tell us it's created an item.
   ASSERT_TRUE(listener1.WaitUntilSatisfied());
@@ skipping 49 matching lines @@
 // Tests registering an item with a very long title that should get truncated in
 // the actual menu displayed.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, LongTitle) {
   ExtensionTestMessageListener listener("created", false);
 
   // Load the extension and wait until it's created a menu item.
   ASSERT_TRUE(LoadContextMenuExtension("long_title"));
   ASSERT_TRUE(listener.WaitUntilSatisfied());
 
   // Make sure we have an item registered with a long title.
-  size_t limit = RenderViewContextMenu::kMaxExtensionItemTitleLength;
+  size_t limit = extensions::ContextMenuMatcher::kMaxExtensionItemTitleLength;
   MenuItem::List items = GetItems();
   ASSERT_EQ(1u, items.size());
   MenuItem* item = items.at(0);
   ASSERT_GT(item->title().size(), limit);
 
   // Create a context menu, then find the item's label. It should be properly
   // truncated.
   GURL url("http://foo.com/");
   scoped_ptr<TestRenderViewContextMenu> menu(
       CreateMenu(browser(), url, GURL(), GURL()));
 
   string16 label;
-  ASSERT_TRUE(menu->GetItemLabel(item->id(), &label));
+  ASSERT_TRUE(GetItemLabel(menu.get(), item->id(), &label));
   ASSERT_TRUE(label.size() <= limit);
 }
 
 // Checks that in |menu|, the item at |index| has type |expected_type| and a
 // label of |expected_label|.
 static void ExpectLabelAndType(const char* expected_label,
                                MenuModel::ItemType expected_type,
                                const MenuModel& menu,
                                int index) {
   EXPECT_EQ(expected_type, menu.GetTypeAt(index));
@@ skipping 244 matching lines @@
   ASSERT_TRUE(MenuHasItemWithLabel(
       about_blank, GURL(), GURL(), std::string("Checkbox 1")));
 
   // Test that checked menu items retain their checkedness.
   LazyBackgroundObserver checkbox_checked;
   scoped_ptr<TestRenderViewContextMenu> menu(
       CreateMenu(browser(), about_blank, GURL(), GURL()));
   MenuItem::Id id(false, extension->id());
   id.string_uid = "checkbox1";
   int command_id = -1;
-  ASSERT_TRUE(menu->FindCommandId(id, &command_id));
+  ASSERT_TRUE(FindCommandId(menu.get(), id, &command_id));
   EXPECT_FALSE(menu->IsCommandIdChecked(command_id));
 
   // Executing the checkbox also fires the onClicked event.
   ExtensionTestMessageListener listener("onClicked fired for checkbox1", false);
   menu->ExecuteCommand(command_id);
   checkbox_checked.WaitUntilClosed();
 
   EXPECT_TRUE(menu->IsCommandIdChecked(command_id));
   ASSERT_TRUE(listener.WaitUntilSatisfied());
 }