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

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 742 matching lines @@
   path_ = path;
 #endif
 }
 
 ExtensionResource Extension::GetResource(const std::string& relative_path) {
 #if defined(OS_POSIX)
   FilePath relative_file_path(relative_path);
 #elif defined(OS_WIN)
   FilePath relative_file_path(UTF8ToWide(relative_path));
 #endif
-  return ExtensionResource(path(), relative_file_path);
+  return ExtensionResource(id(), path(), relative_file_path);
 }
 
 ExtensionResource Extension::GetResource(const FilePath& relative_file_path) {
-  return ExtensionResource(path(), relative_file_path);
+  return ExtensionResource(id(), path(), relative_file_path);
 }
 
 // TODO(rafaelw): Move ParsePEMKeyBytes, ProducePEM & FormatPEMForOutput to a
 // util class in base:
 // http://code.google.com/p/chromium/issues/detail?id=13572
 bool Extension::ParsePEMKeyBytes(const std::string& input,
                                  std::string* output) {
   DCHECK(output);
   if (!output)
     return false;
@@ skipping 799 matching lines @@
 
 void Extension::SetBackgroundPageReady() {
   DCHECK(!background_url().is_empty());
   background_page_ready_ = true;
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
       Source<Extension>(this),
       NotificationService::NoDetails());
 }
 
+static std::string SizeToString(const gfx::Size& max_size) {
+  return IntToString(max_size.width()) + "x" + IntToString(max_size.height());
+}
+
 void Extension::SetCachedImage(const ExtensionResource& source,
-                               const SkBitmap& image) {
+                               const SkBitmap& image,
+                               const gfx::Size& original_size) {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
-  image_cache_[source.relative_path()] = image;
+  const FilePath& path = source.relative_path();
+  gfx::Size actual_size(image.width(), image.height());
+  if (actual_size == original_size) {
+    image_cache_[ImageCacheKey(path, std::string())] = image;
+  } else {
+    image_cache_[ImageCacheKey(path, SizeToString(actual_size))] = image;
+  }
 }
 
-bool Extension::HasCachedImage(const ExtensionResource& source) {
+bool Extension::HasCachedImage(const ExtensionResource& source,
+                               const gfx::Size& max_size) {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
-  return image_cache_.find(source.relative_path()) != image_cache_.end();
+  return GetCachedImageImpl(source, max_size) != NULL;
 }
 
-SkBitmap Extension::GetCachedImage(const ExtensionResource& source) {
+SkBitmap Extension::GetCachedImage(const ExtensionResource& source,
+                                   const gfx::Size& max_size) {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
-  ImageCache::iterator i = image_cache_.find(source.relative_path());
-  if (i == image_cache_.end())
-    return SkBitmap();
-  return i->second;
+  SkBitmap* image = GetCachedImageImpl(source, max_size);
+  return image ? *image : SkBitmap();
 }
 
+SkBitmap* Extension::GetCachedImageImpl(const ExtensionResource& source,
+                                        const gfx::Size& max_size) {
+  const FilePath& path = source.relative_path();
+
+  // Look for exact size match.
+  ImageCache::iterator i = image_cache_.find(
+      ImageCacheKey(path, SizeToString(max_size)));
+  if (i != image_cache_.end())
+    return &(i->second);
+
+  // If we have the original size version cached, return that if it's small
+  // enough.
+  i = image_cache_.find(ImageCacheKey(path, std::string()));
+  if (i != image_cache_.end()) {
+    SkBitmap& image = i->second;
+    if (image.width() <= max_size.width() &&
+        image.height() <= max_size.height())
+      return &(i->second);
+  }
+
+  return NULL;
+}
+
+
 ExtensionResource Extension::GetIconPath(Icons icon) {
   std::map<int, std::string>::const_iterator iter = icons_.find(icon);
   if (iter == icons_.end())
     return ExtensionResource();
   return GetResource(iter->second);
 }
 
 Extension::Icons Extension::GetIconPathAllowLargerSize(
     ExtensionResource* resource, Icons icon) {
   *resource = GetIconPath(icon);
@@ skipping 87 matching lines @@
         } else {
           return false;
         }
       } else {
         return true;
       }
     }
   }
   return false;
 }