Removing base::DictionaryValue::key_iterator.

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/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
@@ skipping 263 matching lines @@
   }
 
   // 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) {
+  for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
+       it.Advance()) {
     // Get server's host/pair.
-    const std::string& server_str = *it;
+    const std::string& server_str = it.key();
     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;
     }
 
     const base::DictionaryValue* server_pref_dict = NULL;
-    if (!servers_dict->GetDictionaryWithoutPathExpansion(
-        server_str, &server_pref_dict)) {
+    if (!it.value().GetAsDictionary(&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) {
       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;
+        for (base::DictionaryValue::Iterator dict_it(*spdy_settings_dict);
+             !dict_it.IsAtEnd(); dict_it.Advance()) {
+          const std::string& id_str = dict_it.key();
           int id = 0;
           if (!base::StringToInt(id_str, &id)) {
             DVLOG(1) << "Malformed id in SpdySettings for server: " <<
                 server_str;
             NOTREACHED();
             continue;
           }
           int value = 0;
-          if (!spdy_settings_dict->GetIntegerWithoutPathExpansion(id_str,
-                                                                  &value)) {
+          if (!dict_it.value().GetAsInteger(&value)) {
             DVLOG(1) << "Malformed value in SpdySettings for server: " <<
                 server_str;
             NOTREACHED();
             continue;
           }
           net::SettingsFlagsAndValue flags_and_value(
               net::SETTINGS_FLAG_PERSISTED, value);
           settings_map[static_cast<net::SpdySettingsIds>(id)] = flags_and_value;
         }
         (*spdy_settings_map)[server] = settings_map;
@@ skipping 326 matching lines @@
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!setting_prefs_)
     ScheduleUpdateCacheOnUI();
 }
 
 }  // namespace chrome_browser_net