Reverts debugging code added in hopes of tracking crash. This also

chrome/common/json_pref_store.cc

 // Copyright (c) 2011 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/common/json_pref_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 130 matching lines @@
     : path_(filename),
       file_message_loop_proxy_(file_message_loop_proxy),
       prefs_(new DictionaryValue()),
       read_only_(false),
       writer_(filename, file_message_loop_proxy),
       error_delegate_(NULL),
       initialized_(false) {
 }
 
 JsonPrefStore::~JsonPrefStore() {
-  ResetCheckIfValueDestroyed(prefs_.get());
   CommitPendingWrite();
 }
 
 PrefStore::ReadResult JsonPrefStore::GetValue(const std::string& key,
                                               const Value** result) const {
   Value* tmp = NULL;
   if (prefs_->Get(key, &tmp)) {
     if (result)
       *result = tmp;
     return READ_OK;
@@ skipping 12 matching lines @@
 bool JsonPrefStore::IsInitializationComplete() const {
   return initialized_;
 }
 
 PrefStore::ReadResult JsonPrefStore::GetMutableValue(const std::string& key,
                                                      Value** result) {
   return prefs_->Get(key, result) ? READ_OK : READ_NO_VALUE;
 }
 
 void JsonPrefStore::SetValue(const std::string& key, Value* value) {
-  SetValueImpl(key, value, SET_VALUE_NOTIFY);
+  DCHECK(value);
+  scoped_ptr<Value> new_value(value);
+  Value* old_value = NULL;
+  prefs_->Get(key, &old_value);
+  if (!old_value || !value->Equals(old_value)) {
+    prefs_->Set(key, new_value.release());
+    FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
+  }
 }
 
 void JsonPrefStore::SetValueSilently(const std::string& key, Value* value) {
-  SetValueImpl(key, value, SET_VALUE_DONT_NOTIFY);
+  DCHECK(value);
+  scoped_ptr<Value> new_value(value);
+  Value* old_value = NULL;
+  prefs_->Get(key, &old_value);
+  if (!old_value || !value->Equals(old_value))
+    prefs_->Set(key, new_value.release());
 }
 
 void JsonPrefStore::RemoveValue(const std::string& key) {
-  Value* value = NULL;
-  bool path_existed = prefs_->Remove(key, &value);
-  scoped_ptr<Value> owned_value(value);
-  ResetCheckIfValueDestroyed(value);
-  if (path_existed)
+  if (prefs_->Remove(key, NULL)) {
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
+  }
 }
 
 bool JsonPrefStore::ReadOnly() const {
   return read_only_;
 }
 
 void JsonPrefStore::OnFileRead(Value* value_owned,
                                PersistentPrefStore::PrefReadError error,
                                bool no_dir) {
   scoped_ptr<Value> value(value_owned);
   initialized_ = true;
 
   if (no_dir) {
     FOR_EACH_OBSERVER(PrefStore::Observer,
                       observers_,
                       OnInitializationCompleted(false));
     return;
   }
 
   switch (error) {
     case PREF_READ_ERROR_ACCESS_DENIED:
     case PREF_READ_ERROR_FILE_OTHER:
     case PREF_READ_ERROR_FILE_LOCKED:
     case PREF_READ_ERROR_JSON_TYPE:
     case PREF_READ_ERROR_FILE_NOT_SPECIFIED:
       read_only_ = true;
       break;
     case PREF_READ_ERROR_NONE:
       DCHECK(value.get());
-      ResetCheckIfValueDestroyed(prefs_.get());
       prefs_.reset(static_cast<DictionaryValue*>(value.release()));
       break;
     case PREF_READ_ERROR_NO_FILE:
       // If the file just doesn't exist, maybe this is first run.  In any case
       // there's no harm in writing out default prefs in this case.
       break;
     case PREF_READ_ERROR_JSON_PARSE:
     case PREF_READ_ERROR_JSON_REPEAT:
       break;
     default:
@@ skipping 58 matching lines @@
 
 void JsonPrefStore::CommitPendingWrite() {
   if (writer_.HasPendingWrite() && !read_only_)
     writer_.DoScheduledWrite();
 }
 
 void JsonPrefStore::ReportValueChanged(const std::string& key) {
   FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
 }
 
-void JsonPrefStore::CheckIfValueDestroyed(const std::string& key) {
-  Value* value = NULL;
-  CHECK_EQ(READ_OK, GetMutableValue(key, &value));
-  CHECK(value);
-  value->set_check_on_delete(true);
-}
-
 bool JsonPrefStore::SerializeData(std::string* output) {
   // TODO(tc): Do we want to prune webkit preferences that match the default
   // value?
   JSONStringValueSerializer serializer(output);
   serializer.set_pretty_print(true);
   scoped_ptr<DictionaryValue> copy(prefs_->DeepCopyWithoutEmptyChildren());
   return serializer.Serialize(*(copy.get()));
 }
-
-void JsonPrefStore::SetValueImpl(const std::string& key,
-                                 Value* value,
-                                 SetValueType type) {
-  DCHECK(value);
-  scoped_ptr<Value> new_value(value);
-  Value* old_value = NULL;
-  prefs_->Get(key, &old_value);
-  ResetCheckIfValueDestroyed(old_value);
-  if (!old_value || !value->Equals(old_value)) {
-    prefs_->Set(key, new_value.release());
-    if (type == SET_VALUE_NOTIFY)
-      ReportValueChanged(key);
-  }
-}
-
-// static
-void JsonPrefStore::ResetCheckIfValueDestroyed(Value* value) {
-  if (!value)
-    return;
-
-  value->set_check_on_delete(false);
-
-  switch (value->GetType()) {
-    case Value::TYPE_DICTIONARY: {
-      DictionaryValue* dictionary = static_cast<DictionaryValue*>(value);
-      for (DictionaryValue::key_iterator i = dictionary->begin_keys();
-           i != dictionary->end_keys(); ++i) {
-        Value* child_value = NULL;
-        dictionary->GetWithoutPathExpansion(*i, &child_value);
-        ResetCheckIfValueDestroyed(child_value);
-      }
-      break;
-    }
-
-    case Value::TYPE_LIST: {
-      ListValue* list = static_cast<ListValue*>(value);
-      for (size_t i = 0; i < list->GetSize(); ++i) {
-        Value* child_value = NULL;
-        list->Get(i, &child_value);
-        ResetCheckIfValueDestroyed(child_value);
-      }
-      break;
-    }
-
-    default:
-      break;
-  }
-}