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