Extend contextMenus API to support browser/page actions

chrome/browser/extensions/context_menu_matcher.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/context_menu_matcher.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
+#include "chrome/common/extensions/api/context_menus.h"

[gpdavis, 2014/08/05 01:02:13]

This appears to be the cause of the failed trybots-- this file does not exist on
an android build.

How exactly do I approach this situation?  Should I just wrap the relevant code
and include in an #ifndef for OS_ANDROID?

[Yoyo Zhou, 2014/08/05 01:06:35]

Yes, sort of. Move this to the bottom of the include list, and wrap it in
#if defined(ENABLE_EXTENSIONS)
...
#endif

[gpdavis, 2014/08/05 01:52:28]

Okay, cool.  Don't I also need to wrap the code that uses the constant from this
file (line 258)?

And in the unittest file, I also use this constant.  Does this need to be done
there as well?  (Sorry if this is a dumb question-- just not entirely sure I
understand the environment in which unit tests are run)

[Yoyo Zhou, 2014/08/05 02:16:52]

Ah, sorry. Yes, you need to put that in an ifdef also. I suggest assigning a
name to that constant, similar to lines 24-25, with an #else clause that sets it
to 0.
It's better to not compile the unittest at all on Android. It's already excluded
in the appropriate .gyp file, so this will be fine.

 #include "content/public/browser/browser_context.h"
 #include "content/public/common/context_menu_params.h"
 #include "extensions/browser/extension_system.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
 
 namespace extensions {
 
 namespace {
 
@@ skipping 25 matching lines @@
     const base::Callback<bool(const MenuItem*)>& filter)
     : browser_context_(browser_context),
       menu_model_(menu_model),
       delegate_(delegate),
       filter_(filter) {
 }
 
 void ContextMenuMatcher::AppendExtensionItems(
     const MenuItem::ExtensionKey& extension_key,
     const base::string16& selection_text,
-    int* index) {
+    int* index,
+    bool is_action_menu) {
   DCHECK_GE(*index, 0);
   int max_index =
       extensions_context_custom_last - extensions_context_custom_first;
   if (*index >= max_index)
     return;
 
   const Extension* extension = NULL;
   MenuItem::List items;
   bool can_cross_incognito;
   if (!GetRelevantExtensionTopLevelItems(
           extension_key, &extension, &can_cross_incognito, items))
     return;
 
   if (items.empty())
     return;
 
   // If this is the first extension-provided menu item, and there are other
   // items in the menu, and the last item is not a separator 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, selection_text,
-                                    menu_model_, index);
+  // extension icon next to it), unless the context menu is an an action menu.
+  // Action menus do not include the extension action, and they only include
+  // items from one extension, so they are not placed within a submenu.
+  // Otherwise, we automatically push them into a submenu if there is more than
+  // one top-level item.
+  if (extension->is_platform_app() || is_action_menu) {
+    RecursivelyAppendExtensionItems(items,
+                                    can_cross_incognito,
+                                    selection_text,
+                                    menu_model_,
+                                    index,
+                                    is_action_menu);
   } else {
     int menu_id = ConvertToExtensionsCustomCommandId(*index);
     (*index)++;
     base::string16 title;
     MenuItem::List submenu_items;
 
     if (items.size() > 1 || items[0]->type() != MenuItem::NORMAL) {
       title = base::UTF8ToUTF16(extension->name());
       submenu_items = items;
     } else {
       MenuItem* item = items[0];
       extension_item_map_[menu_id] = item->id();
       title = item->TitleWithReplacement(selection_text,
                                        kMaxExtensionItemTitleLength);
       submenu_items = GetRelevantExtensionItems(item->children(),
                                                 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(delegate_);
       extension_menu_models_.push_back(submenu);
       menu_model_->AddSubMenu(menu_id, title, submenu);
-      RecursivelyAppendExtensionItems(submenu_items, can_cross_incognito,
-                                      selection_text, submenu, index);
+      RecursivelyAppendExtensionItems(submenu_items,
+                                      can_cross_incognito,
+                                      selection_text,
+                                      submenu,
+                                      index,
+                                      false);  // is_action_menu_top_level
     }
-    SetExtensionIcon(extension_key.extension_id);
+    if (!is_action_menu)
+      SetExtensionIcon(extension_key.extension_id);
   }
 }
 
 void ContextMenuMatcher::Clear() {
   extension_item_map_.clear();
   extension_menu_models_.clear();
 }
 
 base::string16 ContextMenuMatcher::GetTopLevelContextMenuTitle(
     const MenuItem::ExtensionKey& extension_key,
@@ skipping 84 matching lines @@
       result.push_back(*i);
   }
   return result;
 }
 
 void ContextMenuMatcher::RecursivelyAppendExtensionItems(
     const MenuItem::List& items,
     bool can_cross_incognito,
     const base::string16& selection_text,
     ui::SimpleMenuModel* menu_model,
-    int* index)
-{
+    int* index,
+    bool is_action_menu_top_level) {
   MenuItem::Type last_type = MenuItem::NORMAL;
   int radio_group_id = 1;
+  int num_items = 0;
 
   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 = ConvertToExtensionsCustomCommandId(*index);
-    (*index)++;
-    if (menu_id >= extensions_context_custom_last)
+    ++(*index);
+    ++num_items;
+    // Action context menus have a limit for top level extension items to
+    // prevent control items from being pushed off the screen, since extension
+    // items will not be placed in a submenu.
+    if (menu_id >= extensions_context_custom_last ||
+        (is_action_menu_top_level &&
+         num_items >= api::context_menus::ACTION_MENU_TOP_LEVEL_LIMIT))
       return;
+
     extension_item_map_[menu_id] = item->id();
     base::string16 title = item->TitleWithReplacement(selection_text,
                                                 kMaxExtensionItemTitleLength);
     if (item->type() == MenuItem::NORMAL) {
       MenuItem::List children =
           GetRelevantExtensionItems(item->children(), can_cross_incognito);
       if (children.empty()) {
         menu_model->AddItem(menu_id, title);
       } else {
         ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(delegate_);
         extension_menu_models_.push_back(submenu);
         menu_model->AddSubMenu(menu_id, title, submenu);
-        RecursivelyAppendExtensionItems(children, can_cross_incognito,
-                                        selection_text, submenu, index);
+        RecursivelyAppendExtensionItems(children,
+                                        can_cross_incognito,
+                                        selection_text,
+                                        submenu,
+                                        index,
+                                        false);  // is_action_menu_top_level
       }
     } 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.
         menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
@@ skipping 26 matching lines @@
   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::CreateFrom1xBitmap(icon));
 }
 
 }  // namespace extensions