Add FilePath setter/getter to pref service....

chrome/common/pref_service.cc

 // Copyright (c) 2006-2008 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/pref_service.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/stl_util-inl.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // The number of milliseconds we'll wait to do a write of chrome prefs to disk.
 // This lets us batch together write operations.
 static const int kCommitIntervalMs = 10000;
 
 // Replaces the given file's content with the given data. This allows the
 // preferences to be written to disk on a background thread.
 class SaveLaterTask : public Task {
  public:
-  SaveLaterTask(const std::wstring& file_name,
+  SaveLaterTask(const FilePath& file_name,
                 const std::string& data)
       : file_name_(file_name),
         data_(data) {
   }
 
   void Run() {
     // Write the data to a temp file then rename to avoid data loss if we crash
     // while writing the file.
-    std::wstring tmp_file_name = file_name_ + L".tmp";
+    FilePath tmp_file_name(file_name_.value() + FILE_PATH_LITERAL(".tmp"));
     int bytes_written = file_util::WriteFile(tmp_file_name, data_.c_str(),
                                              static_cast<int>(data_.length()));
     if (bytes_written != -1) {
       if (!file_util::Move(tmp_file_name, file_name_)) {
         // Rename failed. Try again on the off chance someone has locked either
         // file and hope we're successful the second time through.
         bool move_result = file_util::Move(tmp_file_name, file_name_);
         DCHECK(move_result);
       }
     }
   }
 
  private:
-  std::wstring file_name_;
+  FilePath file_name_;
   std::string data_;
 
   DISALLOW_COPY_AND_ASSIGN(SaveLaterTask);
 };
 
 // A helper function for RegisterLocalized*Pref that creates a Value* based on
 // the string value in the locale dll.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate type.
 Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
   std::wstring resource_string = l10n_util::GetString(message_id);
@@ skipping 34 matching lines @@
 }
 
 }  // namespace
 
 PrefService::PrefService()
     : persistent_(new DictionaryValue),
       transient_(new DictionaryValue),
       save_preferences_factory_(NULL) {
 }
 
-PrefService::PrefService(const std::wstring& pref_filename)
+PrefService::PrefService(const FilePath& pref_filename)
     : persistent_(new DictionaryValue),
       transient_(new DictionaryValue),
       pref_filename_(pref_filename),
       ALLOW_THIS_IN_INITIALIZER_LIST(save_preferences_factory_(this)) {
   LoadPersistentPrefs(pref_filename_);
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
 
   // Verify that there are no pref observers when we shut down.
   for (PrefObserverMap::iterator it = pref_observers_.begin();
        it != pref_observers_.end(); ++it) {
     NotificationObserverList::Iterator obs_iterator(*(it->second));
     if (obs_iterator.GetNext()) {
       LOG(WARNING) << "pref observer found at shutdown " << it->first;
     }
   }
 
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
   STLDeleteContainerPairSecondPointers(pref_observers_.begin(),
                                        pref_observers_.end());
   pref_observers_.clear();
 }
 
