Correct const accessors in base/values.(h|cc)

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 580 matching lines @@
     bool all_frames = false;
     if (!content_script->GetBoolean(keys::kAllFrames, &all_frames)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidAllFrames, base::IntToString(definition_index));
       return false;
     }
     result->set_match_all_frames(all_frames);
   }
 
   // matches (required)
-  ListValue* matches = NULL;
+  const ListValue* matches = NULL;
   if (!content_script->GetList(keys::kMatches, &matches)) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidMatches,
         base::IntToString(definition_index));
     return false;
   }
 
   if (matches->GetSize() == 0) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidMatchCount,
@@ skipping 31 matching lines @@
       if (!(creation_flags_ & ALLOW_FILE_ACCESS))
         pattern.SetValidSchemes(
             pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
     }
 
     result->add_url_pattern(pattern);
   }
 
   // exclude_matches
   if (content_script->HasKey(keys::kExcludeMatches)) {  // optional
-    ListValue* exclude_matches = NULL;
+    const ListValue* exclude_matches = NULL;
     if (!content_script->GetList(keys::kExcludeMatches, &exclude_matches)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidExcludeMatches,
           base::IntToString(definition_index));
       return false;
     }
 
     for (size_t j = 0; j < exclude_matches->GetSize(); ++j) {
       std::string match_str;
       if (!exclude_matches->GetString(j, &match_str)) {
@@ skipping 26 matching lines @@
                        error, &UserScript::add_glob, result)) {
       return false;
   }
 
   if (!LoadGlobsHelper(content_script, definition_index, keys::kExcludeGlobs,
                        error, &UserScript::add_exclude_glob, result)) {
       return false;
   }
 
   // js and css keys
-  ListValue* js = NULL;
+  const ListValue* js = NULL;
   if (content_script->HasKey(keys::kJs) &&
       !content_script->GetList(keys::kJs, &js)) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidJsList,
         base::IntToString(definition_index));
     return false;
   }
 
