Remove JsonPrefStore pruning of empty values on write.

base/values.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 "base/values.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <ostream>
@@ skipping 444 matching lines @@
 void DictionaryValue::SetStringWithoutPathExpansion(
     const std::string& path, const std::string& in_value) {
   SetWithoutPathExpansion(path, CreateStringValue(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(
     const std::string& path, const string16& in_value) {
   SetWithoutPathExpansion(path, CreateStringValue(in_value));
 }
 
-bool DictionaryValue::Get(
-    const std::string& path, const Value** out_value) const {
+bool DictionaryValue::Get(const std::string& path,
+                          const Value** out_value) const {
   DCHECK(IsStringUTF8(path));
 //  LOG(WARNING) << "\n1\n";
   std::string current_path(path);
   const DictionaryValue* current_dictionary = this;
 //  LOG(WARNING) << "\n2\n";
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
     const DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(
@@ skipping 271 matching lines @@
 
   Value* entry = entry_iterator->second;
   if (out_value)
     out_value->reset(entry);
   else
     delete entry;
   dictionary_.erase(entry_iterator);
   return true;
 }
 
+bool DictionaryValue::RemovePath(const std::string& path,
+                                 scoped_ptr<Value>* out_value) {
+  bool result = false;
+  size_t delimiter_position = path.find('.');
+  if (delimiter_position == std::string::npos) {
+    return RemoveWithoutPathExpansion(path, out_value);
+  } else {
+    const std::string subdict_path = path.substr(0, delimiter_position);
+    DictionaryValue* subdict = NULL;
+    if (!GetDictionary(subdict_path, &subdict))
+      return false;
+    result = subdict->RemovePath(path.substr(delimiter_position + 1),
+                                 out_value);
+    if (result && subdict->empty())
+      Remove(subdict_path, NULL);

[Mattias Nissler (ping if slow), 2013/11/22 08:03:38]

RemoveWithoutPathExpansion for clarity.

[gab, 2013/11/22 23:24:21]

Done.

+  }
+  return result;
+}
+
 DictionaryValue* DictionaryValue::DeepCopyWithoutEmptyChildren() const {
   Value* copy = CopyWithoutEmptyChildren(this);
   return copy ? static_cast<DictionaryValue*>(copy) : new DictionaryValue;
 }
 
 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
   for (DictionaryValue::Iterator it(*dictionary); !it.IsAtEnd(); it.Advance()) {
     const Value* merge_value = &it.value();
     // Check whether we have to merge dictionaries.
     if (merge_value->IsType(Value::TYPE_DICTIONARY)) {
@@ skipping 345 matching lines @@
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(&value,
                                JSONWriter::OPTIONS_PRETTY_PRINT,
                                &json);
   return out << json;
 }
 
 }  // namespace base