RefCounted types should not have public destructors, chrome/ remaining parts

chrome/common/json_pref_store.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/common/json_pref_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 61 matching lines @@
   }
 
   static void HandleErrors(const Value* value,
                            const FilePath& path,
                            int error_code,
                            const std::string& error_msg,
                            PersistentPrefStore::PrefReadError* error);
 
  private:
   friend class base::RefCountedThreadSafe<FileThreadDeserializer>;
+  ~FileThreadDeserializer() {}
 
   bool no_dir_;
   PersistentPrefStore::PrefReadError error_;
   scoped_ptr<Value> value_;
   scoped_refptr<JsonPrefStore> delegate_;
   scoped_refptr<base::MessageLoopProxy> file_loop_proxy_;
   scoped_refptr<base::MessageLoopProxy> origin_loop_proxy_;
 };
 
 // static
@@ skipping 49 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),
       read_error_(PREF_READ_ERROR_OTHER) {
 }
 
-JsonPrefStore::~JsonPrefStore() {
-  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;
   }
   return READ_NO_VALUE;
 }
@@ skipping 52 matching lines @@
 }
 
 bool JsonPrefStore::ReadOnly() const {
   return read_only_;
 }
 
 PersistentPrefStore::PrefReadError JsonPrefStore::GetReadError() const {
   return read_error_;
 }
 
+PersistentPrefStore::PrefReadError JsonPrefStore::ReadPrefs() {
+  if (path_.empty()) {
+    OnFileRead(NULL, PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
+    return PREF_READ_ERROR_FILE_NOT_SPECIFIED;
+  }
+
+  PrefReadError error;
+  bool no_dir;
+  Value* value = FileThreadDeserializer::DoReading(path_, &error, &no_dir);
+  OnFileRead(value, error, no_dir);
+  return error;
+}
+
+void JsonPrefStore::ReadPrefsAsync(ReadErrorDelegate *error_delegate) {
+  initialized_ = false;
+  error_delegate_.reset(error_delegate);
+  if (path_.empty()) {
+    OnFileRead(NULL, PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
+    return;
+  }
+
+  // Start async reading of the preferences file. It will delete itself
+  // in the end.
+  scoped_refptr<FileThreadDeserializer> deserializer(
+      new FileThreadDeserializer(this, file_message_loop_proxy_.get()));
+  deserializer->Start(path_);
+}
+
+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));
+  if (!read_only_)
+    writer_.ScheduleWrite(this);
+}
+
 void JsonPrefStore::OnFileRead(Value* value_owned,
                                PersistentPrefStore::PrefReadError error,
                                bool no_dir) {
   scoped_ptr<Value> value(value_owned);
   initialized_ = true;
   read_error_ = error;
 
   if (no_dir) {
     FOR_EACH_OBSERVER(PrefStore::Observer,
                       observers_,
@@ skipping 25 matching lines @@
   }
 
   if (error_delegate_.get() && error != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(error);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
                     observers_,
                     OnInitializationCompleted(true));
 }
 
-void JsonPrefStore::ReadPrefsAsync(ReadErrorDelegate *error_delegate) {
-  initialized_ = false;
-  error_delegate_.reset(error_delegate);
-  if (path_.empty()) {
-    OnFileRead(NULL, PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
-    return;
-  }
-
-  // Start async reading of the preferences file. It will delete itself
-  // in the end.
-  scoped_refptr<FileThreadDeserializer> deserializer(
-      new FileThreadDeserializer(this, file_message_loop_proxy_.get()));
-  deserializer->Start(path_);
-}
-
-PersistentPrefStore::PrefReadError JsonPrefStore::ReadPrefs() {
-  if (path_.empty()) {
-    OnFileRead(NULL, PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
-    return PREF_READ_ERROR_FILE_NOT_SPECIFIED;
-  }
-
-  PrefReadError error;
-  bool no_dir;

[Nico, 2012/04/25 13:20:37]

why are you moving unrelated functions around?

[Ryan Sleevi, 2012/04/25 15:13:59]

Places where the order of definition /almost/ matches declaration (or when most
files in the directory do) I was just fixing. Since I had to scan the file
anyway to meet pkastings request, its about the same work
 :-/

-  Value* value = FileThreadDeserializer::DoReading(path_, &error, &no_dir);
-  OnFileRead(value, error, no_dir);
-  return error;
-}
-
-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));
-  if (!read_only_)
-    writer_.ScheduleWrite(this);
+JsonPrefStore::~JsonPrefStore() {
+  CommitPendingWrite();
 }
 
 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());
 
   // Iterates |keys_need_empty_value_| and if the key exists in |prefs_|,
@@ skipping 14 matching lines @@
         copy->Set(key, new base::ListValue);
     } else if (value->IsType(base::Value::TYPE_DICTIONARY)) {
       const base::DictionaryValue* dict = NULL;
       if (value->GetAsDictionary(&dict) && dict->empty())
         copy->Set(key, new base::DictionaryValue);
     }
   }
 
   return serializer.Serialize(*(copy.get()));
 }