Sanitize PrefStore interface.

chrome/browser/prefs/pref_service.cc

 // Copyright (c) 2010 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/prefs/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
-#include "chrome/browser/prefs/in_memory_pref_store.h"
+#include "chrome/browser/prefs/default_pref_store.h"
 #include "chrome/browser/prefs/pref_notifier_impl.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
@@ skipping 42 matching lines @@
 void NotifyReadError(PrefService* pref, int message_id) {
   Source<PrefService> source(pref);
   NotificationService::current()->Notify(NotificationType::PROFILE_ERROR,
                                          source, Details<int>(&message_id));
 }
 
 }  // namespace
 
 // static
 PrefService* PrefService::CreatePrefService(const FilePath& pref_filename,
+                                            PrefStore* extension_prefs,
                                             Profile* profile) {
   using policy::ConfigurationPolicyPrefStore;
 
 #if defined(OS_LINUX)
   // We'd like to see what fraction of our users have the preferences
   // stored on a network file system, as we've had no end of troubles
   // with NFS/AFS.
   // TODO(evanm): remove this once we've collected state.
   file_util::FileSystemType fstype;
   if (file_util::GetFileSystemType(pref_filename.DirName(), &fstype)) {
     UMA_HISTOGRAM_ENUMERATION("PrefService.FileSystemType",
                               static_cast<int>(fstype),
                               file_util::FILE_SYSTEM_TYPE_COUNT);
   }
 #endif
 
   ConfigurationPolicyPrefStore* managed =
       ConfigurationPolicyPrefStore::CreateManagedPlatformPolicyPrefStore();
   ConfigurationPolicyPrefStore* device_management =
       ConfigurationPolicyPrefStore::CreateDeviceManagementPolicyPrefStore(
           profile);
-  InMemoryPrefStore* extension = new InMemoryPrefStore();
   CommandLinePrefStore* command_line =
       new CommandLinePrefStore(CommandLine::ForCurrentProcess());
   JsonPrefStore* user = new JsonPrefStore(
       pref_filename,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   ConfigurationPolicyPrefStore* recommended =
       ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore();
 
-  return new PrefService(managed, device_management, extension, command_line,
-                         user, recommended, profile);
+  return new PrefService(managed, device_management, extension_prefs,
+                         command_line, user, recommended, profile);
 }
 
 // static
 PrefService* PrefService::CreateUserPrefService(const FilePath& pref_filename) {
   JsonPrefStore* user = new JsonPrefStore(
       pref_filename,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
-  InMemoryPrefStore* extension = new InMemoryPrefStore();
 
-  return new PrefService(NULL, NULL, extension, NULL, user, NULL, NULL);
+  return new PrefService(NULL, NULL, NULL, NULL, user, NULL, NULL);
 }
 
 PrefService::PrefService(PrefStore* managed_platform_prefs,
                          PrefStore* device_management_prefs,
                          PrefStore* extension_prefs,
                          PrefStore* command_line_prefs,
-                         PrefStore* user_prefs,
+                         PersistentPrefStore* user_prefs,
                          PrefStore* recommended_prefs,
-                         Profile* profile) {
+                         Profile* profile)
+    : user_pref_store_(user_prefs) {
   pref_notifier_.reset(new PrefNotifierImpl(this));
-  extension_store_ = extension_prefs;
-  default_store_ = new InMemoryPrefStore();
+  default_store_ = new DefaultPrefStore();
   pref_value_store_ =
       new PrefValueStore(managed_platform_prefs,
                          device_management_prefs,
-                         extension_store_,
+                         extension_prefs,
                          command_line_prefs,
-                         user_prefs,
+                         user_pref_store_,
                          recommended_prefs,
                          default_store_,
                          pref_notifier_.get(),
                          profile);
   InitFromStorage();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
 }
 
 void PrefService::InitFromStorage() {
-  PrefStore::PrefReadError error = LoadPersistentPrefs();
-  if (error == PrefStore::PREF_READ_ERROR_NONE)
+  PersistentPrefStore::PrefReadError error = user_pref_store_->ReadPrefs();

[danno, 2010/12/08 13:08:45]

const

[Mattias Nissler (ping if slow), 2010/12/09 10:20:20]

Done.

+  if (error == PersistentPrefStore::PREF_READ_ERROR_NONE)
     return;
 
   // Failing to load prefs on startup is a bad thing(TM). See bug 38352 for
   // an example problem that this can cause.
   // Do some diagnosis and try to avoid losing data.
   int message_id = 0;
-  if (error <= PrefStore::PREF_READ_ERROR_JSON_TYPE) {
+  if (error <= PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE) {
     message_id = IDS_PREFERENCES_CORRUPT_ERROR;
-  } else if (error != PrefStore::PREF_READ_ERROR_NO_FILE) {
+  } else if (error != PersistentPrefStore::PREF_READ_ERROR_NO_FILE) {
     message_id = IDS_PREFERENCES_UNREADABLE_ERROR;
   }
 
   if (message_id) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableFunction(&NotifyReadError, this, message_id));
   }
   UMA_HISTOGRAM_ENUMERATION("PrefService.ReadError", error, 20);
 }
 
 bool PrefService::ReloadPersistentPrefs() {
-  return (LoadPersistentPrefs() == PrefStore::PREF_READ_ERROR_NONE);
-}
-
-PrefStore::PrefReadError PrefService::LoadPersistentPrefs() {
-  DCHECK(CalledOnValidThread());
-
-  PrefStore::PrefReadError pref_error = pref_value_store_->ReadPrefs();
-
-  for (PreferenceSet::iterator it = prefs_.begin();
-       it != prefs_.end(); ++it) {
-      (*it)->pref_service_ = this;
-  }
-
-  return pref_error;
+  return user_pref_store_->ReadPrefs() ==
+             PersistentPrefStore::PREF_READ_ERROR_NONE;
 }
 
 bool PrefService::SavePersistentPrefs() {
   DCHECK(CalledOnValidThread());
 
-  return pref_value_store_->WritePrefs();
+  return user_pref_store_->WritePrefs();
 }
 
 void PrefService::ScheduleSavePersistentPrefs() {
   DCHECK(CalledOnValidThread());
 
-  pref_value_store_->ScheduleWritePrefs();
+  user_pref_store_->ScheduleWritePrefs();
 }
 
 void PrefService::RegisterBooleanPref(const char* path,
                                       bool default_value) {
   RegisterPreference(path, Value::CreateBooleanValue(default_value));
 }
 
 void PrefService::RegisterIntegerPref(const char* path, int default_value) {
   RegisterPreference(path, Value::CreateIntegerValue(default_value));
 }
@@ skipping 133 matching lines @@
 
 const PrefService::Preference* PrefService::FindPreference(
     const char* pref_name) const {
   DCHECK(CalledOnValidThread());
   Preference p(this, pref_name);
   PreferenceSet::const_iterator it = prefs_.find(&p);
   return it == prefs_.end() ? NULL : *it;
 }
 
 bool PrefService::ReadOnly() const {
-  return pref_value_store_->ReadOnly();
+  return user_pref_store_->ReadOnly();
 }
 
 PrefNotifier* PrefService::pref_notifier() const {
   return pref_notifier_.get();
 }
 
-PrefStore* PrefService::GetExtensionPrefStore() {
-  return extension_store_;
-}
-
 bool PrefService::IsManagedPreference(const char* pref_name) const {
   const Preference* pref = FindPreference(pref_name);
   if (pref && pref->IsManaged()) {
     return true;
   }
   return false;
 }
 
 const DictionaryValue* PrefService::GetDictionary(const char* path) const {
   DCHECK(CalledOnValidThread());
@@ skipping 45 matching lines @@
   }
 
   Value::ValueType orig_type = default_value->GetType();
   DCHECK(orig_type != Value::TYPE_NULL && orig_type != Value::TYPE_BINARY) <<
          "invalid preference type: " << orig_type;
 
   // We set the default value of dictionaries and lists to be null so it's
   // easier for callers to check for empty dict/list prefs. The PrefValueStore
   // accepts ownership of the value (null or default_value).
   if (Value::TYPE_LIST == orig_type || Value::TYPE_DICTIONARY == orig_type) {
-    default_store_->prefs()->Set(path, Value::CreateNullValue());
+    default_store_->SetDefaultValue(path, Value::CreateNullValue());
   } else {
     // Hand off ownership.
-    DCHECK(!PrefStore::IsUseDefaultSentinelValue(default_value));
-    default_store_->prefs()->Set(path, scoped_value.release());
+    default_store_->SetDefaultValue(path, scoped_value.release());
   }
 
   pref_value_store_->RegisterPreferenceType(path, orig_type);
   prefs_.insert(new Preference(this, path));
 }
 
 void PrefService::ClearPref(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
-  pref_value_store_->RemoveUserPrefValue(path);
+  user_pref_store_->RemoveValue(path);
 }
 
 void PrefService::Set(const char* path, const Value& value) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to write an unregistered pref: " << path;
     return;
   }
 
   // Allow dictionary and list types to be set to null, which removes their
   // user values.
   if (value.GetType() == Value::TYPE_NULL &&
       (pref->GetType() == Value::TYPE_DICTIONARY ||
        pref->GetType() == Value::TYPE_LIST)) {
-    pref_value_store_->RemoveUserPrefValue(path);
+    user_pref_store_->RemoveValue(path);
   } else if (pref->GetType() != value.GetType()) {
     NOTREACHED() << "Trying to set pref " << path
                  << " of type " << pref->GetType()
                  << " to value of type " << value.GetType();
   } else {
-    pref_value_store_->SetUserPrefValue(path, value.DeepCopy());
+    user_pref_store_->SetValue(path, value.DeepCopy());
   }
 }
 
 void PrefService::SetBoolean(const char* path, bool value) {
   SetUserPrefValue(path, Value::CreateBooleanValue(value));
 }
 
 void PrefService::SetInteger(const char* path, int value) {
   SetUserPrefValue(path, Value::CreateIntegerValue(value));
 }
@@ skipping 55 matching lines @@
   }
   if (pref->GetType() != Value::TYPE_DICTIONARY) {
     NOTREACHED() << "Wrong type for GetMutableDictionary: " << path;
     return NULL;
   }
 
   DictionaryValue* dict = NULL;
   Value* tmp_value = NULL;
   // Look for an existing preference in the user store. If it doesn't
   // exist or isn't the correct type, create a new user preference.
-  if (!pref_value_store_->GetUserValue(path, &tmp_value) ||
+  if (user_pref_store_->GetValue(path, &tmp_value)
+          != PersistentPrefStore::READ_OK ||
       !tmp_value->IsType(Value::TYPE_DICTIONARY)) {
     dict = new DictionaryValue;
-    pref_value_store_->SetUserPrefValueSilently(path, dict);
+    user_pref_store_->SetValueSilently(path, dict);
   } else {
     dict = static_cast<DictionaryValue*>(tmp_value);
   }
   return dict;
 }
 
 ListValue* PrefService::GetMutableList(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to get an unregistered pref: " << path;
     return NULL;
   }
   if (pref->GetType() != Value::TYPE_LIST) {
     NOTREACHED() << "Wrong type for GetMutableList: " << path;
     return NULL;
   }
 
   ListValue* list = NULL;
   Value* tmp_value = NULL;
   // Look for an existing preference in the user store. If it doesn't
   // exist or isn't the correct type, create a new user preference.
