Generalize ExtensionIconSet to store icon paths for custom size sets

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 1403 matching lines @@
 
 bool Extension::LoadIcons(string16* error) {
   if (!manifest_->HasKey(keys::kIcons))
     return true;
   DictionaryValue* icons_value = NULL;
   if (!manifest_->GetDictionary(keys::kIcons, &icons_value)) {
     *error = ASCIIToUTF16(errors::kInvalidIcons);
     return false;
   }
 
-  for (size_t i = 0; i < ExtensionIconSet::kNumIconSizes; ++i) {
-    std::string key = base::IntToString(ExtensionIconSet::kIconSizes[i]);
+  for (size_t i = 0; i < extension_misc::kNumExtensionIconSizes; ++i) {
+    std::string key =
+        base::IntToString(extension_misc::kExtensionIconSizes[i]);
     if (icons_value->HasKey(key)) {
       std::string icon_path;
       if (!icons_value->GetString(key, &icon_path)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidIconPath, key);
         return false;
       }
 
       if (!icon_path.empty() && icon_path[0] == '/')
         icon_path = icon_path.substr(1);
 
       if (icon_path.empty()) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidIconPath, key);
         return false;
       }
-      icons_.Add(ExtensionIconSet::kIconSizes[i], icon_path);
+      icons_.Add(extension_misc::kExtensionIconSizes[i], icon_path);
     }
   }
   return true;
 }
 
 bool Extension::LoadCommands(string16* error) {
   if (manifest_->HasKey(keys::kCommands)) {
     DictionaryValue* commands = NULL;
     if (!manifest_->GetDictionary(keys::kCommands, &commands)) {
       *error = ASCIIToUTF16(errors::kInvalidCommandsKey);
@@ skipping 911 matching lines @@
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeTitleIgnored));
   }
   script_badge_->SetTitle(ExtensionAction::kDefaultTabId, name());
 
   if (!script_badge_->default_icon_path().empty()) {
     install_warnings_.push_back(
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeIconIgnored));
   }
-  std::string icon16_path = icons().Get(ExtensionIconSet::EXTENSION_ICON_BITTY,
+  std::string icon16_path = icons().Get(extension_misc::EXTENSION_ICON_BITTY,
                                         ExtensionIconSet::MATCH_EXACTLY);
   if (!icon16_path.empty()) {
     script_badge_->set_default_icon_path(icon16_path);
   } else {
     script_badge_->SetIcon(
         ExtensionAction::kDefaultTabId,
         ui::ResourceBundle::GetSharedInstance().GetImageNamed(
             IDR_EXTENSIONS_FAVICON));
   }
 
@@ skipping 622 matching lines @@
   output->append(is_public ? kPublic : kPrivate);
   output->append(" ");
   output->append(kKeyInfoEndMarker);
   output->append("\n");
 
   return true;
 }
 
 // static
 void Extension::DecodeIcon(const Extension* extension,
-                           ExtensionIconSet::Icons preferred_icon_size,
+                           int preferred_icon_size,
                            ExtensionIconSet::MatchType match_type,
                            scoped_ptr<SkBitmap>* result) {
   std::string path = extension->icons().Get(preferred_icon_size, match_type);
-  ExtensionIconSet::Icons size = extension->icons().GetIconSizeFromPath(path);
+  int size = extension->icons().GetIconSizeFromPath(path);
   ExtensionResource icon_resource = extension->GetResource(path);
   DecodeIconFromPath(icon_resource.GetFilePath(), size, result);
 }
 
 // static
 void Extension::DecodeIcon(const Extension* extension,
-                           ExtensionIconSet::Icons icon_size,
+                           int icon_size,
                            scoped_ptr<SkBitmap>* result) {
   DecodeIcon(extension, icon_size, ExtensionIconSet::MATCH_EXACTLY, result);
 }
 
 // static
 void Extension::DecodeIconFromPath(const FilePath& icon_path,
-                                   ExtensionIconSet::Icons icon_size,
+                                   int icon_size,
                                    scoped_ptr<SkBitmap>* result) {
   if (icon_path.empty())
     return;
 
   std::string file_contents;
   if (!file_util::ReadFileToString(icon_path, &file_contents)) {
     DLOG(ERROR) << "Could not read icon file: " << icon_path.LossyDisplayName();
     return;
   }
 
@@ skipping 879 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions