Change browser/page action default icon defined in manifest to support hidpi.

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 115 matching lines @@
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
                              &val)) {
       (*id)[i] = val + 'a';
     } else {
       (*id)[i] = 'a';
     }
   }
 }
 
+bool LoadIconsFromDictionary(const DictionaryValue* icons_value,
+                             const int* icon_sizes,
+                             size_t num_icon_sizes,
+                             ExtensionIconSet* icons,
+                             string16* error) {
+  DCHECK(icons);
+  for (size_t i = 0; i < num_icon_sizes; ++i) {
+    std::string key = base::IntToString(icon_sizes[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(icon_sizes[i], icon_path);
+    }
+  }
+  return true;
+}
+
 // A singleton object containing global data needed by the extension objects.
 class ExtensionConfig {
  public:
   static ExtensionConfig* GetInstance() {
     return Singleton<ExtensionConfig>::get();
   }
 
   Extension::ScriptingWhitelist* whitelist() { return &scripting_whitelist_; }
 
  private:
@@ skipping 675 matching lines @@
     if (extension_action->HasKey(keys::kPageActionIcons) &&
         extension_action->GetList(keys::kPageActionIcons, &icons)) {
       for (ListValue::const_iterator iter = icons->begin();
            iter != icons->end(); ++iter) {
         std::string path;
         if (!(*iter)->GetAsString(&path) || path.empty()) {
           *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
           return scoped_ptr<ExtensionAction>();
         }
 
-        result->icon_paths()->push_back(path);
+        scoped_ptr<ExtensionIconSet> icon_set(new ExtensionIconSet);
+        icon_set->Add(extension_misc::EXTENSION_ICON_ACTION, path);
+        result->AddPageActionIcon(icon_set.release());
       }
     }
 
     std::string id;
     if (extension_action->HasKey(keys::kPageActionId)) {
       if (!extension_action->GetString(keys::kPageActionId, &id)) {
         *error = ASCIIToUTF16(errors::kInvalidPageActionId);
         return scoped_ptr<ExtensionAction>();
       }
       result->set_id(id);
     }
   }
 
-  std::string default_icon;
-  // Read the page action |default_icon| (optional).
-  if (extension_action->HasKey(keys::kPageActionDefaultIcon)) {
+  if (extension_action->HasKey(keys::kPageActionDefaultIconSet)) {

[tbarzic, 2012/08/30 18:06:45]

I'm not too content with the name here ("default_icon_set").
Do you have any other suggestions?

What do you think of "default_icon" (same as now, when default icon is provided
by path to 19px icon), but allowing the property to be either string (to keep
back compatibility), in which case we assume it represents a path to 19px icon,
or a dictionary introduced here?

+    const DictionaryValue* icons_value = NULL;
+    if (!extension_action->GetDictionary(keys::kPageActionDefaultIconSet,
+                                         &icons_value)) {
+      *error = ASCIIToUTF16(errors::kInvalidIcons);
+      return scoped_ptr<ExtensionAction>();
+    }
+
+    scoped_ptr<ExtensionIconSet> default_icons(new ExtensionIconSet());
+    if (!LoadIconsFromDictionary(icons_value,
+                                 extension_misc::kExtensionActionIconSizes,
+                                 extension_misc::kNumExtensionActionIconSizes,
+                                 default_icons.get(),
+                                 error)) {
+      return scoped_ptr<ExtensionAction>();
+    }
+
+    result->set_default_icon(default_icons.release());
+  } else if (extension_action->HasKey(keys::kPageActionDefaultIcon)) {
+    // Read the page action |default_icon| (optional).
+    std::string default_icon;
     if (!extension_action->GetString(keys::kPageActionDefaultIcon,
                                      &default_icon) ||
         default_icon.empty()) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return scoped_ptr<ExtensionAction>();
     }
-    result->set_default_icon_path(default_icon);
+    scoped_ptr<ExtensionIconSet> icon_set(new ExtensionIconSet);
+    icon_set->Add(extension_misc::EXTENSION_ICON_ACTION, default_icon);
+    result->set_default_icon(icon_set.release());
   }
 
   // Read the page action title from |default_title| if present, |name| if not
   // (both optional).
   std::string title;
   if (extension_action->HasKey(keys::kPageActionDefaultTitle)) {
     if (!extension_action->GetString(keys::kPageActionDefaultTitle, &title)) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
       return scoped_ptr<ExtensionAction>();
     }
@@ skipping 551 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 < 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(extension_misc::kExtensionIconSizes[i], icon_path);
-    }
-  }
-  return true;
+  return LoadIconsFromDictionary(icons_value,
+                                 extension_misc::kExtensionIconSizes,
+                                 extension_misc::kNumExtensionIconSizes,
+                                 &icons_,
+                                 error);
 }
 
 bool Extension::LoadCommands(string16* error) {
   if (manifest_->HasKey(keys::kCommands)) {
     DictionaryValue* commands = NULL;
     if (!manifest_->GetDictionary(keys::kCommands, &commands)) {
       *error = ASCIIToUTF16(errors::kInvalidCommandsKey);
       return false;
     }
 
@@ skipping 903 matching lines @@
   // that matches the icon of a trusted extension, and users wouldn't be warned
   // during installation.
 
   if (!script_badge_->GetTitle(ExtensionAction::kDefaultTabId).empty()) {
     install_warnings_.push_back(
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeTitleIgnored));
   }
   script_badge_->SetTitle(ExtensionAction::kDefaultTabId, name());
 
-  if (!script_badge_->default_icon_path().empty()) {
+  if (script_badge_->default_icon()) {
     install_warnings_.push_back(
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeIconIgnored));
   }
-  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);
+
+  scoped_ptr<ExtensionIconSet> icon_set(new ExtensionIconSet);
+
+  for (size_t i = 0; i < extension_misc::kNumScriptBadgeIconSizes; i++) {
+    std::string path = icons().Get(extension_misc::kScriptBadgeIconSizes[i],
+                                   ExtensionIconSet::MATCH_EXACTLY);
+    if (!path.empty()) {
+      icon_set->Add(extension_misc::kScriptBadgeIconSizes[i], path);
+    }
+  }
+
+  if (!icon_set->map().empty()) {
+    script_badge_->set_default_icon(icon_set.release());
   } else {
-    script_badge_->SetIcon(
-        ExtensionAction::kDefaultTabId,
-        ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-            IDR_EXTENSIONS_FAVICON));
+    script_badge_->set_default_icon(NULL);
   }
 
   return true;
 }
 
 bool Extension::LoadFileBrowserHandlers(string16* error) {
   if (!manifest_->HasKey(keys::kFileBrowserHandlers))
     return true;
   ListValue* file_browser_handlers_value = NULL;
   if (!manifest_->GetList(keys::kFileBrowserHandlers,
@@ skipping 811 matching lines @@
     for (DictionaryValue::key_iterator it = theme_images->begin_keys();
          it != theme_images->end_keys(); ++it) {
       std::string val;
       if (theme_images->GetStringWithoutPathExpansion(*it, &val))
         image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(val)));
     }
   }
 
   // Page action icons.
   if (page_action()) {
-    std::vector<std::string>* icon_paths = page_action()->icon_paths();
-    for (std::vector<std::string>::iterator iter = icon_paths->begin();
-         iter != icon_paths->end(); ++iter) {
-      image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(*iter)));
+    const std::vector<const ExtensionIconSet*>& page_action_icons =
+        page_action()->page_action_icons();
+    for (size_t icon = 0; icon < page_action_icons.size(); icon++) {
+      for (ExtensionIconSet::IconMap::const_iterator iter =
+               page_action_icons[icon]->map().begin();
+           iter != page_action_icons[icon]->map().end();
+           ++iter) {
+        image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
+      }
     }
   }
 
   // Browser action icons.
   if (browser_action()) {
-    std::vector<std::string>* icon_paths = browser_action()->icon_paths();
-    for (std::vector<std::string>::iterator iter = icon_paths->begin();
-         iter != icon_paths->end(); ++iter) {
-      image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(*iter)));
+    const std::vector<const ExtensionIconSet*>& page_action_icons =
+        browser_action()->page_action_icons();
+    for (size_t icon = 0; icon < page_action_icons.size(); icon++) {
+      for (ExtensionIconSet::IconMap::const_iterator iter =
+               page_action_icons[icon]->map().begin();
+           iter != page_action_icons[icon]->map().end();
+           ++iter) {
+        image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
+      }
     }
   }
 
   return image_paths;
 }
 
 GURL Extension::GetFullLaunchURL() const {
   if (!launch_local_path().empty())
     return url().Resolve(launch_local_path());
   else
@@ skipping 709 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions