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 112 matching lines @@
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
                              &val)) {
       (*id)[i] = val + 'a';
     } else {
       (*id)[i] = 'a';
     }
   }
 }
 
+// Loads icon paths defined in dictionary |icons_value| into ExtensionIconSet
+// |icons|. |icons_value| is a dictionary value {icon size -> icon path}. Icons
+// in |icons_value| whose size is not in |icon_sizes| will be ignored.
+// Returns success. If load fails, |error| will be set.
+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 671 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.Pass());
       }
     }
 
     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).
+  // The |default_icon| value can be either dictionary {icon size -> icon path}
+  // or non empty string value.
   if (extension_action->HasKey(keys::kPageActionDefaultIcon)) {
-    if (!extension_action->GetString(keys::kPageActionDefaultIcon,
-                                     &default_icon) ||
-        default_icon.empty()) {
+    const DictionaryValue* icons_value = NULL;
+    std::string default_icon;
+    if (extension_action->GetDictionary(keys::kPageActionDefaultIcon,
+                                        &icons_value)) {
+      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.Pass());
+    } else if (extension_action->GetString(keys::kPageActionDefaultIcon,
+                                           &default_icon) &&
+               !default_icon.empty()) {
+      scoped_ptr<ExtensionIconSet> icon_set(new ExtensionIconSet);
+      icon_set->Add(extension_misc::EXTENSION_ICON_ACTION, default_icon);
+      result->set_default_icon(icon_set.Pass());
+    } else {
       *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return scoped_ptr<ExtensionAction>();
     }
-    result->set_default_icon_path(default_icon);
   }
 
   // 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 507 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 952 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.Pass());
   } else {
-    script_badge_->SetIcon(
-        ExtensionAction::kDefaultTabId,
-        ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-            IDR_EXTENSIONS_FAVICON));
+    script_badge_->set_default_icon(scoped_ptr<ExtensionIconSet>());
   }
 
   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 799 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 {
   return launch_local_path().empty() ? GURL(launch_web_url()) :
                                        url().Resolve(launch_local_path());
 }
@@ skipping 740 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions