Removing base::DictionaryValue::key_iterator.

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
@@ skipping 1159 matching lines @@
   extension_dict->Remove(kFileEntries, NULL);
 }
 
 void ExtensionPrefs::GetSavedFileEntries(
     const std::string& extension_id,
     std::vector<app_file_handler_util::SavedFileEntry>* out) {
   const DictionaryValue* prefs = GetExtensionPref(extension_id);
   const DictionaryValue* file_entries = NULL;
   if (!prefs->GetDictionary(kFileEntries, &file_entries))
     return;
-  for (DictionaryValue::key_iterator it = file_entries->begin_keys();
-       it != file_entries->end_keys(); ++it) {
-    std::string id = *it;
+  for (DictionaryValue::Iterator it(*file_entries); !it.IsAtEnd();
+       it.Advance()) {
     const DictionaryValue* file_entry = NULL;
-    if (!file_entries->GetDictionaryWithoutPathExpansion(id, &file_entry))
+    if (!it.value().GetAsDictionary(&file_entry))
       continue;
     base::FilePath::StringType path_string;
     if (!file_entry->GetString(kFileEntryPath, &path_string))
       continue;
     bool writable = false;
     if (!file_entry->GetBoolean(kFileEntryWritable, &writable))
       continue;
     base::FilePath file_path(path_string);
     out->push_back(app_file_handler_util::SavedFileEntry(
-        id, file_path, writable));
+        it.key(), file_path, writable));
   }
 }
 
 ExtensionOmniboxSuggestion
 ExtensionPrefs::GetOmniboxDefaultSuggestion(const std::string& extension_id) {
   ExtensionOmniboxSuggestion suggestion;
 
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   const DictionaryValue* dict = NULL;
   if (extension && extension->GetDictionary(kOmniboxDefaultSuggestion, &dict))
@@ skipping 835 matching lines @@
   std::string scope_string;
   bool success = ScopeToPrefKey(scope, &scope_string);
   DCHECK(success);
   std::string key = extension_id + "." + scope_string;
   const DictionaryValue* preferences = NULL;
   // First try the regular lookup.
   const DictionaryValue* source_dict = prefs_->GetDictionary(kExtensionsPref);
   if (!source_dict->GetDictionary(key, &preferences))
     return;
 
-  for (DictionaryValue::Iterator i(*preferences); i.HasNext(); i.Advance()) {
+  for (DictionaryValue::Iterator i(*preferences); !i.IsAtEnd(); i.Advance()) {
     extension_pref_value_map_->SetExtensionPref(
         extension_id, i.key(), scope, i.value().DeepCopy());
   }
 }
 
 void ExtensionPrefs::InitPrefStore(bool extensions_disabled) {
   if (extensions_disabled) {
     extension_pref_value_map_->NotifyInitializationCompleted();
     return;
   }
@@ skipping 373 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions