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

chrome/browser/net/http_server_properties_manager.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/browser/net/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
@@ skipping 235 matching lines @@
 
   const base::DictionaryValue* servers_dict;
   if (version == kMissingVersion) {
     // If http_server_properties_dict has no "version" key and no "servers" key,
     // then the properties for a given server are in
     // http_server_properties_dict[server].
     servers_dict = &http_server_properties_dict;
   } else {
     // The "new" format has "version" and "servers" keys. The properties for a
     // given server is in http_server_properties_dict["servers"][server].
-    base::DictionaryValue* servers_dict_temp = NULL;
+    const base::DictionaryValue* servers_dict_temp = NULL;
     if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
         "servers", &servers_dict_temp)) {
       DVLOG(1) << "Malformed http_server_properties for servers";
       return;
     }
     servers_dict = servers_dict_temp;
   }
 
   // String is host/port pair of spdy server.
   scoped_ptr<StringVector> spdy_servers(new StringVector);
   scoped_ptr<net::SpdySettingsMap> spdy_settings_map(new net::SpdySettingsMap);
   scoped_ptr<net::PipelineCapabilityMap> pipeline_capability_map(
       new net::PipelineCapabilityMap);
   scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
       new net::AlternateProtocolMap);
 
   for (base::DictionaryValue::key_iterator it = servers_dict->begin_keys();
        it != servers_dict->end_keys();
        ++it) {
     // Get server's host/pair.
     const std::string& server_str = *it;
     net::HostPortPair server = net::HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
       detected_corrupted_prefs = true;
       continue;
     }
 
-    base::DictionaryValue* server_pref_dict = NULL;
+    const base::DictionaryValue* server_pref_dict = NULL;
     if (!servers_dict->GetDictionaryWithoutPathExpansion(
         server_str, &server_pref_dict)) {
       DVLOG(1) << "Malformed http_server_properties server: " << server_str;
       detected_corrupted_prefs = true;
       continue;
     }
 
     // Get if server supports Spdy.
     bool supports_spdy = false;
     if ((server_pref_dict->GetBoolean(
          "supports_spdy", &supports_spdy)) && supports_spdy) {
       spdy_servers->push_back(server_str);
     }
 
     // Get SpdySettings.
     DCHECK(!ContainsKey(*spdy_settings_map, server));
     if (version == kVersionNumber) {
-      base::DictionaryValue* spdy_settings_dict = NULL;
+      const base::DictionaryValue* spdy_settings_dict = NULL;
       if (server_pref_dict->GetDictionaryWithoutPathExpansion(
           "settings", &spdy_settings_dict)) {
         net::SettingsMap settings_map;
         for (base::DictionaryValue::key_iterator dict_it =
              spdy_settings_dict->begin_keys();
              dict_it != spdy_settings_dict->end_keys(); ++dict_it) {
           const std::string& id_str = *dict_it;
           int id = 0;
           if (!base::StringToInt(id_str, &id)) {
             DVLOG(1) << "Malformed id in SpdySettings for server: " <<
@@ skipping 20 matching lines @@
     int pipeline_capability = net::PIPELINE_UNKNOWN;
     if ((server_pref_dict->GetInteger(
          "pipeline_capability", &pipeline_capability)) &&
         pipeline_capability != net::PIPELINE_UNKNOWN) {
       (*pipeline_capability_map)[server] =
           static_cast<net::HttpPipelinedHostCapability>(pipeline_capability);
     }
 
     // Get alternate_protocol server.
     DCHECK(!ContainsKey(*alternate_protocol_map, server));
-    base::DictionaryValue* port_alternate_protocol_dict = NULL;
+    const base::DictionaryValue* port_alternate_protocol_dict = NULL;
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
         "alternate_protocol", &port_alternate_protocol_dict)) {
       continue;
     }
 
     do {
       int port = 0;
       if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
           "port", &port) || (port > (1 << 16))) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
@@ skipping 292 matching lines @@
   std::string* pref_name = content::Details<std::string>(details).ptr();
   if (*pref_name == prefs::kHttpServerProperties) {
     if (!setting_prefs_)
       ScheduleUpdateCacheOnUI();
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace chrome_browser_net