Revert 158691 - 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(protocol_handler_submenu_model_(this)),
       protocol_handler_registry_(profile_->GetProtocolHandlerRegistry()) {
 }
 
 RenderViewContextMenu::~RenderViewContextMenu() {
 }
 
 // Menu construction functions -------------------------------------------------
@@ skipping 65 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
-bool RenderViewContextMenu::MenuItemMatchesParams(
+MenuItem::List RenderViewContextMenu::GetRelevantExtensionItems(
+    const MenuItem::List& items,
     const content::ContextMenuParams& params,
-    const extensions::MenuItem* item) {
-  bool match = ExtensionContextAndPatternMatch(params, item->contexts(),
-                                               item->target_url_patterns());
-  if (!match)
-    return false;
+    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 GURL& document_url = GetDocumentURL(params);
-  return ExtensionPatternMatch(item->document_url_patterns(), document_url);
+    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));
 }
 
 void RenderViewContextMenu::AppendAllExtensionItems() {
-  extension_items_.Clear();
+  extension_item_map_.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) {
-    extension_items_.AppendExtensionItems(i->second, PrintableSelectionText(),
-                                       &index);
+    AppendExtensionItems(i->second, &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;
-  extension_items_.AppendExtensionItems(platform_app->id(),
-                                     PrintableSelectionText(), &index);
+  AppendExtensionItems(platform_app->id(), &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 370 matching lines @@
 
   menu_model_.AddSubMenu(
       IDC_CONTENT_CONTEXT_OPENLINKWITH,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_OPENLINKWITH),
       &protocol_handler_submenu_model_);
 }
 
 void RenderViewContextMenu::AppendPlatformEditableItems() {
 }
 
+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) {
-    return extension_items_.IsCommandIdEnabled(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;
   }
 
   IncognitoModePrefs::Availability incognito_avail =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
   switch (id) {
@@ skipping 276 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) {
-    return extension_items_.IsCommandIdChecked(id);
+    MenuItem* item = GetExtensionMenuItem(id);
+    if (item)
+      return item->checked();
+    else
+      return false;
   }
 
 #if defined(ENABLE_INPUT_SPEECH)
   // Check box for menu item 'Block offensive words'.
   if (id == IDC_CONTENT_CONTEXT_SPEECH_INPUT_FILTER_PROFANITIES) {
     return ChromeSpeechRecognitionPreferences::GetForProfile(profile_)->
         FilterProfanities();
   }
 #endif
 
@@ skipping 20 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) {
-    extension_items_.ExecuteCommand(id, params_);
+    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) {
     ProtocolHandlerRegistry::ProtocolHandlerList handlers =
         GetHandlersForLinkUrl();
     if (handlers.empty()) {
       return;
     }
@@ skipping 502 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);
 }