-bool PrefService::LoadPersistentPrefs(const std::wstring& file_path) {
+bool PrefService::LoadPersistentPrefs(const FilePath& file_path) {
 #if defined(OS_WIN)
   DCHECK(!file_path.empty());
 #else
   // On non-Windows platforms we haven't gotten round to this yet.
   // TODO(port): remove this exception
   if (file_path.empty()) {
     NOTIMPLEMENTED();
     return false;
   }
 #endif
   DCHECK(CalledOnValidThread());
 
-  JSONFileValueSerializer serializer(file_path);
+  JSONFileValueSerializer serializer(file_path.ToWStringHack());
   scoped_ptr<Value> root(serializer.Deserialize(NULL));
   if (!root.get())
     return false;
 
   // Preferences should always have a dictionary root.
   if (!root->IsType(Value::TYPE_DICTIONARY))
     return false;
 
   persistent_.reset(static_cast<DictionaryValue*>(root.release()));
   return true;
 }
 
 void PrefService::ReloadPersistentPrefs() {
   DCHECK(CalledOnValidThread());
 
-  JSONFileValueSerializer serializer(pref_filename_);
+  JSONFileValueSerializer serializer(pref_filename_.ToWStringHack());
   scoped_ptr<Value> root(serializer.Deserialize(NULL));
   if (!root.get())
     return;
 
   // Preferences should always have a dictionary root.
   if (!root->IsType(Value::TYPE_DICTIONARY))
     return;
 
   persistent_.reset(static_cast<DictionaryValue*>(root.release()));
   for (PreferenceSet::iterator it = prefs_.begin();
@@ skipping 57 matching lines @@
   RegisterPreference(pref);
 }
 
 void PrefService::RegisterStringPref(const wchar_t* path,
                                      const std::wstring& default_value) {
   Preference* pref = new Preference(persistent_.get(), path,
       Value::CreateStringValue(default_value));
   RegisterPreference(pref);
 }
 
+void PrefService::RegisterFilePathPref(const wchar_t* path,
+                                       const FilePath& default_value) {
+  Preference* pref = new Preference(persistent_.get(), path,
+      Value::CreateStringValue(default_value.value()));
+  RegisterPreference(pref);
+}
+
 void PrefService::RegisterListPref(const wchar_t* path) {
   Preference* pref = new Preference(persistent_.get(), path,
       new ListValue);
   RegisterPreference(pref);
 }
 
 void PrefService::RegisterDictionaryPref(const wchar_t* path) {
   Preference* pref = new Preference(persistent_.get(), path,
       new DictionaryValue());
   RegisterPreference(pref);
@@ skipping 98 matching lines @@
 #else
     // TODO(port): remove this exception
 #endif
     return result;
   }
   bool rv = pref->GetValue()->GetAsString(&result);
   DCHECK(rv);
   return result;
 }
 
+FilePath PrefService::GetFilePath(const wchar_t* path) const {
+  DCHECK(CalledOnValidThread());
+
+  FilePath::StringType result;
+  if (transient_->GetString(path, &result))
+    return FilePath(result);
+
+  const Preference* pref = FindPreference(path);
+  if (!pref) {
+#if defined(OS_WIN)
+    DCHECK(false) << "Trying to read an unregistered pref: " << path;
+#else
+    // TODO(port): remove this exception
+#endif
+    return FilePath(result);
+  }
+  bool rv = pref->GetValue()->GetAsString(&result);
+  DCHECK(rv);
+  return FilePath(result);
+}
+
 bool PrefService::HasPrefPath(const wchar_t* path) const {
   Value* value = NULL;
   return (transient_->Get(path, &value) || persistent_->Get(path, &value));
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const wchar_t* pref_name) const {
   DCHECK(CalledOnValidThread());
   Preference p(NULL, pref_name, NULL);
   PreferenceSet::const_iterator it = prefs_.find(&p);
@@ skipping 185 matching lines @@
     return;
   }
 
   scoped_ptr<Value> old_value(GetPrefCopy(path));
   bool rv = persistent_->SetString(path, value);
   DCHECK(rv);
 
   FireObserversIfChanged(path, old_value.get());
 }
 
+void PrefService::SetFilePath(const wchar_t* path, const FilePath& value) {
+  DCHECK(CalledOnValidThread());
+
+  const Preference* pref = FindPreference(path);
+  if (!pref) {
+    DCHECK(false) << "Trying to write an unregistered pref: " << path;
+    return;
+  }
+  if (pref->type() != Value::TYPE_STRING) {
+    DCHECK(false) << "Wrong type for SetFilePath: " << path;
+    return;
+  }
+
+  scoped_ptr<Value> old_value(GetPrefCopy(path));
+  bool rv = persistent_->SetString(path, value.value());
+  DCHECK(rv);
+
+  FireObserversIfChanged(path, old_value.get());
+}
+
 DictionaryValue* PrefService::GetMutableDictionary(const wchar_t* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     DCHECK(false) << "Trying to get an unregistered pref: " << path;
     return NULL;
   }
   if (pref->type() != Value::TYPE_DICTIONARY) {
     DCHECK(false) << "Wrong type for GetMutableDictionary: " << path;
@@ skipping 103 matching lines @@
   }
 
   // Pref not found, just return the app default.
   return default_value_.get();
 }
 
 bool PrefService::Preference::IsDefaultValue() const {
   DCHECK(default_value_.get());
   return default_value_->Equals(GetValue());
 }