Initial version of an experimental Extensions Context Menu API....

chrome/browser/tab_contents/render_view_context_menu.cc

 // Copyright (c) 2010 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 <functional>
+
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 
 #include "app/clipboard/clipboard.h"
 #include "app/clipboard/scoped_clipboard_writer.h"
 #include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/download/download_manager.h"
+#include "chrome/browser/extensions/extension_menu_manager.h"
+#include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/fonts_languages_window.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/net/browser_url_util.h"
 #include "chrome/browser/page_info_window.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/search_versus_navigate_classifier.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/spellcheck_host.h"
@@ skipping 32 matching lines @@
 RenderViewContextMenu::~RenderViewContextMenu() {
 }
 
 // Menu construction functions -------------------------------------------------
 
 void RenderViewContextMenu::Init() {
   InitMenu();
   DoInit();
 }
 
+static bool ExtensionContextMatch(ContextMenuParams params,
+                                  ExtensionMenuItem::ContextList contexts) {
+  bool has_link = !params.link_url.is_empty();
+  bool has_selection = !params.selection_text.empty();
+
+  if (contexts.Contains(ExtensionMenuItem::ALL) ||
+      (has_selection && contexts.Contains(ExtensionMenuItem::SELECTION)) ||
+      (has_link && contexts.Contains(ExtensionMenuItem::LINK)) ||
+      (params.is_editable && contexts.Contains(ExtensionMenuItem::EDITABLE))) {
+    return true;
+  }
+
+  switch (params.media_type) {
+    case WebContextMenuData::MediaTypeImage:
+      return contexts.Contains(ExtensionMenuItem::IMAGE);
+
+    case WebContextMenuData::MediaTypeVideo:
+      return contexts.Contains(ExtensionMenuItem::VIDEO);
+
+    case WebContextMenuData::MediaTypeAudio:
+      return contexts.Contains(ExtensionMenuItem::AUDIO);
+
+    default:
+      break;
+  }
+
+  // PAGE is the least specific context, so we only examine that if none of the
+  // other contexts apply.
+  if (!has_link && !has_selection && !params.is_editable &&
+      params.media_type == WebContextMenuData::MediaTypeNone &&
+      contexts.Contains(ExtensionMenuItem::PAGE))
+    return true;
+
+  return false;
+}
+
+void RenderViewContextMenu::GetItemsForExtension(
+    const std::string& extension_id,
+    std::vector<const ExtensionMenuItem*>* items) {
+  ExtensionsService* service = profile_->GetExtensionsService();
+
+  // Get the set of possible items, and iterate to find which ones are
+  // applicable.
+  std::vector<const ExtensionMenuItem*> potential_items =
+      service->menu_manager()->MenuItems(extension_id);
+
+  std::vector<const ExtensionMenuItem*>::const_iterator i;
+  for (i = potential_items.begin(); i != potential_items.end(); ++i) {
+    const ExtensionMenuItem* item = *i;
+    if (ExtensionContextMatch(params_, item->contexts()))
+      items->push_back(item);
+  }
+}
+
+bool RenderViewContextMenu::MaybeStartExtensionSubMenu(
+    const string16& selection_text, const std::string& extension_name,
+    std::vector<const ExtensionMenuItem*>* items, int* index) {
+  if (items->size() == 0 ||
+      (items->size() == 1 && items->at(0)->child_count() == 0))
+    return false;
+
+  int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
+  string16 title;
+  const ExtensionMenuItem* first_item = items->at(0);
+  if (first_item->child_count() > 0) {
+    title = first_item->TitleWithReplacement(selection_text);
+    extension_item_map_[menu_id] = first_item->id();
+  } else {
+    title = UTF8ToUTF16(extension_name);
+  }
+  StartSubMenu(menu_id, title);
+
+  // If we have 1 parent item with a submenu of children, pull the
+  // parent out of |items| and put the children in.
+  if (items->size() == 1 && first_item->child_count() > 0) {
+    const ExtensionMenuItem* parent = first_item;
+    items->clear();
+    for (int j = 0; j < parent->child_count(); j++) {
+      const ExtensionMenuItem* child = parent->ChildAt(j);
+      if (ExtensionContextMatch(params_, child->contexts()))
+        items->push_back(child);
+    }
+  }
+
+  return true;
+}
+
+void RenderViewContextMenu::AppendExtensionItems(
+    const std::string& extension_id, int* index) {
+  Extension* extension =
+      profile_->GetExtensionsService()->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;
+
+  std::vector<const ExtensionMenuItem*> items;
+  GetItemsForExtension(extension_id, &items);
+  if (items.empty())
+    return;
+
+  string16 selection_text = PrintableSelectionText();
+
+  // If this is the first extension-provided menu item, add a separator.
+  if (*index == 0)
+    AppendSeparator();
+
+  bool submenu_started = MaybeStartExtensionSubMenu(
+      selection_text, extension->name(), &items, index);
+
+  ExtensionMenuItem::Type last_type = ExtensionMenuItem::NORMAL;
+  for (std::vector<const ExtensionMenuItem*>::iterator i = items.begin();
+       i != items.end(); ++i) {
+    const ExtensionMenuItem* item = *i;
+    if (item->type() == ExtensionMenuItem::SEPARATOR) {
+      // We don't want the case of an extension with one top-level item that is
+      // just a separator, so make sure this is inside a submenu.
+      if (submenu_started) {
+        AppendSeparator();
+        last_type = ExtensionMenuItem::SEPARATOR;
+      }
+      continue;
+    }
+
+    // Auto-prepend a separator, if needed, to group radio items together.
+    if (item->type() != ExtensionMenuItem::RADIO &&
+        item->type() != ExtensionMenuItem::SEPARATOR &&
+        last_type == ExtensionMenuItem::RADIO) {
+      AppendSeparator();
+    }
+
+    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);
+    if (item->type() == ExtensionMenuItem::NORMAL) {
+      AppendMenuItem(menu_id, title);
+    } else if (item->type() == ExtensionMenuItem::CHECKBOX) {
+      AppendCheckboxMenuItem(menu_id, title);
+    } else if (item->type() == ExtensionMenuItem::RADIO) {
+      // Auto-append a separator if needed to group radio items together.
+      if (*index > 0 && last_type != ExtensionMenuItem::RADIO &&
+          last_type != ExtensionMenuItem::SEPARATOR)
+        AppendSeparator();
+
+      AppendRadioMenuItem(menu_id, title);
+    } else {
+      NOTREACHED();
+    }
+    last_type = item->type();
+  }
+
+  if (submenu_started)
+    FinishSubMenu();
+}
+
+void RenderViewContextMenu::AppendAllExtensionItems() {
+  extension_item_map_.clear();
+  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionMenuManager* 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) {
+    Extension* extension = service->GetExtensionById(*i, false);
+    if (extension)
+      sorted_ids.push_back(
+          std::pair<std::string, std::string>(extension->name(), *i));
+  }
+  // TODO(asargent) - See if this works properly for i18n names (bug 32363).
+  std::sort(sorted_ids.begin(), sorted_ids.end());
+
+  int index = 0;
+  std::vector<std::pair<std::string, std::string> >::const_iterator i;
+  for (i = sorted_ids.begin();
+       i != sorted_ids.end(); ++i) {
+    AppendExtensionItems(i->second, &index);
+  }
+}
+
 void RenderViewContextMenu::InitMenu() {
   bool has_link = !params_.link_url.is_empty();
   bool has_selection = !params_.selection_text.empty();
 
   if (AppendCustomItems()) {
     AppendSeparator();
     AppendDeveloperItems();
     return;
   }
 
@@ skipping 37 matching lines @@
   }
 
   if (params_.is_editable)
     AppendEditableItems();
   else if (has_selection)
     AppendCopyItem();
 
   if (has_selection)
     AppendSearchProvider();
 
