Extend contextMenus API to support browser/page actions

chrome/browser/extensions/extension_context_menu_model.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 "chrome/browser/extensions/extension_context_menu_model.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/context_menu_params.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/common/extension.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/text_elider.h"
 
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
 using extensions::Extension;
+using extensions::MenuItem;
+using extensions::MenuManager;
 
 ExtensionContextMenuModel::ExtensionContextMenuModel(const Extension* extension,
                                                      Browser* browser,
                                                      PopupDelegate* delegate)
     : SimpleMenuModel(this),
       extension_id_(extension->id()),
       browser_(browser),
       profile_(browser->profile()),
-      delegate_(delegate) {
+      delegate_(delegate),
+      extension_items_(profile_,
+                       this,
+                       this,
+                       base::Bind(MenuItemMatchesParams)) {
   InitMenu(extension);
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode) &&
       delegate_) {
     AddSeparator(ui::NORMAL_SEPARATOR);
     AddItemWithStringId(INSPECT_POPUP, IDS_EXTENSION_ACTION_INSPECT_POPUP);
   }
 }
 
 ExtensionContextMenuModel::ExtensionContextMenuModel(const Extension* extension,
                                                      Browser* browser)
     : SimpleMenuModel(this),
       extension_id_(extension->id()),
       browser_(browser),
       profile_(browser->profile()),
