Normalize extension action icon paths before adding them to icon set

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';
     }
   }
 }
 
+// Strips leading slashes from the file path. Returns true iff the final path is
+// non empty.
+bool NormalizeAndValidatePath(std::string* path) {
+  size_t first_non_slash = path->find_first_not_of('/');
+  if (first_non_slash == std::string::npos) {
+    *path = "";
+    return false;
+  }
+
+  *path = path->substr(first_non_slash);
+  return true;
+}
+
 // 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()) {
+      if (!NormalizeAndValidatePath(&icon_path)) {
         *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() {
@@ skipping 674 matching lines @@
 
   if (manifest_version_ == 1) {
     // kPageActionIcons is obsolete, and used by very few extensions. Continue
     // loading it, but only take the first icon as the default_icon path.
     const ListValue* icons = NULL;
     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()) {
+        if (!(*iter)->GetAsString(&path) || !NormalizeAndValidatePath(&path)) {
           *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
           return scoped_ptr<ExtensionAction>();
         }
 
         scoped_ptr<ExtensionIconSet> icon_set(new ExtensionIconSet);
         icon_set->Add(extension_misc::EXTENSION_ICON_ACTION, path);
         result->set_default_icon(icon_set.Pass());
         break;
       }
     }
@@ skipping 21 matching lines @@
                                    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()) {
+               NormalizeAndValidatePath(&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.Pass());
     } else {
       *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return scoped_ptr<ExtensionAction>();
     }
   }
 
   // Read the page action title from |default_title| if present, |name| if not
@@ skipping 1502 matching lines @@
     install_warnings_.push_back(
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeIconIgnored));
   }
 
   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()) {
+    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_->set_default_icon(scoped_ptr<ExtensionIconSet>());
   }
 
   return true;
 }
@@ skipping 1588 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions