base/prefs/pref_member.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/prefs/pref_member.h"
   6
   7 #include "base/callback.h"
   8 #include "base/callback_helpers.h"
   9 #include "base/location.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/value_conversions.h"
  12
  13 using base::MessageLoopProxy;
  14
  15 namespace subtle {
  16
  17 PrefMemberBase::PrefMemberBase()
  18     : prefs_(NULL),
  19       setting_value_(false) {
  20 }
  21
  22 PrefMemberBase::~PrefMemberBase() {
  23   Destroy();
  24 }
  25
  26 void PrefMemberBase::Init(const char* pref_name,
  27                           PrefService* prefs,
  28                           const NamedChangeCallback& observer) {
  29   observer_ = observer;
  30   Init(pref_name, prefs);
  31 }
  32
  33 void PrefMemberBase::Init(const char* pref_name,
  34                           PrefService* prefs) {
  35   DCHECK(pref_name);
  36   DCHECK(prefs);
  37   DCHECK(pref_name_.empty());  // Check that Init is only called once.
  38   prefs_ = prefs;
  39   pref_name_ = pref_name;
  40   // Check that the preference is registered.
  41   DCHECK(prefs_->FindPreference(pref_name_.c_str()))
  42       << pref_name << " not registered.";
  43
  44   // Add ourselves as a pref observer so we can keep our local value in sync.
  45   prefs_->AddPrefObserver(pref_name, this);
  46 }
  47
  48 void PrefMemberBase::Destroy() {
  49   if (prefs_ && !pref_name_.empty()) {
  50     prefs_->RemovePrefObserver(pref_name_.c_str(), this);
  51     prefs_ = NULL;
  52   }
  53 }
  54
  55 void PrefMemberBase::MoveToThread(
  56     const scoped_refptr<MessageLoopProxy>& message_loop) {
  57   VerifyValuePrefName();
  58   // Load the value from preferences if it hasn't been loaded so far.
  59   if (!internal())
  60     UpdateValueFromPref(base::Closure());
  61   internal()->MoveToThread(message_loop);
  62 }
  63
  64 void PrefMemberBase::OnPreferenceChanged(PrefService* service,
  65                                          const std::string& pref_name) {
  66   VerifyValuePrefName();
  67   UpdateValueFromPref((!setting_value_ && !observer_.is_null()) ?
  68       base::Bind(observer_, pref_name) : base::Closure());
  69 }
  70
  71 void PrefMemberBase::UpdateValueFromPref(const base::Closure& callback) const {
  72   VerifyValuePrefName();
  73   const PrefService::Preference* pref =
  74       prefs_->FindPreference(pref_name_.c_str());
  75   DCHECK(pref);
  76   if (!internal())
  77     CreateInternal();
  78   internal()->UpdateValue(pref->GetValue()->DeepCopy(),
  79                           pref->IsManaged(),
  80                           pref->IsUserModifiable(),
  81                           callback);
  82 }
  83
  84 void PrefMemberBase::VerifyPref() const {
  85   VerifyValuePrefName();
  86   if (!internal())
  87     UpdateValueFromPref(base::Closure());
  88 }
  89
  90 void PrefMemberBase::InvokeUnnamedCallback(const base::Closure& callback,
  91                                            const std::string& pref_name) {
  92   callback.Run();
  93 }
  94
  95 PrefMemberBase::Internal::Internal()
  96     : thread_loop_(MessageLoopProxy::current()),
  97       is_managed_(false),
  98       is_user_modifiable_(false) {
  99 }
 100 PrefMemberBase::Internal::~Internal() { }
 101
 102 bool PrefMemberBase::Internal::IsOnCorrectThread() const {
 103   // In unit tests, there may not be a message loop.
 104   return thread_loop_.get() == NULL || thread_loop_->BelongsToCurrentThread();
 105 }
 106
 107 void PrefMemberBase::Internal::UpdateValue(
 108     base::Value* v,
 109     bool is_managed,
 110     bool is_user_modifiable,
 111     const base::Closure& callback) const {
 112   scoped_ptr<base::Value> value(v);
 113   base::ScopedClosureRunner closure_runner(callback);
 114   if (IsOnCorrectThread()) {
 115     bool rv = UpdateValueInternal(*value);
 116     DCHECK(rv);
 117     is_managed_ = is_managed;
 118     is_user_modifiable_ = is_user_modifiable;
 119   } else {
 120     bool may_run = thread_loop_->PostTask(
 121         FROM_HERE,
 122         base::Bind(&PrefMemberBase::Internal::UpdateValue, this,
 123                    value.release(), is_managed, is_user_modifiable,
 124                    closure_runner.Release()));
 125     DCHECK(may_run);
 126   }
 127 }
 128
 129 void PrefMemberBase::Internal::MoveToThread(
 130     const scoped_refptr<MessageLoopProxy>& message_loop) {
 131   CheckOnCorrectThread();
 132   thread_loop_ = message_loop;
 133 }
 134
 135 bool PrefMemberVectorStringUpdate(const base::Value& value,
 136                                   std::vector<std::string>* string_vector) {
 137   if (!value.IsType(base::Value::TYPE_LIST))
 138     return false;
 139   const base::ListValue* list = static_cast<const base::ListValue*>(&value);
 140
 141   std::vector<std::string> local_vector;
 142   for (base::ListValue::const_iterator it = list->begin();
 143        it != list->end(); ++it) {
 144     std::string string_value;
 145     if (!(*it)->GetAsString(&string_value))
 146       return false;
 147
 148     local_vector.push_back(string_value);
 149   }
 150
 151   string_vector->swap(local_vector);
 152   return true;
 153 }
 154
 155 }  // namespace subtle
 156
 157 template <>
 158 void PrefMember<bool>::UpdatePref(const bool& value) {
 159   prefs()->SetBoolean(pref_name().c_str(), value);
 160 }
 161
 162 template <>
 163 bool PrefMember<bool>::Internal::UpdateValueInternal(
 164     const base::Value& value) const {
 165   return value.GetAsBoolean(&value_);
 166 }
 167
 168 template <>
 169 void PrefMember<int>::UpdatePref(const int& value) {
 170   prefs()->SetInteger(pref_name().c_str(), value);
 171 }
 172
 173 template <>
 174 bool PrefMember<int>::Internal::UpdateValueInternal(
 175     const base::Value& value) const {
 176   return value.GetAsInteger(&value_);
 177 }
 178
 179 template <>
 180 void PrefMember<double>::UpdatePref(const double& value) {
 181   prefs()->SetDouble(pref_name().c_str(), value);
 182 }
 183
 184 template <>
 185 bool PrefMember<double>::Internal::UpdateValueInternal(const base::Value& value)
 186     const {
 187   return value.GetAsDouble(&value_);
 188 }
 189
 190 template <>
 191 void PrefMember<std::string>::UpdatePref(const std::string& value) {
 192   prefs()->SetString(pref_name().c_str(), value);
 193 }
 194
 195 template <>
 196 bool PrefMember<std::string>::Internal::UpdateValueInternal(
 197     const base::Value& value)
 198     const {
 199   return value.GetAsString(&value_);
 200 }
 201
 202 template <>
 203 void PrefMember<base::FilePath>::UpdatePref(const base::FilePath& value) {
 204   prefs()->SetFilePath(pref_name().c_str(), value);
 205 }
 206
 207 template <>
 208 bool PrefMember<base::FilePath>::Internal::UpdateValueInternal(
 209     const base::Value& value)
 210     const {
 211   return base::GetValueAsFilePath(value, &value_);
 212 }
 213
 214 template <>
 215 void PrefMember<std::vector<std::string> >::UpdatePref(
 216     const std::vector<std::string>& value) {
 217   base::ListValue list_value;
 218   list_value.AppendStrings(value);
 219   prefs()->Set(pref_name().c_str(), list_value);
 220 }
 221
 222 template <>
 223 bool PrefMember<std::vector<std::string> >::Internal::UpdateValueInternal(
 224     const base::Value& value) const {
 225   return subtle::PrefMemberVectorStringUpdate(value, &value_);
 226 }