-      delegate_(NULL) {
+      delegate_(NULL),
+      extension_items_(profile_,
+                       this,
+                       this,
+                       base::Bind(MenuItemMatchesParams)) {
   InitMenu(extension);
 }
 
 bool ExtensionContextMenuModel::IsCommandIdChecked(int command_id) const {
+  if (command_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+      command_id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST)
+    return extension_items_.IsCommandIdChecked(command_id);
   return false;
 }
 
 bool ExtensionContextMenuModel::IsCommandIdEnabled(int command_id) const {
   const Extension* extension = this->GetExtension();
   if (!extension)
     return false;
 
   if (command_id == CONFIGURE) {
     return
@@ skipping 22 matching lines @@
     int command_id, ui::Accelerator* accelerator) {
   return false;
 }
 
 void ExtensionContextMenuModel::ExecuteCommand(int command_id,
                                                int event_flags) {
   const Extension* extension = GetExtension();
   if (!extension)
     return;
 
+  if (command_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
+      command_id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST) {
+    WebContents* web_contents =
+        browser_->tab_strip_model()->GetActiveWebContents();
+    content::ContextMenuParams *params = new content::ContextMenuParams();
+    extension_items_.ExecuteCommand(command_id, web_contents, *params);

[gpdavis, 2014/06/26 18:16:02]

I had to remove params when I was porting over all this code, which I figure
isn't an issue.  Here I added a blank params to be passed into ExecuteCommand. 
The code appeared to accommodate for any null values and had default actions.

From what I understood, params contain all the information relevant to a right
click, like what was clicked on, whether there was selected text, etc.  I
figured since this would always be a predictable context from which the menu is
created, that information is irrelevant (ie, we're always clicking on an
extension icon in the top right).

Let me know if this isn't the proper way to approach this.  If we should in fact
have params here, it should be relatively simple to inject the values we need
into params before it's passed in, if any values are necessary for this context.

+    return;
+  }
+
   switch (command_id) {
     case NAME: {
       OpenURLParams params(extensions::ManifestURL::GetHomepageURL(extension),
                            Referrer(), NEW_FOREGROUND_TAB,
                            content::PAGE_TRANSITION_LINK, false);
       browser_->OpenURL(params);
       break;
     }
     case CONFIGURE:
       DCHECK(!extensions::ManifestURL::GetOptionsPage(extension).is_empty());
@@ skipping 54 matching lines @@
   // mnemonics in the menu.
   base::ReplaceChars(extension_name, "&", "&&", &extension_name);
   AddItem(NAME, base::UTF8ToUTF16(extension_name));
   AddSeparator(ui::NORMAL_SEPARATOR);
   AddItemWithStringId(CONFIGURE, IDS_EXTENSIONS_OPTIONS_MENU_ITEM);
   AddItem(UNINSTALL, l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNINSTALL));
   if (extension_action_manager->GetBrowserAction(*extension))
     AddItemWithStringId(HIDE, IDS_EXTENSIONS_HIDE_BUTTON);
   AddSeparator(ui::NORMAL_SEPARATOR);
   AddItemWithStringId(MANAGE, IDS_MANAGE_EXTENSION);
+  AppendExtensionItems();
 }
 
 const Extension* ExtensionContextMenuModel::GetExtension() const {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   return extension_service->GetExtensionById(extension_id_, false);
 }
+
+void ExtensionContextMenuModel::AppendExtensionItems() {
+  LOG(WARNING) << "AppendExtensionItems";
+  extension_items_.Clear();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  if (!service)
+    return;  // In unit-tests, we may not have an ExtensionService.
+
+  MenuManager* menu_manager = MenuManager::Get(profile_);
+  if (!menu_manager)
+    return;
+
+  base::string16 *null_string = new base::string16();
+
+  // Get a list of extension id's that have context menu items, and sort by the
+  // top level context menu title of the extension.
+  std::set<MenuItem::ExtensionKey> ids = menu_manager->ExtensionIds();
+  std::vector<base::string16> sorted_menu_titles;
+  std::map<base::string16, std::string> map_ids;
+  for (std::set<MenuItem::ExtensionKey>::iterator i = ids.begin();
+       i != ids.end();
+       ++i) {
+    const Extension* extension =
+        service->GetExtensionById(i->extension_id, false);
+    // Platform apps have their context menus created directly in
+    // AppendPlatformAppItems.
+    if (extension && !extension->is_platform_app()) {
+      base::string16 menu_title = extension_items_.GetTopLevelContextMenuTitle(
+          *i, *null_string);
+      map_ids[menu_title] = i->extension_id;
+      sorted_menu_titles.push_back(menu_title);
+    }
+  }
+  if (sorted_menu_titles.empty())
+    return;
+
+  const std::string app_locale = g_browser_process->GetApplicationLocale();
+  l10n_util::SortStrings16(app_locale, &sorted_menu_titles);
+
+  int index = 0;
+//  base::TimeTicks begin = base::TimeTicks::Now();
+  for (size_t i = 0; i < sorted_menu_titles.size(); ++i) {
+    LOG(WARNING) << "LOOP " << sorted_menu_titles[i];
+    const std::string& id = map_ids[sorted_menu_titles[i]];
+    const MenuItem::ExtensionKey extension_key(id);
+    extension_items_.AppendExtensionItems(
+        extension_key, *null_string, &index);
+  }
+  LOG(WARNING) << "COMPLETE";
+/*
+  UMA_HISTOGRAM_TIMES("Extensions.ContextMenus_BuildTime",
+                      base::TimeTicks::Now() - begin);
+  UMA_HISTOGRAM_COUNTS("Extensions.ContextMenus_ItemCount", index);

[gpdavis, 2014/06/26 18:16:02]

I wanted to get some clarification on that to make sure I wasn't doing it wrong
here with the histogram stats, so I left it commented out.  Most of this code is
borrowed from RenderViewContextMenu, which was my model for a context menu that
implements the ContextMenuMatcher, the functionality of which I added into
ExtensionContextMenuModel to support extension menu items.

Some direction on how histogram times work and how to add this in properly would
be appreciated.

+  */
+}
+
+bool ExtensionContextMenuModel::MenuItemMatchesParams(
+    const extensions::MenuItem* item) {
+//  MenuItem::ContextList contexts = item->contexts();
+
+//  if (contexts.Contains(MenuItem::ALL)
+//      || context.Contains(MenuItem::BROWSERACTION)
+//      )
+    return true;

[gpdavis, 2014/06/26 18:16:02]

I haven't added a browser_context string yet-- instead I had it show up in the
browser context menu by default (this function also needs to be renamed-- I
forgot to do that when I borrowed the prototype from another class).  This
function is the filter for menu items, and it currently returns true by default,
adding any items to the menu.  The commented out section shows what will be
added once I had that string to the JS.

+
+  return false;
+}
+
+// Helper function to escape "&" as "&&".
+void ExtensionContextMenuModel::EscapeAmpersands(base::string16* text) {
+    base::ReplaceChars(*text, base::ASCIIToUTF16("&"), base::ASCIIToUTF16("&&"),
+                         text);
+}