Many changes to DictionaryValues:...

chrome/common/extensions/extension.cc

 // Copyright (c) 2009 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 "app/resource_bundle.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 449 matching lines @@
   if (!theme_key_mapped) {
     for (size_t i = 0; i < arraysize(kValidThemeKeys); ++i) {
       theme_keys[kValidThemeKeys[i]] = true;
     }
     theme_key_mapped = true;
   }
 
   // Go through all the root level keys and verify that they're in the map
   // of keys allowable by themes. If they're not, then make a not of it for
   // later.
-  DictionaryValue::key_iterator iter = source.begin_keys();
-  while (iter != source.end_keys()) {
-    std::wstring key = (*iter);
-    if (theme_keys.find(key) == theme_keys.end())
+  for (DictionaryValue::key_iterator iter = source.begin_keys();
+       iter != source.end_keys(); ++iter) {
+    if (theme_keys.find(*iter) == theme_keys.end())
       return true;
-    ++iter;
   }
   return false;
 }
 
 // static
 ExtensionResource Extension::GetResource(const FilePath& extension_path,
                                          const std::string& relative_path) {
   // IsAbsolutePath gets confused on Unix if relative path starts with /.
   // Lets remove leading / if there is one.
   size_t start_pos = relative_path.find_first_not_of("/");
@@ skipping 264 matching lines @@
     DictionaryValue* theme_value;
     if (!source.GetDictionary(keys::kTheme, &theme_value)) {
       *error = errors::kInvalidTheme;
       return false;
     }
     is_theme_ = true;
 
     DictionaryValue* images_value;
     if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
       // Validate that the images are all strings
-      DictionaryValue::key_iterator iter = images_value->begin_keys();
-      while (iter != images_value->end_keys()) {
+      for (DictionaryValue::key_iterator iter = images_value->begin_keys();
+           iter != images_value->end_keys(); ++iter) {
         std::string val;
         if (!images_value->GetString(*iter, &val)) {
           *error = errors::kInvalidThemeImages;
           return false;
         }
-        ++iter;
       }
       theme_images_.reset(
           static_cast<DictionaryValue*>(images_value->DeepCopy()));
     }
 
     DictionaryValue* colors_value;
     if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
-      // Validate that the colors are all three-item lists
-      DictionaryValue::key_iterator iter = colors_value->begin_keys();
-      while (iter != colors_value->end_keys()) {
-        std::string val;
-        int color = 0;
+      // Validate that the colors are RGB or RGBA lists
+      for (DictionaryValue::key_iterator iter = colors_value->begin_keys();
+           iter != colors_value->end_keys(); ++iter) {
         ListValue* color_list;
-        if (colors_value->GetList(*iter, &color_list)) {
-          if (color_list->GetSize() == 3 ||
-              color_list->GetSize() == 4) {
-            if (color_list->GetInteger(0, &color) &&
-                color_list->GetInteger(1, &color) &&
-                color_list->GetInteger(2, &color)) {
-              if (color_list->GetSize() == 4) {
-                double alpha;
-                int alpha_int;
-                if (color_list->GetReal(3, &alpha) ||
-                    color_list->GetInteger(3, &alpha_int)) {
-                  ++iter;
-                  continue;
-                }
-              } else {
-                ++iter;
-                continue;
-              }
-            }
-          }
+        double alpha;
+        int alpha_int;
+        int color;
+        // The color must be a list
+        if (!colors_value->GetListWithoutPathExpansion(*iter, &color_list) ||
+            // And either 3 items (RGB) or 4 (RGBA)
+            ((color_list->GetSize() != 3) &&
+             ((color_list->GetSize() != 4) ||
+              // For RGBA, the fourth item must be a real or int alpha value
+              (!color_list->GetReal(3, &alpha) &&
+               !color_list->GetInteger(3, &alpha_int)))) ||
+            // For both RGB and RGBA, the first three items must be ints (R,G,B)
+            !color_list->GetInteger(0, &color) ||
+            !color_list->GetInteger(1, &color) ||
+            !color_list->GetInteger(2, &color)) {
+          *error = errors::kInvalidThemeColors;
+          return false;
         }
-        *error = errors::kInvalidThemeColors;
-        return false;
       }
       theme_colors_.reset(
           static_cast<DictionaryValue*>(colors_value->DeepCopy()));
     }
 
     DictionaryValue* tints_value;
     if (theme_value->GetDictionary(keys::kThemeTints, &tints_value)) {
       // Validate that the tints are all reals.
-      DictionaryValue::key_iterator iter = tints_value->begin_keys();
-      while (iter != tints_value->end_keys()) {
+      for (DictionaryValue::key_iterator iter = tints_value->begin_keys();
+           iter != tints_value->end_keys(); ++iter) {
         ListValue* tint_list;
-        double v = 0;
-        int vi = 0;
-        if (!tints_value->GetList(*iter, &tint_list) ||
+        double v;
+        int vi;
+        if (!tints_value->GetListWithoutPathExpansion(*iter, &tint_list) ||
             tint_list->GetSize() != 3 ||
             !(tint_list->GetReal(0, &v) || tint_list->GetInteger(0, &vi)) ||
             !(tint_list->GetReal(1, &v) || tint_list->GetInteger(1, &vi)) ||
             !(tint_list->GetReal(2, &v) || tint_list->GetInteger(2, &vi))) {
           *error = errors::kInvalidThemeTints;
           return false;
         }
-        ++iter;
       }
       theme_tints_.reset(
           static_cast<DictionaryValue*>(tints_value->DeepCopy()));
     }
 
     DictionaryValue* display_properties_value;
     if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
         &display_properties_value)) {
       theme_display_properties_.reset(
           static_cast<DictionaryValue*>(display_properties_value->DeepCopy()));
@@ skipping 274 matching lines @@
 
   // Chrome URL overrides (optional)
   if (source.HasKey(keys::kChromeURLOverrides)) {
     DictionaryValue* overrides;
     if (!source.GetDictionary(keys::kChromeURLOverrides, &overrides)) {
       *error = errors::kInvalidChromeURLOverrides;
       return false;
     }
 
     // Validate that the overrides are all strings
-    DictionaryValue::key_iterator iter = overrides->begin_keys();
-    while (iter != overrides->end_keys()) {
+    for (DictionaryValue::key_iterator iter = overrides->begin_keys();
+         iter != overrides->end_keys(); ++iter) {
       std::string page = WideToUTF8(*iter);
       // For now, only allow the new tab page.  Others will work when we remove
       // this check, but let's keep it simple for now.
       // TODO(erikkay) enable other pages as well
-      if (page != chrome::kChromeUINewTabHost) {
-        *error = errors::kInvalidChromeURLOverrides;
-        return false;
-      }
       std::string val;
-      if (!overrides->GetString(*iter, &val)) {
+      if ((page != chrome::kChromeUINewTabHost) ||
+          !overrides->GetStringWithoutPathExpansion(*iter, &val)) {
         *error = errors::kInvalidChromeURLOverrides;
         return false;
       }
       // Replace the entry with a fully qualified chrome-extension:// URL.
       chrome_url_overrides_[page] = GetResourceURL(val);
-      ++iter;
     }
   }
 
   // Although |source| is passed in as a const, it's still possible to modify
   // it.  This is dangerous since the utility process re-uses |source| after
   // it calls InitFromValue, passing it up to the browser process which calls
   // InitFromValue again.  As a result, we need to make sure that nobody
   // accidentally modifies it.
   DCHECK(source.Equals(manifest_value_.get()));
 
   return true;
 }
 
 std::set<FilePath> Extension::GetBrowserImages() {
   std::set<FilePath> image_paths;
 
   // extension icons
   for (std::map<int, std::string>::iterator iter = icons_.begin();
        iter != icons_.end(); ++iter) {
     image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
   }
 
   // theme images
   DictionaryValue* theme_images = GetThemeImages();
   if (theme_images) {
     for (DictionaryValue::key_iterator it = theme_images->begin_keys();
          it != theme_images->end_keys(); ++it) {
       std::wstring val;
-      if (theme_images->GetString(*it, &val)) {
+      if (theme_images->GetStringWithoutPathExpansion(*it, &val))
         image_paths.insert(FilePath::FromWStringHack(val));
-      }
     }
   }
 
   // page action icons
   if (page_action_.get()) {
     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)));
     }
@@ skipping 71 matching lines @@
     UserScript::PatternList::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern) {
       if (pattern->match_subdomains() && pattern->host().empty())
         return true;
     }
   }
 
   return false;
 }