+  if (!is_devtools)
+    AppendAllExtensionItems();
+
   // In the DevTools popup menu, "developer items" is normally the only section,
   // so omit the separator there.
   if (!is_devtools)
     AppendSeparator();
   AppendDeveloperItems();
 }
 
 bool RenderViewContextMenu::AppendCustomItems() {
   std::vector<WebMenuItem>& custom_items = params_.custom_items;
   for (size_t i = 0; i < custom_items.size(); ++i) {
@@ skipping 104 matching lines @@
   if (params_.selection_text.empty())
     return;
 
   bool is_search;
   profile_->GetSearchVersusNavigateClassifier()->Classify(
       params_.selection_text, std::wstring(), &is_search,
       &selection_navigation_url_, NULL, NULL, NULL);
   if (!selection_navigation_url_.is_valid())
     return;
 
-  string16 printable_selection_text(
-      WideToUTF16(l10n_util::TruncateString(params_.selection_text, 50)));
+  string16 printable_selection_text = PrintableSelectionText();
   // Escape "&" as "&&".
   for (size_t i = printable_selection_text.find('&'); i != string16::npos;
        i = printable_selection_text.find('&', i + 2))
     printable_selection_text.insert(i, 1, '&');
 
   if (is_search) {
     const TemplateURL* const default_provider =
         profile_->GetTemplateURLModel()->GetDefaultSearchProvider();
     if (!default_provider)
       return;
@@ skipping 87 matching lines @@
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_WRITING_DIRECTION_MENU));
 
   AppendCheckboxMenuItem(IDC_WRITING_DIRECTION_DEFAULT,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_WRITING_DIRECTION_DEFAULT));
   AppendCheckboxMenuItem(IDC_WRITING_DIRECTION_LTR,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_WRITING_DIRECTION_LTR));
   AppendCheckboxMenuItem(IDC_WRITING_DIRECTION_RTL,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_WRITING_DIRECTION_RTL));
 
   FinishSubMenu();
-#endif // OS_MACOSX
+#endif  // OS_MACOSX
 
   AppendSeparator();
   AppendMenuItem(IDS_CONTENT_CONTEXT_SELECTALL);
 }
 
+ExtensionMenuItem* RenderViewContextMenu::GetExtensionMenuItem(int id) const {
+  ExtensionMenuManager* manager =
+      profile_->GetExtensionsService()->menu_manager();
+  std::map<int, int>::const_iterator i = extension_item_map_.find(id);
+  if (i != extension_item_map_.end()) {
+    ExtensionMenuItem* item = manager->GetItemById(i->second);
+    if (item)
+      return item;
+  }
+  return NULL;
+}
+
 // Menu delegate functions -----------------------------------------------------
 
 bool RenderViewContextMenu::IsItemCommandEnabled(int id) const {
   // Allow Spell Check language items on sub menu for text area context menu.
   if ((id >= IDC_SPELLCHECK_LANGUAGES_FIRST) &&
       (id < IDC_SPELLCHECK_LANGUAGES_LAST)) {
     return profile_->GetPrefs()->GetBoolean(prefs::kEnableSpellCheck);
   }
 
   // Process custom actions range.
   if ((id >= IDC_CONTENT_CONTEXT_CUSTOM_FIRST) &&
       (id < IDC_CONTENT_CONTEXT_CUSTOM_LAST)) {
     unsigned action = id - IDC_CONTENT_CONTEXT_CUSTOM_FIRST;
     for (size_t i = 0; i < params_.custom_items.size(); ++i) {
       if (params_.custom_items[i].action == action)
         return params_.custom_items[i].enabled;
     }
     NOTREACHED();
     return false;
   }
 
+  // Extension items.
+  if (id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+      id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    ExtensionMenuItem* item = GetExtensionMenuItem(id);
+    if (item)
+      return ExtensionContextMatch(params_, item->enabled_contexts());
+    else
+      return false;
+  }
+
   switch (id) {
     case IDS_CONTENT_CONTEXT_BACK:
       return source_tab_contents_->controller().CanGoBack();
 
     case IDS_CONTENT_CONTEXT_FORWARD:
       return source_tab_contents_->controller().CanGoForward();
 
     case IDS_CONTENT_CONTEXT_RELOAD:
       return source_tab_contents_->delegate()->CanReloadContents(
           source_tab_contents_);
@@ skipping 169 matching lines @@
   }
 }
 
 bool RenderViewContextMenu::ItemIsChecked(int id) const {
   // See if the video is set to looping.
   if (id == IDS_CONTENT_CONTEXT_LOOP) {
     return (params_.media_flags &
             WebContextMenuData::MediaLoop) != 0;
   }
 
+  if (id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+      id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    ExtensionMenuItem* 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;
     if (id == IDC_WRITING_DIRECTION_RTL)
       return params_.writing_direction_right_to_left &
           WebContextMenuData::CheckableMenuItemChecked;
     if (id == IDC_WRITING_DIRECTION_LTR)
       return params_.writing_direction_left_to_right &
           WebContextMenuData::CheckableMenuItemChecked;
@@ skipping 34 matching lines @@
 
   // Process custom actions range.
   if ((id >= IDC_CONTENT_CONTEXT_CUSTOM_FIRST) &&
       (id < IDC_CONTENT_CONTEXT_CUSTOM_LAST)) {
     unsigned action = id - IDC_CONTENT_CONTEXT_CUSTOM_FIRST;
     source_tab_contents_->render_view_host()->
         PerformCustomContextMenuAction(action);
     return;
   }
 
+  // Process extension menu items.
+  if (id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+      id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    ExtensionMenuManager* manager =
+        profile_->GetExtensionsService()->menu_manager();
+    std::map<int, int>::const_iterator i = extension_item_map_.find(id);
+    if (i != extension_item_map_.end()) {
+      manager->ExecuteCommand(profile_, source_tab_contents_, params_,
+                              i->second);
+    }
+    return;
+  }
+
+
   switch (id) {
     case IDS_CONTENT_CONTEXT_OPENLINKNEWTAB:
       OpenURL(params_.link_url,
               source_tab_contents_->delegate() &&
               source_tab_contents_->delegate()->IsApplication() ?
                   NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB,
               PageTransition::LINK);
       break;
 
     case IDS_CONTENT_CONTEXT_OPENLINKNEWWINDOW:
@@ skipping 296 matching lines @@
     // Don't enable the web inspector on web inspector if there is no process
     // per tab flag set.
     if (IsDevToolsURL(active_entry->url()) &&
         !command_line.HasSwitch(switches::kProcessPerTab))
       return false;
   }
 
   return true;
 }
 
+string16 RenderViewContextMenu::PrintableSelectionText() {
+  return WideToUTF16(l10n_util::TruncateString(params_.selection_text, 50));
+}
+
 // Controller functions --------------------------------------------------------
 
 void RenderViewContextMenu::OpenURL(
     const GURL& url,
     WindowOpenDisposition disposition,
     PageTransition::Type transition) {
   source_tab_contents_->OpenURL(url, GURL(), disposition, transition);
 }
 
 void RenderViewContextMenu::CopyImageAt(int x, int y) {
@@ skipping 12 matching lines @@
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void RenderViewContextMenu::MediaPlayerActionAt(
     const gfx::Point& location,
     const WebMediaPlayerAction& action) {
   source_tab_contents_->render_view_host()->MediaPlayerActionAt(
       location, action);
 }