Show extension icons next to their top-level context menu items....

chrome/browser/extensions/extension_menu_manager.h

 // 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/browser/extensions/image_loading_tracker.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 
 struct ContextMenuParams;
 
+class Extension;
 class ExtensionMessageService;
 class Profile;
 class TabContents;
 
 // Represents a menu item added by an extension.
 class ExtensionMenuItem {
  public:
   // A list of ExtensionMenuItem's.
   typedef std::vector<ExtensionMenuItem*> List;
 
@@ skipping 128 matching lines @@
   // 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 {
+class ExtensionMenuManager
+    : public ImageLoadingTracker::Observer,
+      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'
   // children. A view can then decide how to display these, including whether to
   // put them into a submenu if there are more than 1.
   const ExtensionMenuItem::List* 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);
+  // Adds a top-level menu item for an extension, requiring the |extension|
+  // pointer so it can load the icon for the extension. Takes ownership of
+  // |item|. Returns the id assigned to the item. Has the side-effect of
+  // incrementing the next_item_id_ member.
+  int AddContextItem(Extension* extension, 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);
 
   // Makes existing item with |child_id| a child of the item with |parent_id|.
   // If the child item was already a child of another parent, this will remove
   // it from that parent first. It is an error to try and move an item to be a
   // child of one of its own descendants.
@@ skipping 12 matching lines @@
 
   // 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);
 
+  // This returns a bitmap of width/height kFavIconSize, loaded either from an
+  // entry specified in the extension's 'icon' section of the manifest, or a
+  // default extension icon.
+  const SkBitmap& GetIconForExtension(const std::string& extension_id);
+
+  // Implements the ImageLoadingTracker::Observer interface.
+  virtual void OnImageLoaded(SkBitmap* image, ExtensionResource resource,
+                             int index);
+
  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);
 
   // Returns true if item is a descendant of an item with id |ancestor_id|.
   bool DescendantOf(ExtensionMenuItem* item, int ancestor_id);
 
+  // Makes sure we've done one-time initialization of the default extension icon
+  // default_icon_.
+  void EnsureDefaultIcon();
+
+  // Helper function to return a copy of |src| scaled to kFavIconSize.
+  SkBitmap ScaleToFavIconSize(const SkBitmap& src);
+
   // 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_;
 
+  // Used for loading extension icons.
+  ImageLoadingTracker image_tracker_;
+
+  // Maps extension id to an SkBitmap with the icon for that extension.
+  std::map<std::string, SkBitmap> extension_icons_;
+
+  // The default icon we'll use if an extension doesn't have one.
+  SkBitmap default_icon_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionMenuManager);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_MENU_MANAGER_H_