Many changes to DictionaryValues:...

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2009 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/string_util.h"
 #include "chrome/common/extensions/extension.h"
 
 namespace {
@@ skipping 32 matching lines @@
 InstalledExtensions::InstalledExtensions(ExtensionPrefs* prefs) {
   extension_data_.reset(prefs->CopyCurrentExtensions());
 }
 
 InstalledExtensions::~InstalledExtensions() {
 }
 
 void InstalledExtensions::VisitInstalledExtensions(
     InstalledExtensions::Callback *callback) {
   scoped_ptr<InstalledExtensions::Callback> cleanup(callback);
-  DictionaryValue::key_iterator extension_id = extension_data_->begin_keys();
-  for (; extension_id != extension_data_->end_keys(); ++extension_id) {
+  for (DictionaryValue::key_iterator extension_id(
+           extension_data_->begin_keys());
+       extension_id != extension_data_->end_keys(); ++extension_id) {
     DictionaryValue* ext;
-    if (!extension_data_->GetDictionary(*extension_id, &ext)) {
+    if (!extension_data_->GetDictionaryWithoutPathExpansion(*extension_id,
+                                                            &ext)) {
       LOG(WARNING) << "Invalid pref for extension " << *extension_id;
       NOTREACHED();
       continue;
     }
     if (ext->HasKey(kPrefBlacklist)) {
       bool is_blacklisted = false;
       if (!ext->GetBoolean(kPrefBlacklist, &is_blacklisted)) {
         NOTREACHED() << "Invalid blacklist pref:" << *extension_id;
         continue;
       }
@@ skipping 51 matching lines @@
       parent.value().length());
   if (FilePath::IsSeparator(retval[0]))
     return retval.substr(1);
   else
     return retval;
 }
 
 void ExtensionPrefs::MakePathsRelative() {
   bool dirty = false;
   const DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
-  if (!dict || dict->GetSize() == 0)
+  if (!dict || dict->empty())
     return;
 
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     DictionaryValue* extension_dict;
-    if (!dict->GetDictionary(*i, &extension_dict))
+    if (!dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict))
       continue;
     FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string))
       continue;
     FilePath path(path_string);
     if (path.IsAbsolute()) {
       extension_dict->SetString(kPrefPath,
           MakePathRelative(install_directory_, path, &dirty));
     }
   }
   if (dirty)
     prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionPrefs::MakePathsAbsolute(DictionaryValue* dict) {
-  if (!dict || dict->GetSize() == 0)
+  if (!dict || dict->empty())
     return;
 
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     DictionaryValue* extension_dict;
-    if (!dict->GetDictionary(*i, &extension_dict)) {
+    if (!dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
       NOTREACHED();
       continue;
     }
     FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string)) {
       if (!IsBlacklistBitSet(extension_dict)) {
         // We expect the kPrefPath for non-blacklisted extensions.
         NOTREACHED();
       }
       continue;
@@ skipping 37 matching lines @@
   }
   return IsBlacklistBitSet(ext);
 }
 
 void ExtensionPrefs::UpdateBlacklist(
   const std::set<std::string>& blacklist_set) {
   std::vector<std::string> remove_pref_ids;
   std::set<std::string> used_id_set;
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   DCHECK(extensions);
-  DictionaryValue::key_iterator extension_id = extensions->begin_keys();
-  for (; extension_id != extensions->end_keys(); ++extension_id) {
+  for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
+       extension_id != extensions->end_keys(); ++extension_id) {
     DictionaryValue* ext;
-    std::string id = WideToASCII(*extension_id);
-    if (!extensions->GetDictionary(*extension_id, &ext)) {
+    if (!extensions->GetDictionaryWithoutPathExpansion(*extension_id, &ext)) {
       NOTREACHED() << "Invalid pref for extension " << *extension_id;
       continue;
     }
+    std::string id = WideToASCII(*extension_id);
     if (blacklist_set.find(id) == blacklist_set.end()) {
       if (!IsBlacklistBitSet(ext)) {
         // This extension is not in blacklist. And it was not blacklisted
         // before.
         continue;
       } else {
-        if (ext->GetSize() == 1) {
+        if (ext->size() == 1) {
           // We should remove the entry if the only flag here is blacklist.
           remove_pref_ids.push_back(id);
         } else {
           // Remove the blacklist bit.
           ext->Remove(kPrefBlacklist, NULL);
         }
       }
     } else {
       if (!IsBlacklistBitSet(ext)) {
         // Only set the blacklist if it was not set.
@@ skipping 15 matching lines @@
   for (unsigned int i = 0; i < remove_pref_ids.size(); ++i) {
     DeleteExtensionPrefs(remove_pref_ids[i]);
   }
   // Update persistent registry
   prefs_->ScheduleSavePersistentPrefs();
   return;
 }
 
 void ExtensionPrefs::GetKilledExtensionIds(std::set<std::string>* killed_ids) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
-  if (!dict || dict->GetSize() == 0)
+  if (!dict || dict->empty())
     return;
 
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     std::wstring key_name = *i;
     if (!Extension::IdIsValid(WideToASCII(key_name))) {
       LOG(WARNING) << "Invalid external extension ID encountered: "
                    << WideToASCII(key_name);
       continue;
     }
 
-    DictionaryValue* extension = NULL;
+    DictionaryValue* extension;
     if (!dict->GetDictionary(key_name, &extension)) {
       NOTREACHED();
       continue;
     }
 
     // Check to see if the extension has been killed.
     int state;
     if (extension->GetInteger(kPrefState, &state) &&
         state == static_cast<int>(Extension::KILLBIT)) {
       StringToLowerASCII(&key_name);
@@ skipping 97 matching lines @@
   return version;
 }
 
 void ExtensionPrefs::MigrateToPrefs(Extension* extension) {
   UpdateExtensionPref(extension->id(), kPrefManifest,
                       extension->manifest_value()->DeepCopy());
 }
 
 FilePath ExtensionPrefs::GetExtensionPath(const std::string& extension_id) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
-  if (!dict || dict->GetSize() == 0)
+  if (!dict || dict->empty())
     return FilePath();
 
   std::wstring path;
   if (!dict->GetString(ASCIIToWide(extension_id) + L"." + kPrefPath, &path))
     return FilePath();
 
   return install_directory_.Append(FilePath::FromWStringHack(path));
 }
 
-bool ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id,
+void ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id,
                                          const std::wstring& key,
                                          Value* data_value) {
   DictionaryValue* extension = GetOrCreateExtensionPref(extension_id);
-  if (!extension->Set(key, data_value)) {
-    NOTREACHED() << "Cannot modify key: '" << key.c_str()
-                 << "' for extension: '" << extension_id.c_str() << "'";
-    return false;
-  }
-  return true;
+  extension->Set(key, data_value);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   std::wstring id = ASCIIToWide(extension_id);
   DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
   if (dict->HasKey(id)) {
     dict->Remove(id, NULL);
     prefs_->ScheduleSavePersistentPrefs();
   }
 }
@@ skipping 12 matching lines @@
 }
 
 DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   DictionaryValue* extension = NULL;
   std::wstring id = ASCIIToWide(extension_id);
   dict->GetDictionary(id, &extension);
   return extension;
 }