Moved ExtensionMenuManager and ExtensionMenuItem into extensions namespace

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"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/extensions/lazy_background_page_test_util.h"
 #include "chrome/browser/extensions/test_management_policy.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/common/context_menu_params.h"
 #include "net/base/mock_host_resolver.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebContextMenuData.h"
 #include "ui/base/models/menu_model.h"
 
 using WebKit::WebContextMenuData;
 using content::WebContents;
+using extensions::MenuItem;
 using ui::MenuModel;
 
 namespace {
 // This test class helps us sidestep platform-specific issues with popping up a
 // 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, ExtensionMenuItem::Id>::iterator i;
+    std::map<int, MenuItem::Id>::iterator i;
     for (i = extension_item_map_.begin(); i != extension_item_map_.end(); ++i) {
-      const ExtensionMenuItem::Id& id = i->second;
+      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 ExtensionMenuItem::Id& id, string16* result) {
+  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);
@@ skipping 21 matching lines @@
           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 ExtensionMenuItem::Id& id, int* command_id) {
-    std::map<int, ExtensionMenuItem::Id>::const_iterator i;
+  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;
   }
 
  protected:
@@ skipping 37 matching lines @@
     content::ContextMenuParams params(data);
     params.page_url = page_url;
     params.link_url = link_url;
     params.frame_url = frame_url;
     TestRenderViewContextMenu* menu =
         new TestRenderViewContextMenu(web_contents, params);
     menu->Init();
     return menu;
   }
 
-  // Shortcut to return the current ExtensionMenuManager.
-  ExtensionMenuManager* menu_manager() {
+  // Shortcut to return the current MenuManager.
+  extensions::MenuManager* menu_manager() {
     return browser()->profile()->GetExtensionService()->menu_manager();
   }
 
   // Returns a pointer to the currently loaded extension with |name|, or null
   // if not found.
   const extensions::Extension* GetExtensionNamed(std::string name) {
     const ExtensionSet* extensions =
         browser()->profile()->GetExtensionService()->extensions();
     ExtensionSet::const_iterator i;
     for (i = extensions->begin(); i != extensions->end(); ++i) {
       if ((*i)->name() == name) {
         return *i;
       }
     }
     return NULL;
   }
 
   // This gets all the items that any extension has registered for possible
   // inclusion in context menus.
-  ExtensionMenuItem::List GetItems() {
-    ExtensionMenuItem::List result;
+  MenuItem::List GetItems() {
+    MenuItem::List result;
     std::set<std::string> extension_ids = menu_manager()->ExtensionIds();
     std::set<std::string>::iterator i;
     for (i = extension_ids.begin(); i != extension_ids.end(); ++i) {
-      const ExtensionMenuItem::List* list = menu_manager()->MenuItems(*i);
+      const MenuItem::List* list = menu_manager()->MenuItems(*i);
       result.insert(result.end(), list->begin(), list->end());
     }
     return result;
   }
 
   // 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,
@@ skipping 100 matching lines @@
 // 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;
-  ExtensionMenuItem::List items = GetItems();
+  MenuItem::List items = GetItems();
   ASSERT_EQ(1u, items.size());
-  ExtensionMenuItem* item = items.at(0);
+  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));
@@ skipping 253 matching lines @@
   // Test that menu items appear while the page is unloaded.
   ASSERT_TRUE(MenuHasItemWithLabel(
       about_blank, GURL(), GURL(), std::string("Item 1")));
   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()));
-  ExtensionMenuItem::Id id(false, extension->id());
+  MenuItem::Id id(false, extension->id());
   id.string_uid = "checkbox1";
   int command_id = -1;
   ASSERT_TRUE(menu->FindCommandId(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());
 }