-  if (!pref_value_store_->GetUserValue(path, &tmp_value) ||
+  if (user_pref_store_->GetValue(path, &tmp_value)
+          != PersistentPrefStore::READ_OK ||
       !tmp_value->IsType(Value::TYPE_LIST)) {
     list = new ListValue;
-    pref_value_store_->SetUserPrefValueSilently(path, list);
+    user_pref_store_->SetValueSilently(path, list);
   } else {
     list = static_cast<ListValue*>(tmp_value);
   }
   return list;
 }
 
-Value* PrefService::GetPrefCopy(const char* path) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  DCHECK(pref);
-  return pref->GetValue()->DeepCopy();
-}
-
 void PrefService::SetUserPrefValue(const char* path, Value* new_value) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to write an unregistered pref: " << path;
     return;
   }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
   if (pref->GetType() != new_value->GetType()) {
     NOTREACHED() << "Trying to set pref " << path
                  << " of type " << pref->GetType()
                  << " to value of type " << new_value->GetType();
     return;
   }
 
-  pref_value_store_->SetUserPrefValue(path, new_value);
+  user_pref_store_->SetValue(path, new_value);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PrefService::Preference
 
 PrefService::Preference::Preference(const PrefService* service,
                                     const char* name)
       : name_(name),
         pref_service_(service) {
   DCHECK(name);
@@ skipping 11 matching lines @@
   Value* found_value = NULL;
   if (pref_service_->pref_value_store_->GetValue(name_, &found_value))
     return found_value;
 
   // Every registered preference has at least a default value.
   NOTREACHED() << "no valid value found for registered pref " << name_;
   return NULL;
 }
 
 bool PrefService::Preference::IsManaged() const {
-  PrefValueStore* pref_value_store =
-      pref_service_->pref_value_store_;
+  PrefValueStore* pref_value_store = pref_service_->pref_value_store_;
   return pref_value_store->PrefValueInManagedPlatformStore(name_.c_str()) ||
       pref_value_store->PrefValueInDeviceManagementStore(name_.c_str());
 }
 
 bool PrefService::Preference::HasExtensionSetting() const {
   return pref_service_->pref_value_store_->
       PrefValueInExtensionStore(name_.c_str());
 }
 
 bool PrefService::Preference::HasUserSetting() const {
@@ skipping 13 matching lines @@
 
 bool PrefService::Preference::IsDefaultValue() const {
   return pref_service_->pref_value_store_->
       PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_service_->pref_value_store_->
       PrefValueUserModifiable(name_.c_str());
 }