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

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 209 matching lines @@
   if (page_url.SchemeIs("chrome-extension") &&
       page_url.DomainIs(kFileBrowserDomain))
     return false;
 #endif
 
   return true;
 }
 }  // namespace
 
 // static
-const size_t RenderViewContextMenu::kMaxExtensionItemTitleLength = 75;
-// static
 const size_t RenderViewContextMenu::kMaxSelectionTextLength = 50;
 
 // static
 bool RenderViewContextMenu::IsDevToolsURL(const GURL& url) {
   return url.SchemeIs(chrome::kChromeDevToolsScheme) &&
       url.host() == chrome::kChromeUIDevToolsHost;
 }
 
 // static
 bool RenderViewContextMenu::IsInternalResourcesURL(const GURL& url) {
   if (!url.SchemeIs(chrome::kChromeUIScheme))
     return false;
   return url.host() == chrome::kChromeUISyncResourcesHost;
 }
 
 static const int kSpellcheckRadioGroup = 1;
 
 RenderViewContextMenu::RenderViewContextMenu(
     WebContents* web_contents,
     const content::ContextMenuParams& params)
     : params_(params),
       source_web_contents_(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       ALLOW_THIS_IN_INITIALIZER_LIST(menu_model_(this)),
+      extension_items_(profile_, this, &menu_model_,
+                    base::Bind(MenuItemMatchesParams, params_)),
       external_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(speech_input_submenu_model_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(bidi_submenu_model_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(protocol_handler_submenu_model_(this)),
       protocol_handler_registry_(profile_->GetProtocolHandlerRegistry()) {
 }
 
 RenderViewContextMenu::~RenderViewContextMenu() {
 }
 
@@ skipping 66 matching lines @@
       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
-MenuItem::List RenderViewContextMenu::GetRelevantExtensionItems(
-    const MenuItem::List& items,
+bool RenderViewContextMenu::MenuItemMatchesParams(
     const content::ContextMenuParams& params,
-    Profile* profile,
-    bool can_cross_incognito) {
-  MenuItem::List result;
-  for (MenuItem::List::const_iterator i = items.begin();
-       i != items.end(); ++i) {
-    const MenuItem* item = *i;
+    const extensions::MenuItem* item) {
+  bool match = ExtensionContextAndPatternMatch(params, item->contexts(),
+                                               item->target_url_patterns());
+  if (!match)
+    return false;
 
-    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();
-  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 MenuItem::List* all_items = manager->MenuItems(extension_id);
-  if (!all_items || all_items->empty())
-    return;
-  bool can_cross_incognito = service->CanCrossIncognito(extension);
-  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(ui::NORMAL_SEPARATOR);
-
-  // Extensions (other than platform apps) 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.
-  if (extension->is_platform_app()) {
-    RecursivelyAppendExtensionItems(items, can_cross_incognito, &menu_model_,
-                                    index);
-  } else {
-    int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
-    string16 title;
-    MenuItem::List submenu_items;
-
-    if (items.size() > 1 || items[0]->type() != MenuItem::NORMAL) {
-      title = UTF8ToUTF16(extension->name());
-      submenu_items = items;
-    } else {
-      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 MenuItem::List& items,
-    bool can_cross_incognito,
-    ui::SimpleMenuModel* menu_model,
-    int* index) {
-  string16 selection_text = PrintableSelectionText();
-  MenuItem::Type last_type = MenuItem::NORMAL;
-  int radio_group_id = 1;
-
-  for (MenuItem::List::const_iterator i = items.begin();
-       i != items.end(); ++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 == MenuItem::RADIO &&
-        item->type() != MenuItem::RADIO) {
-      menu_model->AddSeparator(ui::NORMAL_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() == 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() == MenuItem::CHECKBOX) {
-      menu_model->AddCheckItem(menu_id, title);
-    } else if (item->type() == MenuItem::RADIO) {
-      if (i != items.begin() &&
-          last_type != MenuItem::RADIO) {
-        radio_group_id++;
-
-        // Auto-append a separator if needed.
-        if (last_type != MenuItem::SEPARATOR)
-          menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
-      }
-
-      menu_model->AddRadioItem(menu_id, title, radio_group_id);
-    } else if (item->type() == MenuItem::SEPARATOR) {
-      if (i != items.begin() && last_type != MenuItem::SEPARATOR) {
-        menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
-      }
-    }
-    last_type = item->type();
-  }
-}
-
-void RenderViewContextMenu::SetExtensionIcon(const std::string& extension_id) {
-  ExtensionService* service = profile_->GetExtensionService();
-  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, gfx::Image(icon));
+  const GURL& document_url = GetDocumentURL(params);
+  return ExtensionPatternMatch(item->document_url_patterns(), document_url);
 }
 
 void RenderViewContextMenu::AppendAllExtensionItems() {
-  extension_item_map_.clear();
+  extension_items_.Clear();
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return;  // In unit-tests, we may not have an ExtensionService.
   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())
       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());
 
   if (sorted_ids.empty())
     return;
 
   int index = 0;
   base::TimeTicks begin = base::TimeTicks::Now();
   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);
+    extension_items_.AppendExtensionItems(i->second, PrintableSelectionText(),
+                                       &index);
   }
   UMA_HISTOGRAM_TIMES("Extensions.ContextMenus_BuildTime",
                       base::TimeTicks::Now() - begin);
   UMA_HISTOGRAM_COUNTS("Extensions.ContextMenus_ItemCount", index);
 }
 
 void RenderViewContextMenu::InitMenu() {
   chrome::ViewType view_type = chrome::GetViewType(source_web_contents_);
   if (view_type == chrome::VIEW_TYPE_APP_SHELL) {
     AppendPlatformAppItems();
@@ skipping 110 matching lines @@
 
   bool has_selection = !params_.selection_text.empty();
 
   // Add undo/redo, cut/copy/paste etc for text fields
   if (params_.is_editable)
     AppendEditableItems();
   else if (has_selection)
     AppendCopyItem();
 
   int index = 0;
-  AppendExtensionItems(platform_app->id(), &index);
+  extension_items_.AppendExtensionItems(platform_app->id(),
+                                     PrintableSelectionText(), &index);
 
   // Add dev tools for unpacked extensions.
   if (platform_app->location() == Extension::LOAD) {
     menu_model_.AddItemWithStringId(IDC_RELOAD, IDS_CONTENT_CONTEXT_RELOAD);
     AppendDeveloperItems();
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE,
                                     IDS_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE);
   }
 }
 
@@ skipping 389 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_);
 }
 
-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()) {
-    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
   // observer.
   ObserverListBase<RenderViewContextMenuObserver>::Iterator it(observers_);
   RenderViewContextMenuObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     if (observer->IsCommandIdSupported(id))
       return observer->IsCommandIdEnabled(id);
@@ skipping 19 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) {
-    MenuItem* item = GetExtensionMenuItem(id);
-    // If this is the parent menu item, it is always enabled.
-    if (!item)
-      return true;
-    return item->enabled();
+    return extension_items_.IsCommandIdEnabled(id);
   }
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
     return true;
   }
 
   IncognitoModePrefs::Availability incognito_avail =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
   switch (id) {
@@ skipping 288 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) {
-    MenuItem* item = GetExtensionMenuItem(id);
-    if (item)
-      return item->checked();
-    else
-      return false;
+    return extension_items_.IsCommandIdChecked(id);
   }
 
 #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)
@@ skipping 34 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) {
-    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);
-    }
+    extension_items_.ExecuteCommand(id, params_);
     return;
   }
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
     ProtocolHandlerRegistry::ProtocolHandlerList handlers =
         GetHandlersForLinkUrl();
     if (handlers.empty()) {
       return;
     }
@@ skipping 518 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);
 }