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

chrome/test/webdriver/webdriver_capabilities_parser.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/test/webdriver/webdriver_capabilities_parser.h"
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
@@ skipping 54 matching lines @@
 
   struct NameAndParser {
     const char* name;
     Parser parser;
   };
   NameAndParser name_and_parser[] = {
     { "proxy", &CapabilitiesParser::ParseProxy },
     { "loggingPrefs", &CapabilitiesParser::ParseLoggingPrefs }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(name_and_parser); ++i) {
-    Value* value;
+    const Value* value;
     if (dict_->Get(name_and_parser[i].name, &value)) {
       Error* error = (this->*name_and_parser[i].parser)(value);
       if (error)
         return error;
     }
   }
 
   // Parse Chrome custom capabilities (a.k.a., ChromeOptions).
   const char kOptionsKey[] = "chromeOptions";
   const DictionaryValue* options = dict_;
   bool legacy_options = true;
-  Value* options_value;
+  const Value* options_value;
   if (dict_->Get(kOptionsKey, &options_value)) {
     legacy_options = false;
     if (options_value->IsType(Value::TYPE_DICTIONARY)) {
-      options = static_cast<DictionaryValue*>(options_value);
+      options = static_cast<const DictionaryValue*>(options_value);
     } else {
       return CreateBadInputError(
           kOptionsKey, Value::TYPE_DICTIONARY, options_value);
     }
   }
 
   std::map<std::string, Parser> parser_map;
   if (legacy_options) {
     parser_map["chrome.binary"] = &CapabilitiesParser::ParseBinary;
     parser_map["chrome.channel"] = &CapabilitiesParser::ParseChannel;
@@ skipping 23 matching lines @@
   }
 
   DictionaryValue::key_iterator key_iter = options->begin_keys();
   for (; key_iter != options->end_keys(); ++key_iter) {
     if (parser_map.find(*key_iter) == parser_map.end()) {
       if (!legacy_options)
         return new Error(kBadRequest,
                          "Unrecognized chrome capability: " +  *key_iter);
       continue;
     }
-    Value* option = NULL;
+    const Value* option = NULL;
     options->GetWithoutPathExpansion(*key_iter, &option);
     Error* error = (this->*parser_map[*key_iter])(option);
     if (error) {
       error->AddDetails(base::StringPrintf(
           "Error occurred while processing capability '%s'",
           (*key_iter).c_str()));
       return error;
     }
   }
   return NULL;
@@ skipping 85 matching lines @@
   const DictionaryValue* logging_prefs;
   if (!option->GetAsDictionary(&logging_prefs))
     return CreateBadInputError("loggingPrefs", Value::TYPE_DICTIONARY, option);
 
   DictionaryValue::key_iterator key_iter = logging_prefs->begin_keys();
   for (; key_iter != logging_prefs->end_keys(); ++key_iter) {
     LogType log_type;
     if (!LogType::FromString(*key_iter, &log_type))
       continue;
 
-    Value* level_value;
+    const Value* level_value;
     logging_prefs->Get(*key_iter, &level_value);
     std::string level_name;
     if (!level_value->GetAsString(&level_name)) {
       return CreateBadInputError(
           std::string("loggingPrefs.") + *key_iter,
           Value::TYPE_STRING,
           level_value);
     }
     caps_->log_levels[log_type.type()] = LogLevelFromString(level_name);
   }
@@ skipping 51 matching lines @@
   typedef Error* (CapabilitiesParser::*Parser)(const DictionaryValue*);
   std::map<std::string, Parser> proxy_type_parser_map;
   proxy_type_parser_map["autodetect"] =
       &CapabilitiesParser::ParseProxyAutoDetect;
   proxy_type_parser_map["pac"] =
       &CapabilitiesParser::ParseProxyAutoconfigUrl;
   proxy_type_parser_map["manual"] = &CapabilitiesParser::ParseProxyServers;
   proxy_type_parser_map["direct"] = NULL;
   proxy_type_parser_map["system"] = NULL;
 
-  Value* proxy_type_value;
+  const Value* proxy_type_value;
   if (!options->Get("proxyType", &proxy_type_value))
     return new Error(kBadRequest, "Missing 'proxyType' capability.");
 
   std::string proxy_type;
   if (!proxy_type_value->GetAsString(&proxy_type))
     return CreateBadInputError("proxyType", Value::TYPE_STRING,
                                proxy_type_value);
 
   proxy_type = StringToLowerASCII(proxy_type);
   if (proxy_type_parser_map.find(proxy_type) == proxy_type_parser_map.end())
@@ skipping 43 matching lines @@
   const char kFtpProxy[] = "ftpProxy";
   const char kHttpProxy[] = "httpProxy";
   const char kSslProxy[] = "sslProxy";
 
   std::set<std::string> proxy_servers_options;
   proxy_servers_options.insert(kFtpProxy);
   proxy_servers_options.insert(kHttpProxy);
   proxy_servers_options.insert(kSslProxy);
 
   Error* error = NULL;
-  Value* option = NULL;
+  const Value* option = NULL;
   bool has_manual_settings = false;
   if (options->Get(kNoProxy, &option) && !option->IsType(Value::TYPE_NULL)) {
     error = ParseNoProxy(option);
     if (error)
       return error;
     has_manual_settings = true;
   }
 
   std::vector<std::string> proxy_servers;
   std::set<std::string>::const_iterator iter = proxy_servers_options.begin();
@@ skipping 36 matching lines @@
 }
 
 Error* CapabilitiesParser::ParseNoWebsiteTestingDefaults(const Value* option) {
   if (!option->GetAsBoolean(&caps_->no_website_testing_defaults))
     return CreateBadInputError("noWebsiteTestingDefaults",
                                Value::TYPE_BOOLEAN, option);
   return NULL;
 }
 
 }  // namespace webdriver