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

chrome/browser/extensions/extension_menu_manager.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_menu_manager.h"
 
 #include <algorithm>
 
+#include "app/resource_bundle.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/json/json_writer.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_resource.h"
+#include "gfx/favicon_size.h"
+#include "gfx/size.h"
+#include "grit/theme_resources.h"
+#include "skia/ext/image_operations.h"
 #include "webkit/glue/context_menu.h"
 
 ExtensionMenuItem::ExtensionMenuItem(const std::string& extension_id,
                                      std::string title,
                                      bool checked, Type type,
                                      const ContextList& contexts,
                                      const ContextList& enabled_contexts)
     : extension_id_(extension_id),
       title_(title),
       id_(0),
@@ skipping 60 matching lines @@
     return false;
   checked_ = checked;
   return true;
 }
 
 void ExtensionMenuItem::AddChild(ExtensionMenuItem* item) {
   item->parent_id_ = id_;
   children_.push_back(item);
 }
 
-ExtensionMenuManager::ExtensionMenuManager() : next_item_id_(1) {
+ExtensionMenuManager::ExtensionMenuManager()
+    : next_item_id_(1),
+      ALLOW_THIS_IN_INITIALIZER_LIST(image_tracker_(this)) {
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
 }
 
 ExtensionMenuManager::~ExtensionMenuManager() {
   MenuItemMap::iterator i;
   for (i = context_items_.begin(); i != context_items_.end(); ++i) {
     STLDeleteElements(&(i->second));
   }
 }
 
 std::set<std::string> ExtensionMenuManager::ExtensionIds() {
   std::set<std::string> id_set;
   for (MenuItemMap::const_iterator i = context_items_.begin();
        i != context_items_.end(); ++i) {
     id_set.insert(i->first);
   }
   return id_set;
 }
 
 const ExtensionMenuItem::List* ExtensionMenuManager::MenuItems(
     const std::string& extension_id) {
   MenuItemMap::iterator i = context_items_.find(extension_id);
   if (i != context_items_.end()) {
     return &(i->second);
   }
   return NULL;
 }
 
-int ExtensionMenuManager::AddContextItem(ExtensionMenuItem* item) {
+int ExtensionMenuManager::AddContextItem(Extension* extension,
+                                         ExtensionMenuItem* item) {
   const std::string& extension_id = item->extension_id();
   // The item must have a non-empty extension id.
   if (extension_id.empty())
     return 0;
 
+  DCHECK_EQ(extension->id(), extension_id);
+
   DCHECK_EQ(0, item->id());
   item->set_id(next_item_id_++);
 
+  bool first_item = !ContainsKey(context_items_, extension_id);
   context_items_[extension_id].push_back(item);
   items_by_id_[item->id()] = item;
 
   if (item->type() == ExtensionMenuItem::RADIO && item->checked())
     RadioItemSelected(item);
 
+  // If this is the first item for this extension, start loading its icon.
+  if (first_item) {
+    ExtensionResource icon_resource;
+    extension->GetIconPathAllowLargerSize(&icon_resource,
+                                          Extension::EXTENSION_ICON_BITTY);
+    if (!icon_resource.extension_root().empty()) {
+      image_tracker_.LoadImage(extension,
+                               icon_resource,
+                               gfx::Size(kFavIconSize, kFavIconSize),
+                               ImageLoadingTracker::CACHE);
+    }
+  }
+
   return item->id();
 }
 
 int ExtensionMenuManager::AddChildItem(int parent_id,
                                        ExtensionMenuItem* child) {
   ExtensionMenuItem* parent = GetItemById(parent_id);
   if (!parent || parent->type() != ExtensionMenuItem::NORMAL ||
       parent->extension_id() != child->extension_id())
     return 0;
   child->set_id(next_item_id_++);
@@ skipping 72 matching lines @@
   if (!ContainsKey(items_by_id_, id))
     return false;
 
   std::string extension_id = GetItemById(id)->extension_id();
   MenuItemMap::iterator i = context_items_.find(extension_id);
   if (i == context_items_.end()) {
     NOTREACHED();
     return false;
   }
 
+  bool result = false;
   ExtensionMenuItem::List& list = i->second;
   ExtensionMenuItem::List::iterator j;
   for (j = list.begin(); j < list.end(); ++j) {
     // See if the current item is a match, or if one of its children was.
     if ((*j)->id() == id) {
       delete *j;
       list.erase(j);
       items_by_id_.erase(id);
-      return true;
+      result = true;
+      break;
     } else if ((*j)->RemoveChild(id)) {
       items_by_id_.erase(id);
-      return true;
+      result = true;
+      break;
     }
   }
-  NOTREACHED();  // The check at the very top should prevent getting here.
-  return false;
+  DCHECK(result);  // The check at the very top should have prevented this.
+
+  if (list.empty() && ContainsKey(extension_icons_, extension_id))
+    extension_icons_.erase(extension_id);
+
+  return result;
 }
 
 void ExtensionMenuManager::RemoveAllContextItems(std::string extension_id) {
   ExtensionMenuItem::List::iterator i;
   for (i = context_items_[extension_id].begin();
        i != context_items_[extension_id].end(); ++i) {
     ExtensionMenuItem* item = *i;
     items_by_id_.erase(item->id());
 
     // Remove descendants from this item and erase them from the lookup cache.
     std::set<int> removed_ids = item->RemoveAllDescendants();
     for (std::set<int>::const_iterator j = removed_ids.begin();
         j != removed_ids.end(); ++j) {
       items_by_id_.erase(*j);
     }
   }
   STLDeleteElements(&context_items_[extension_id]);
   context_items_.erase(extension_id);
+
+  if (ContainsKey(extension_icons_, extension_id))
+    extension_icons_.erase(extension_id);
 }
 
 ExtensionMenuItem* ExtensionMenuManager::GetItemById(int id) const {
   std::map<int, ExtensionMenuItem*>::const_iterator i = items_by_id_.find(id);
   if (i != items_by_id_.end())
     return i->second;
   else
     return NULL;
 }
 
@@ skipping 135 matching lines @@
   // Remove menu items for disabled/uninstalled extensions.
   if (type != NotificationType::EXTENSION_UNLOADED) {
     NOTREACHED();
     return;
   }
   Extension* extension = Details<Extension>(details).ptr();
   if (ContainsKey(context_items_, extension->id())) {
     RemoveAllContextItems(extension->id());
   }
 }
+
+const SkBitmap& ExtensionMenuManager::GetIconForExtension(
+    const std::string& extension_id) {
+  const SkBitmap* result = NULL;
+  if (ContainsKey(extension_icons_, extension_id)) {
+    result = &(extension_icons_[extension_id]);
+  } else {
+    EnsureDefaultIcon();
+    result = &default_icon_;
+  }
+  DCHECK(result);
+  DCHECK(result->width() == kFavIconSize);
+  DCHECK(result->height() == kFavIconSize);
+  return *result;
+}
+
+void ExtensionMenuManager::OnImageLoaded(SkBitmap* image,
+                                         ExtensionResource resource,
+                                         int index) {
+  if (!image)
+    return;
+
+  const std::string extension_id = resource.extension_id();
+
+  // Make sure we still have menu items for this extension (since image loading
+  // is asynchronous, there's a slight chance they may have all been removed
+  // while the icon was loading).
+  if (!ContainsKey(context_items_, extension_id))
+    return;
+
+  if (image->width() == kFavIconSize && image->height() == kFavIconSize)
+    extension_icons_[extension_id] = *image;
+  else
+    extension_icons_[extension_id] = ScaleToFavIconSize(*image);
+}
+
+void ExtensionMenuManager::EnsureDefaultIcon() {
+  if (default_icon_.empty()) {
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+    SkBitmap* src = rb.GetBitmapNamed(IDR_EXTENSIONS_SECTION);
+    if (src->width() == kFavIconSize && src->height() == kFavIconSize) {
+      default_icon_ = *src;
+    } else {
+      default_icon_ = SkBitmap(ScaleToFavIconSize(*src));
+    }
+  }
+}
+
+SkBitmap ExtensionMenuManager::ScaleToFavIconSize(const SkBitmap& source) {
+  return skia::ImageOperations::Resize(source,
+                                       skia::ImageOperations::RESIZE_LANCZOS3,
+                                       kFavIconSize,
+                                       kFavIconSize);
+}