Initial version of an experimental Extensions Context Menu API.
The proposal for the API is documented at:
http://dev.chromium.org/developers/design-documents/extensions/context-menu-api
Notable limitations in this initial implementation:
-No reliable way to get at the unique, actual node clicked on in contexts like
IMAGE/LINK/etc. We'll need to fix this in the long run - see the API proposal
page for some notes on this.
-No update or deleteAll methods ; the only way you can change items is to delete
by id and re-add.
-We aren't yet matching the UI goal of having the extension items at the
top level include the extension icon on the left. This will require a
refactoring of RenderViewContextMenu to steal some of the code from the
bookmarks bar context menus, which can display favicons.
-The only kind of parent->child menu that currently works is if you have
a single top-level parent, and only one level of children. (This is because
of how RenderViewContextMenu currently works)
-No browser tests that the menu items actually get drawn (will wait on those
until the above mentioned refactor is complete), or API tests (the API may
change a bit based on feedback, at which point I'll write more tests).
-Unit tests need to cover some more cases.
BUG=32363
TEST=Should be able to create context menus with this API.
Review URL: http://codereview.chromium.org/1042003
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@42321 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/chrome/browser/extensions/extension_menu_manager.h b/chrome/browser/extensions/extension_menu_manager.h
new file mode 100644
index 0000000..2e927b7f
--- /dev/null
+++ b/chrome/browser/extensions/extension_menu_manager.h
@@ -0,0 +1,221 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_MENU_MANAGER_H_
+#define CHROME_BROWSER_EXTENSIONS_EXTENSION_MENU_MANAGER_H_
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/linked_ptr.h"
+#include "base/stl_util-inl.h"
+#include "base/string16.h"
+#include "chrome/common/notification_observer.h"
+#include "chrome/common/notification_registrar.h"
+
+struct ContextMenuParams;
+
+class ExtensionMessageService;
+class Profile;
+class TabContents;
+
+// Represents a menu item added by an extension.
+class ExtensionMenuItem {
+ public:
+ // A list of owned ExtensionMenuItem's.
+ typedef std::vector<linked_ptr<ExtensionMenuItem> > List;
+
+ // For context menus, these are the contexts where an item can appear and
+ // potentially be enabled.
+ enum Context {
+ ALL = 1,
+ PAGE = 2,
+ SELECTION = 4,
+ LINK = 8,
+ EDITABLE = 16,
+ IMAGE = 32,
+ VIDEO = 64,
+ AUDIO = 128,
+ };
+
+ // An item can be only one of these types.
+ enum Type {
+ NORMAL,
+ CHECKBOX,
+ RADIO,
+ SEPARATOR
+ };
+
+ // A list of Contexts for an item (where it should be shown/enabled).
+ class ContextList {
+ public:
+ ContextList() : value_(0) {}
+ explicit ContextList(Context context) : value_(context) {}
+ ContextList(const ContextList& other) : value_(other.value_) {}
+
+ void operator=(const ContextList& other) {
+ value_ = other.value_;
+ }
+
+ bool Contains(Context context) const {
+ return (value_ & context) > 0;
+ }
+
+ void Add(Context context) {
+ value_ |= context;
+ }
+
+ private:
+ uint32 value_; // A bitmask of Context values.
+ };
+
+ ExtensionMenuItem(const std::string& extension_id, std::string title,
+ bool checked, Type type, const ContextList& contexts,
+ const ContextList& enabled_contexts);
+ virtual ~ExtensionMenuItem();
+
+ // Simple accessor methods.
+ const std::string& extension_id() const { return extension_id_; }
+ const std::string& title() const { return title_; }
+ int id() const { return id_; }
+ int parent_id() const { return parent_id_; }
+ int child_count() const { return children_.size(); }
+ ContextList contexts() const { return contexts_; }
+ ContextList enabled_contexts() const { return enabled_contexts_; }
+ Type type() const { return type_; }
+ bool checked() const { return checked_; }
+
+ // Returns the child at the given index, or NULL.
+ ExtensionMenuItem* ChildAt(int index) const;
+
+ // Returns the title with any instances of %s replaced by |selection|.
+ string16 TitleWithReplacement(const string16& selection) const;
+
+ protected:
+ friend class ExtensionMenuManager;
+
+ // This is protected because the ExtensionMenuManager is in charge of
+ // assigning unique ids.
+ virtual void set_id(int id) {
+ id_ = id;
+ }
+
+ // Provides direct access to the children of this item.
+ List* children() { return &children_; }
+
+ // Set the checked state to |checked|. Returns true if successful.
+ bool SetChecked(bool checked);
+
+ // Takes ownership of |item| and sets its parent_id_.
+ void AddChild(ExtensionMenuItem* item);
+
+ // Removes child menu item with the given id, returning true if the item was
+ // found and removed, or false otherwise.
+ bool RemoveChild(int child_id);
+
+ private:
+ // The extension that added this item.
+ std::string extension_id_;
+
+ // What gets shown in the menu for this item.
+ std::string title_;
+
+ // A unique id for this item. The value 0 means "not yet assigned".
+ int id_;
+
+ Type type_;
+
+ // This should only be true for items of type CHECKBOX or RADIO.
+ bool checked_;
+
+ // In what contexts should the item be shown?
+ ContextList contexts_;
+
+ // In what contexts should the item be enabled (i.e. not greyed out). This
+ // should be a subset of contexts_.
+ ContextList enabled_contexts_;
+
+ // If this item is a child of another item, the unique id of its parent. If
+ // this is a top-level item with no parent, this will be 0.
+ int parent_id_;
+
+ // Any children this item may have.
+ List children_;
+
+ DISALLOW_COPY_AND_ASSIGN(ExtensionMenuItem);
+};
+
+// This class keeps track of menu items added by extensions.
+class ExtensionMenuManager : public NotificationObserver {
+ public:
+ ExtensionMenuManager();
+ virtual ~ExtensionMenuManager();
+
+ // Returns the ids of extensions which have menu items registered.
+ std::set<std::string> ExtensionIds();
+
+ // Returns a list of all the *top-level* menu items (added via AddContextItem)
+ // for the given extension id, *not* including child items (added via
+ // AddChildItem); although those can be reached via the top-level items'
+ // ChildAt function. A view can then decide how to display these, including
+ // whether to put them into a submenu if there are more than 1.
+ std::vector<const ExtensionMenuItem*> MenuItems(
+ const std::string& extension_id);
+
+ // Takes ownership of |item|. Returns the id assigned to the item. Has the
+ // side-effect of incrementing the next_item_id_ member.
+ int AddContextItem(ExtensionMenuItem* item);
+
+ // Add an item as a child of another item which has been previously added, and
+ // takes ownership of |item|. Returns the id assigned to the item, or 0 on
+ // error. Has the side-effect of incrementing the next_item_id_ member.
+ int AddChildItem(int parent_id, ExtensionMenuItem* child);
+
+ // Removes a context menu item with the given id (whether it is a top-level
+ // item or a child of some other item), returning true if the item was found
+ // and removed or false otherwise.
+ bool RemoveContextMenuItem(int id);
+
+ // Returns the item with the given |id| or NULL.
+ ExtensionMenuItem* GetItemById(int id);
+
+ // Called when a menu item is clicked on by the user.
+ void ExecuteCommand(Profile* profile, TabContents* tab_contents,
+ const ContextMenuParams& params,
+ int menuItemId);
+
+ // Implements the NotificationObserver interface.
+ virtual void Observe(NotificationType type, const NotificationSource& source,
+ const NotificationDetails& details);
+
+ private:
+ // This is a helper function which takes care of de-selecting any other radio
+ // items in the same group (i.e. that are adjacent in the list).
+ void RadioItemSelected(ExtensionMenuItem* item);
+
+ // If an item with |id| is found, |item| will be set to point to it and
+ // |index| will be set to its index within the containing list.
+ void GetItemAndIndex(int id, ExtensionMenuItem** item, size_t* index);
+
+ // We keep items organized by mapping an extension id to a list of items.
+ typedef std::map<std::string, ExtensionMenuItem::List> MenuItemMap;
+ MenuItemMap context_items_;
+
+ // This lets us make lookup by id fast. It maps id to ExtensionMenuItem* for
+ // all items the menu manager knows about, including all children of top-level
+ // items.
+ std::map<int, ExtensionMenuItem*> items_by_id_;
+
+ // The id we will assign to the next item that gets added.
+ int next_item_id_;
+
+ NotificationRegistrar registrar_;
+
+ DISALLOW_COPY_AND_ASSIGN(ExtensionMenuManager);
+};
+
+#endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_MENU_MANAGER_H_