-  ListValue* css = NULL;
+  const ListValue* css = NULL;
   if (content_script->HasKey(keys::kCss) &&
       !content_script->GetList(keys::kCss, &css)) {
     *error = ExtensionErrorUtils::
         FormatErrorMessageUTF16(errors::kInvalidCssList,
         base::IntToString(definition_index));
     return false;
   }
 
   // The manifest needs to have at least one js or css user script definition.
   if (((js ? js->GetSize() : 0) + (css ? css->GetSize() : 0)) == 0) {
@@ skipping 47 matching lines @@
 bool Extension::LoadGlobsHelper(
     const DictionaryValue* content_script,
     int content_script_index,
     const char* globs_property_name,
     string16* error,
     void(UserScript::*add_method)(const std::string& glob),
     UserScript* instance) {
   if (!content_script->HasKey(globs_property_name))
     return true;  // they are optional
 
-  ListValue* list = NULL;
+  const ListValue* list = NULL;
   if (!content_script->GetList(globs_property_name, &list)) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidGlobList,
         base::IntToString(content_script_index),
         globs_property_name);
     return false;
   }
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string glob;
@@ skipping 17 matching lines @@
     ExtensionAction::Type action_type,
     string16* error) {
   scoped_ptr<ExtensionAction> result(new ExtensionAction(id(), action_type));
 
   // Page actions are hidden/disabled by default, and browser actions are
   // visible/enabled by default.
   result->SetIsVisible(ExtensionAction::kDefaultTabId,
                        action_type != ExtensionAction::TYPE_PAGE);
 
   if (manifest_version_ == 1) {
-    ListValue* icons = NULL;
+    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()) {
           *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
           return scoped_ptr<ExtensionAction>();
         }
 
@@ skipping 50 matching lines @@
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPageActionOldAndNewKeys,
           keys::kPageActionDefaultPopup,
           keys::kPageActionPopup);
       return scoped_ptr<ExtensionAction>();
     }
     popup_key = keys::kPageActionPopup;
   }
 
   if (popup_key) {
-    DictionaryValue* popup = NULL;
+    const DictionaryValue* popup = NULL;
     std::string url_str;
 
     if (extension_action->GetString(popup_key, &url_str)) {
       // On success, |url_str| is set.  Nothing else to do.
     } else if (manifest_version_ == 1 &&
                extension_action->GetDictionary(popup_key, &popup)) {
       if (!popup->GetString(keys::kPageActionPopupPath, &url_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, "<missing>");
         return scoped_ptr<ExtensionAction>();
@@ skipping 1003 matching lines @@
 
 bool Extension::LoadWebIntentAction(const std::string& action_name,
                                     const DictionaryValue& intent_service,
                                     string16* error) {
   DCHECK(error);
   webkit_glue::WebIntentServiceData service;
   std::string value;
 
   service.action = UTF8ToUTF16(action_name);
 
-  ListValue* mime_types = NULL;
+  const ListValue* mime_types = NULL;
   if (!intent_service.HasKey(keys::kIntentType) ||
       !intent_service.GetList(keys::kIntentType, &mime_types) ||
       mime_types->GetSize() == 0) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidIntentType, action_name);
     return false;
   }
 
   std::string href;
   if (intent_service.HasKey(keys::kIntentPath)) {
@@ skipping 516 matching lines @@
   // Read the page action title from |default_title| (mandatory).
   std::string title;
   if (!file_browser_handler->HasKey(keys::kPageActionDefaultTitle) ||
       !file_browser_handler->GetString(keys::kPageActionDefaultTitle, &title)) {
     *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
     return NULL;
   }
   result->set_title(title);
 
   // Initialize access permissions (optional).
-  ListValue* access_list_value = NULL;
+  const ListValue* access_list_value = NULL;
   if (file_browser_handler->HasKey(keys::kFileAccessList)) {
     if (!file_browser_handler->GetList(keys::kFileAccessList,
                                        &access_list_value) ||
         access_list_value->empty()) {
       *error = ASCIIToUTF16(errors::kInvalidFileAccessList);
       return NULL;
     }
     for (size_t i = 0; i < access_list_value->GetSize(); ++i) {
       std::string access;
       if (!access_list_value->GetString(i, &access) ||
           result->AddFileAccessPermission(access)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidFileAccessValue, base::IntToString(i));
         return NULL;
       }
     }
   }
   if (!result->ValidateFileAccessPermissions()) {
     *error = ASCIIToUTF16(errors::kInvalidFileAccessList);
     return NULL;
   }
 
   // Initialize file filters (mandatory, unless "create" access is specified,
   // in which case is ignored).
   if (!result->HasCreateAccessPermission()) {
-    ListValue* list_value = NULL;
+    const ListValue* list_value = NULL;
     if (!file_browser_handler->HasKey(keys::kFileFilters) ||
         !file_browser_handler->GetList(keys::kFileFilters, &list_value) ||
         list_value->empty()) {
       *error = ASCIIToUTF16(errors::kInvalidFileFiltersList);
       return NULL;
     }
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       std::string filter;
       if (!list_value->GetString(i, &filter)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
@@ skipping 311 matching lines @@
   if (!LoadThemeTints(theme_value, error))
     return false;
   if (!LoadThemeDisplayProperties(theme_value, error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadThemeImages(const DictionaryValue* theme_value,
                                 string16* error) {
-  DictionaryValue* images_value = NULL;
+  const DictionaryValue* images_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
     // Validate that the images are all strings
     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 = ASCIIToUTF16(errors::kInvalidThemeImages);
         return false;
       }
     }
     theme_images_.reset(images_value->DeepCopy());
   }
   return true;
 }
 
 bool Extension::LoadThemeColors(const DictionaryValue* theme_value,
                                 string16* error) {
-  DictionaryValue* colors_value = NULL;
+  const DictionaryValue* colors_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
     // 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 = NULL;
+      const ListValue* color_list = NULL;
       double alpha = 0.0;
       int color = 0;
       // 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.
             // Note that GetDouble() can get an integer value.
             !color_list->GetDouble(3, &alpha))) ||
           // 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 = ASCIIToUTF16(errors::kInvalidThemeColors);
         return false;
       }
     }
     theme_colors_.reset(colors_value->DeepCopy());
   }
   return true;
 }
 
 bool Extension::LoadThemeTints(const DictionaryValue* theme_value,
                                string16* error) {
-  DictionaryValue* tints_value = NULL;
+  const DictionaryValue* tints_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeTints, &tints_value)) {
     // Validate that the tints are all reals.
     for (DictionaryValue::key_iterator iter = tints_value->begin_keys();
          iter != tints_value->end_keys(); ++iter) {
-      ListValue* tint_list = NULL;
+      const ListValue* tint_list = NULL;
       double v = 0.0;
       if (!tints_value->GetListWithoutPathExpansion(*iter, &tint_list) ||
           tint_list->GetSize() != 3 ||
           !tint_list->GetDouble(0, &v) ||
           !tint_list->GetDouble(1, &v) ||
           !tint_list->GetDouble(2, &v)) {
         *error = ASCIIToUTF16(errors::kInvalidThemeTints);
         return false;
       }
     }
     theme_tints_.reset(tints_value->DeepCopy());
   }
   return true;
 }
 
 bool Extension::LoadThemeDisplayProperties(const DictionaryValue* theme_value,
                                            string16* error) {
-  DictionaryValue* display_properties_value = NULL;
+  const DictionaryValue* display_properties_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
                                  &display_properties_value)) {
     theme_display_properties_.reset(
         display_properties_value->DeepCopy());
   }
   return true;
 }
 
 // static
 bool Extension::IsTrustedId(const std::string& id) {
@@ skipping 996 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions