Moved ExtensionMenuManager and ExtensionMenuItem into extensions namespace

chrome/browser/tab_contents/render_view_context_menu.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 <algorithm>
 #include <set>
 #include <utility>
 
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 
@@ skipping 89 matching lines @@
 using content::DownloadManager;
 using content::DownloadUrlParameters;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::SSLStatus;
 using content::UserMetricsAction;
 using content::WebContents;
 using extensions::Extension;
+using extensions::MenuItem;
+using extensions::MenuManager;
 
 namespace {
 
 // Usually a new tab is expected where this function is used,
 // however users should be able to open a tab in background
 // or in a new window.
 WindowOpenDisposition ForceNewTabDispositionFromEventFlags(
     int event_flags) {
   WindowOpenDisposition disposition =
       chrome::DispositionFromEventFlags(event_flags);
@@ skipping 154 matching lines @@
                                   const GURL& url) {
   // No patterns means no restriction, so that implicitly matches.
   if (patterns.is_empty())
     return true;
   return patterns.MatchesURL(url);
 }
 
 // static
 bool RenderViewContextMenu::ExtensionContextAndPatternMatch(
     const content::ContextMenuParams& params,
-    ExtensionMenuItem::ContextList contexts,
+    MenuItem::ContextList contexts,
     const URLPatternSet& target_url_patterns) {
   bool has_link = !params.link_url.is_empty();
   bool has_selection = !params.selection_text.empty();
   bool in_frame = !params.frame_url.is_empty();
 
-  if (contexts.Contains(ExtensionMenuItem::ALL) ||
-      (has_selection && contexts.Contains(ExtensionMenuItem::SELECTION)) ||
-      (params.is_editable && contexts.Contains(ExtensionMenuItem::EDITABLE)) ||
-      (in_frame && contexts.Contains(ExtensionMenuItem::FRAME)))
+  if (contexts.Contains(MenuItem::ALL) ||
+      (has_selection && contexts.Contains(MenuItem::SELECTION)) ||
+      (params.is_editable && contexts.Contains(MenuItem::EDITABLE)) ||
+      (in_frame && contexts.Contains(MenuItem::FRAME)))
     return true;
 
-  if (has_link && contexts.Contains(ExtensionMenuItem::LINK) &&
+  if (has_link && contexts.Contains(MenuItem::LINK) &&
       ExtensionPatternMatch(target_url_patterns, params.link_url))
     return true;
 
   switch (params.media_type) {
     case WebContextMenuData::MediaTypeImage:
-      if (contexts.Contains(ExtensionMenuItem::IMAGE) &&
+      if (contexts.Contains(MenuItem::IMAGE) &&
           ExtensionPatternMatch(target_url_patterns, params.src_url))
         return true;
       break;
 
     case WebContextMenuData::MediaTypeVideo:
-      if (contexts.Contains(ExtensionMenuItem::VIDEO) &&
+      if (contexts.Contains(MenuItem::VIDEO) &&
           ExtensionPatternMatch(target_url_patterns, params.src_url))
         return true;
       break;
 
     case WebContextMenuData::MediaTypeAudio:
-      if (contexts.Contains(ExtensionMenuItem::AUDIO) &&
+      if (contexts.Contains(MenuItem::AUDIO) &&
           ExtensionPatternMatch(target_url_patterns, params.src_url))
         return true;
       break;
 
     default:
       break;
   }
 
   // PAGE is the least specific context, so we only examine that if none of the
   // other contexts apply (except for FRAME, which is included in PAGE for
   // backwards compatibility).
   if (!has_link && !has_selection && !params.is_editable &&
       params.media_type == WebContextMenuData::MediaTypeNone &&
-      contexts.Contains(ExtensionMenuItem::PAGE))
+      contexts.Contains(MenuItem::PAGE))
     return true;
 
   return false;
 }
 
 static const GURL& GetDocumentURL(const content::ContextMenuParams& params) {
   return params.frame_url.is_empty() ? params.page_url : params.frame_url;
 }
 
 // Given a list of items, returns the ones that match given the contents
 // of |params| and the profile.
 // static
-ExtensionMenuItem::List RenderViewContextMenu::GetRelevantExtensionItems(
-    const ExtensionMenuItem::List& items,
+MenuItem::List RenderViewContextMenu::GetRelevantExtensionItems(
+    const MenuItem::List& items,
     const content::ContextMenuParams& params,
     Profile* profile,
     bool can_cross_incognito) {
-  ExtensionMenuItem::List result;
-  for (ExtensionMenuItem::List::const_iterator i = items.begin();
+  MenuItem::List result;
+  for (MenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++i) {
-    const ExtensionMenuItem* item = *i;
+    const MenuItem* item = *i;
 
     if (!ExtensionContextAndPatternMatch(params, item->contexts(),
         item->target_url_patterns()))
       continue;
 
     const GURL& document_url = GetDocumentURL(params);
     if (!ExtensionPatternMatch(item->document_url_patterns(), document_url))
       continue;
 
     if (item->id().incognito == profile->IsOffTheRecord() ||
         can_cross_incognito)
       result.push_back(*i);
   }
   return result;
 }
 
 void RenderViewContextMenu::AppendExtensionItems(
     const std::string& extension_id, int* index) {
   ExtensionService* service = profile_->GetExtensionService();
-  ExtensionMenuManager* manager = service->menu_manager();
+  MenuManager* manager = service->menu_manager();
   const Extension* extension = service->GetExtensionById(extension_id, false);
   DCHECK_GE(*index, 0);
   int max_index =
       IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST - IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
   if (!extension || *index >= max_index)
     return;
 
   // Find matching items.
-  const ExtensionMenuItem::List* all_items = manager->MenuItems(extension_id);
+  const MenuItem::List* all_items = manager->MenuItems(extension_id);
   if (!all_items || all_items->empty())
     return;
   bool can_cross_incognito = service->CanCrossIncognito(extension);
-  ExtensionMenuItem::List items =
+  MenuItem::List items =
       GetRelevantExtensionItems(*all_items, params_, profile_,
                                 can_cross_incognito);
   if (items.empty())
     return;
 
   // If this is the first extension-provided menu item, and there are other
   // items in the menu, add a separator.
   if (*index == 0 && menu_model_.GetItemCount())
     menu_model_.AddSeparator();
 
   int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
 
   // Extensions are only allowed one top-level slot (and it can't be a radio or
   // checkbox item because we are going to put the extension icon next to it).
   // If they have more than that, we automatically push them into a submenu.
   string16 title;
-  ExtensionMenuItem::List submenu_items;
-  if (items.size() > 1 || items[0]->type() != ExtensionMenuItem::NORMAL) {
+  MenuItem::List submenu_items;
+  if (items.size() > 1 || items[0]->type() != MenuItem::NORMAL) {
     title = UTF8ToUTF16(extension->name());
     submenu_items = items;
   } else {
-    ExtensionMenuItem* item = items[0];
+    MenuItem* item = items[0];
     extension_item_map_[menu_id] = item->id();
     title = item->TitleWithReplacement(PrintableSelectionText(),
                                        kMaxExtensionItemTitleLength);
     submenu_items = GetRelevantExtensionItems(item->children(), params_,
                                               profile_, can_cross_incognito);
   }
 
   // Now add our item(s) to the menu_model_.
   if (submenu_items.empty()) {
     menu_model_.AddItem(menu_id, title);
   } else {
     ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(this);
     extension_menu_models_.push_back(submenu);
     menu_model_.AddSubMenu(menu_id, title, submenu);
     RecursivelyAppendExtensionItems(submenu_items, can_cross_incognito, submenu,
                                     index);
   }
   SetExtensionIcon(extension_id);
 }
 
 void RenderViewContextMenu::RecursivelyAppendExtensionItems(
-    const ExtensionMenuItem::List& items,
+    const MenuItem::List& items,
     bool can_cross_incognito,
     ui::SimpleMenuModel* menu_model,
     int* index) {
   string16 selection_text = PrintableSelectionText();
-  ExtensionMenuItem::Type last_type = ExtensionMenuItem::NORMAL;
+  MenuItem::Type last_type = MenuItem::NORMAL;
   int radio_group_id = 1;
 
-  for (ExtensionMenuItem::List::const_iterator i = items.begin();
+  for (MenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++i) {
-    ExtensionMenuItem* item = *i;
+    MenuItem* item = *i;
 
     // If last item was of type radio but the current one isn't, auto-insert
     // a separator.  The converse case is handled below.
-    if (last_type == ExtensionMenuItem::RADIO &&
-        item->type() != ExtensionMenuItem::RADIO) {
+    if (last_type == MenuItem::RADIO &&
+        item->type() != MenuItem::RADIO) {
       menu_model->AddSeparator();
-      last_type = ExtensionMenuItem::SEPARATOR;
+      last_type = MenuItem::SEPARATOR;
     }
 
     int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
     if (menu_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST)
       return;
     extension_item_map_[menu_id] = item->id();
     string16 title = item->TitleWithReplacement(selection_text,
                                                 kMaxExtensionItemTitleLength);
-    if (item->type() == ExtensionMenuItem::NORMAL) {
-      ExtensionMenuItem::List children =
+    if (item->type() == MenuItem::NORMAL) {
+      MenuItem::List children =
           GetRelevantExtensionItems(item->children(), params_,
                                     profile_, can_cross_incognito);
       if (children.empty()) {
         menu_model->AddItem(menu_id, title);
       } else {
         ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(this);
         extension_menu_models_.push_back(submenu);
         menu_model->AddSubMenu(menu_id, title, submenu);
         RecursivelyAppendExtensionItems(children, can_cross_incognito,
                                         submenu, index);
       }
-    } else if (item->type() == ExtensionMenuItem::CHECKBOX) {
+    } else if (item->type() == MenuItem::CHECKBOX) {
       menu_model->AddCheckItem(menu_id, title);
-    } else if (item->type() == ExtensionMenuItem::RADIO) {
+    } else if (item->type() == MenuItem::RADIO) {
       if (i != items.begin() &&
-          last_type != ExtensionMenuItem::RADIO) {
+          last_type != MenuItem::RADIO) {
         radio_group_id++;
 
         // Auto-append a separator if needed.
-        if (last_type != ExtensionMenuItem::SEPARATOR)
+        if (last_type != MenuItem::SEPARATOR)
           menu_model->AddSeparator();
       }
 
       menu_model->AddRadioItem(menu_id, title, radio_group_id);
-    } else if (item->type() == ExtensionMenuItem::SEPARATOR) {
-      if (i != items.begin() && last_type != ExtensionMenuItem::SEPARATOR) {
+    } else if (item->type() == MenuItem::SEPARATOR) {
+      if (i != items.begin() && last_type != MenuItem::SEPARATOR) {
         menu_model->AddSeparator();
       }
     }
     last_type = item->type();
   }
 }
 
 void RenderViewContextMenu::SetExtensionIcon(const std::string& extension_id) {
   ExtensionService* service = profile_->GetExtensionService();
-  ExtensionMenuManager* menu_manager = service->menu_manager();
+  MenuManager* menu_manager = service->menu_manager();
 
   int index = menu_model_.GetItemCount() - 1;
   DCHECK_GE(index, 0);
 
   const SkBitmap& icon = menu_manager->GetIconForExtension(extension_id);
   DCHECK(icon.width() == gfx::kFaviconSize);
   DCHECK(icon.height() == gfx::kFaviconSize);
 
   menu_model_.SetIcon(index, icon);
 }
 
 void RenderViewContextMenu::AppendAllExtensionItems() {
   extension_item_map_.clear();
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return;  // In unit-tests, we may not have an ExtensionService.
-  ExtensionMenuManager* menu_manager = service->menu_manager();
+  MenuManager* menu_manager = service->menu_manager();
 
   // Get a list of extension id's that have context menu items, and sort it by
   // the extension's name.
   std::set<std::string> ids = menu_manager->ExtensionIds();
   std::vector<std::pair<std::string, std::string> > sorted_ids;
   for (std::set<std::string>::iterator i = ids.begin(); i != ids.end(); ++i) {
     const Extension* extension = service->GetExtensionById(*i, false);
     // Platform apps have their context menus created directly in
     // AppendPlatformAppItems.
     if (extension && !extension->is_platform_app())
@@ skipping 534 matching lines @@
   protocol_handler_submenu_model_.AddItem(
       IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_SETTINGS,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_OPENLINKWITH_CONFIGURE));
 
   menu_model_.AddSubMenu(
       IDC_CONTENT_CONTEXT_OPENLINKWITH,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_OPENLINKWITH),
       &protocol_handler_submenu_model_);
 }
 
-ExtensionMenuItem* RenderViewContextMenu::GetExtensionMenuItem(int id) const {
-  ExtensionMenuManager* manager =
-      profile_->GetExtensionService()->menu_manager();
-  std::map<int, ExtensionMenuItem::Id>::const_iterator i =
+MenuItem* RenderViewContextMenu::GetExtensionMenuItem(int id) const {
+  MenuManager* manager = profile_->GetExtensionService()->menu_manager();
+  std::map<int, MenuItem::Id>::const_iterator i =
       extension_item_map_.find(id);
   if (i != extension_item_map_.end()) {
-    ExtensionMenuItem* item = manager->GetItemById(i->second);
+    MenuItem* item = manager->GetItemById(i->second);
     if (item)
       return item;
   }
   return NULL;
 }
 
 // Menu delegate functions -----------------------------------------------------
 
 bool RenderViewContextMenu::IsCommandIdEnabled(int id) const {
   // If this command is is added by one of our observers, we dispatch it to the
@@ skipping 25 matching lines @@
 
   // Custom items.
   if (id >= IDC_CONTENT_CONTEXT_CUSTOM_FIRST &&
       id <= IDC_CONTENT_CONTEXT_CUSTOM_LAST) {
     return IsCustomItemEnabled(params_.custom_items, id);
   }
 
   // Extension items.
   if (id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
       id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
-    ExtensionMenuItem* item = GetExtensionMenuItem(id);
+    MenuItem* item = GetExtensionMenuItem(id);
     // If this is the parent menu item, it is always enabled.
     if (!item)
       return true;
     return item->enabled();
   }
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
     return true;
   }
@@ skipping 285 matching lines @@
 
   // Custom items.
   if (id >= IDC_CONTENT_CONTEXT_CUSTOM_FIRST &&
       id <= IDC_CONTENT_CONTEXT_CUSTOM_LAST) {
     return IsCustomItemChecked(params_.custom_items, id);
   }
 
   // Extension items.
   if (id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
       id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
-    ExtensionMenuItem* item = GetExtensionMenuItem(id);
+    MenuItem* item = GetExtensionMenuItem(id);
     if (item)
       return item->checked();
     else
       return false;
   }
 
 #if defined(OS_MACOSX)
     if (id == IDC_WRITING_DIRECTION_DEFAULT)
       return params_.writing_direction_default &
           WebContextMenuData::CheckableMenuItemChecked;
@@ skipping 38 matching lines @@
   if (id >= IDC_CONTENT_CONTEXT_CUSTOM_FIRST &&
       id <= IDC_CONTENT_CONTEXT_CUSTOM_LAST) {
     unsigned action = id - IDC_CONTENT_CONTEXT_CUSTOM_FIRST;
     rvh->ExecuteCustomContextMenuCommand(action, params_.custom_context);
     return;
   }
 
   // Process extension menu items.
   if (id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
       id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
-    ExtensionMenuManager* manager =
-        profile_->GetExtensionService()->menu_manager();
-    std::map<int, ExtensionMenuItem::Id>::const_iterator i =
+    MenuManager* manager = profile_->GetExtensionService()->menu_manager();
+    std::map<int, MenuItem::Id>::const_iterator i =
         extension_item_map_.find(id);
     if (i != extension_item_map_.end()) {
       manager->ExecuteCommand(profile_, source_web_contents_, params_,
                               i->second);
     }
     return;
   }
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
@@ skipping 513 matching lines @@
   source_web_contents_->GetRenderViewHost()->
       ExecuteMediaPlayerActionAtLocation(location, action);
 }
 
 void RenderViewContextMenu::PluginActionAt(
     const gfx::Point& location,
     const WebPluginAction& action) {
   source_web_contents_->GetRenderViewHost()->
       ExecutePluginActionAtLocation(location, action);
 }