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

chrome/browser/extensions/api/proxy/proxy_api_helpers.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.
 
 // Implementation of helper functions for the Chrome Extensions Proxy Settings
 // API.
 //
 // Throughout this code, we report errors to the user by setting an |error|
 // parameter, if and only if these errors can be cause by invalid input
 // from the extension and we cannot expect that the extensions API has
@@ skipping 62 matching lines @@
     *bad_message = true;
     return false;
   }
   return true;
 }
 
 bool GetPacMandatoryFromExtensionPref(const DictionaryValue* proxy_config,
                                       bool* out,
                                       std::string* error,
                                       bool* bad_message){
-  DictionaryValue* pac_dict = NULL;
+  const DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   bool mandatory_pac = false;
   if (pac_dict->HasKey(keys::kProxyConfigPacScriptMandatory) &&
       !pac_dict->GetBoolean(keys::kProxyConfigPacScriptMandatory,
                             &mandatory_pac)) {
     LOG(ERROR) << "'pacScript.mandatory' could not be parsed.";
     *bad_message = true;
     return false;
   }
   *out = mandatory_pac;
   return true;
 }
 
 bool GetPacUrlFromExtensionPref(const DictionaryValue* proxy_config,
                                 std::string* out,
                                 std::string* error,
                                 bool* bad_message) {
-  DictionaryValue* pac_dict = NULL;
+  const DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   // TODO(battre): Handle UTF-8 URLs (http://crbug.com/72692).
   string16 pac_url16;
   if (pac_dict->HasKey(keys::kProxyConfigPacScriptUrl) &&
       !pac_dict->GetString(keys::kProxyConfigPacScriptUrl, &pac_url16)) {
     LOG(ERROR) << "'pacScript.url' could not be parsed.";
     *bad_message = true;
     return false;
   }
   if (!IsStringASCII(pac_url16)) {
     *error = "'pacScript.url' supports only ASCII URLs "
              "(encode URLs in Punycode format).";
     return false;
   }
   *out = UTF16ToASCII(pac_url16);
   return true;
 }
 
 bool GetPacDataFromExtensionPref(const DictionaryValue* proxy_config,
                                  std::string* out,
                                  std::string* error,
                                  bool* bad_message) {
-  DictionaryValue* pac_dict = NULL;
+  const DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   string16 pac_data16;
   if (pac_dict->HasKey(keys::kProxyConfigPacScriptData) &&
       !pac_dict->GetString(keys::kProxyConfigPacScriptData, &pac_data16)) {
     LOG(ERROR) << "'pacScript.data' could not be parsed.";
     *bad_message = true;
     return false;
@@ skipping 45 matching lines @@
 
   *out = net::ProxyServer(scheme, net::HostPortPair(host, port));
 
   return true;
 }
 
 bool GetProxyRulesStringFromExtensionPref(const DictionaryValue* proxy_config,
                                           std::string* out,
                                           std::string* error,
                                           bool* bad_message) {
-  DictionaryValue* proxy_rules = NULL;
+  const DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigRules, &proxy_rules);
   if (!proxy_rules)
     return true;
 
   // Local data into which the parameters will be parsed. has_proxy describes
   // whether a setting was found for the scheme; proxy_server holds the
   // respective ProxyServer objects containing those descriptions.
   bool has_proxy[keys::SCHEME_MAX + 1];
   net::ProxyServer proxy_server[keys::SCHEME_MAX + 1];
 
   // Looking for all possible proxy types is inefficient if we have a
   // singleProxy that will supersede per-URL proxies, but it's worth it to keep
   // the code simple and extensible.
   for (size_t i = 0; i <= keys::SCHEME_MAX; ++i) {
-    DictionaryValue* proxy_dict = NULL;
+    const DictionaryValue* proxy_dict = NULL;
     has_proxy[i] = proxy_rules->GetDictionary(keys::field_name[i],
                                               &proxy_dict);
     if (has_proxy[i]) {
       net::ProxyServer::Scheme default_scheme = net::ProxyServer::SCHEME_HTTP;
       if (!GetProxyServer(proxy_dict, default_scheme,
                           &proxy_server[i], error, bad_message)) {
         // Don't set |error| here, as GetProxyServer takes care of that.
         return false;
       }
     }
@@ skipping 27 matching lines @@
       proxy_pref.append(keys::scheme_name[i]);
       proxy_pref.append("=");
       proxy_pref.append(proxy_server[i].ToURI());
     }
   }
 
   *out = proxy_pref;
   return true;
 }
 
-bool JoinUrlList(ListValue* list,
+bool JoinUrlList(const ListValue* list,
                  const std::string& joiner,
                  std::string* out,
                  std::string* error,
                  bool* bad_message) {
   std::string result;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     if (!result.empty())
       result.append(joiner);
 
     // TODO(battre): handle UTF-8 (http://crbug.com/72692).
@@ skipping 11 matching lines @@
     result.append(UTF16ToASCII(entry));
   }
   *out = result;
   return true;
 }
 
 bool GetBypassListFromExtensionPref(const DictionaryValue* proxy_config,
                                     std::string *out,
                                     std::string* error,
                                     bool* bad_message) {
-  DictionaryValue* proxy_rules = NULL;
+  const DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigRules, &proxy_rules);
   if (!proxy_rules)
     return true;
 
   if (!proxy_rules->HasKey(keys::kProxyConfigBypassList)) {
     *out = "";
     return true;
   }
-  ListValue* bypass_list = NULL;
+  const ListValue* bypass_list = NULL;
   if (!proxy_rules->GetList(keys::kProxyConfigBypassList, &bypass_list)) {
     LOG(ERROR) << "'rules.bypassList' could not be parsed.";
     *bad_message = true;
     return false;
   }
 
   return JoinUrlList(bypass_list, ",", out, error, bad_message);
 }
 
 DictionaryValue* CreateProxyConfigDict(ProxyPrefs::ProxyMode mode_enum,
@@ skipping 171 matching lines @@
                                 const std::string& delims) {
   ListValue* out = new ListValue;
   StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->Append(Value::CreateStringValue(entries.token()));
   return out;
 }
 
 }  // namespace proxy_api_helpers
 }  // namespace extensions