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/testing_pref_store.h" 6 7#include "base/memory/scoped_ptr.h" 8#include "base/values.h" 9 10TestingPrefStore::TestingPrefStore() 11 : read_only_(true), 12 read_success_(true), 13 read_error_(PersistentPrefStore::PREF_READ_ERROR_NONE), 14 block_async_read_(false), 15 pending_async_read_(false), 16 init_complete_(false), 17 committed_(true) {} 18 19bool TestingPrefStore::GetValue(const std::string& key, 20 const base::Value** value) const { 21 return prefs_.GetValue(key, value); 22} 23 24bool TestingPrefStore::GetMutableValue(const std::string& key, 25 base::Value** value) { 26 return prefs_.GetValue(key, value); 27} 28 29void TestingPrefStore::AddObserver(PrefStore::Observer* observer) { 30 observers_.AddObserver(observer); 31} 32 33void TestingPrefStore::RemoveObserver(PrefStore::Observer* observer) { 34 observers_.RemoveObserver(observer); 35} 36 37bool TestingPrefStore::HasObservers() const { 38 return observers_.might_have_observers(); 39} 40 41bool TestingPrefStore::IsInitializationComplete() const { 42 return init_complete_; 43} 44 45void TestingPrefStore::SetValue(const std::string& key, base::Value* value) { 46 if (prefs_.SetValue(key, value)) { 47 committed_ = false; 48 NotifyPrefValueChanged(key); 49 } 50} 51 52void TestingPrefStore::SetValueSilently(const std::string& key, 53 base::Value* value) { 54 if (prefs_.SetValue(key, value)) 55 committed_ = false; 56} 57 58void TestingPrefStore::RemoveValue(const std::string& key) { 59 if (prefs_.RemoveValue(key)) { 60 committed_ = false; 61 NotifyPrefValueChanged(key); 62 } 63} 64 65bool TestingPrefStore::ReadOnly() const { 66 return read_only_; 67} 68 69PersistentPrefStore::PrefReadError TestingPrefStore::GetReadError() const { 70 return read_error_; 71} 72 73PersistentPrefStore::PrefReadError TestingPrefStore::ReadPrefs() { 74 NotifyInitializationCompleted(); 75 return read_error_; 76} 77 78void TestingPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) { 79 DCHECK(!pending_async_read_); 80 error_delegate_.reset(error_delegate); 81 if (block_async_read_) 82 pending_async_read_ = true; 83 else 84 NotifyInitializationCompleted(); 85} 86 87void TestingPrefStore::CommitPendingWrite() { committed_ = true; } 88 89void TestingPrefStore::SetInitializationCompleted() { 90 NotifyInitializationCompleted(); 91} 92 93void TestingPrefStore::NotifyPrefValueChanged(const std::string& key) { 94 FOR_EACH_OBSERVER(Observer, observers_, OnPrefValueChanged(key)); 95} 96 97void TestingPrefStore::NotifyInitializationCompleted() { 98 DCHECK(!init_complete_); 99 init_complete_ = true; 100 if (read_success_ && read_error_ != PREF_READ_ERROR_NONE && error_delegate_) 101 error_delegate_->OnError(read_error_); 102 FOR_EACH_OBSERVER( 103 Observer, observers_, OnInitializationCompleted(read_success_)); 104} 105 106void TestingPrefStore::ReportValueChanged(const std::string& key) { 107 FOR_EACH_OBSERVER(Observer, observers_, OnPrefValueChanged(key)); 108} 109 110void TestingPrefStore::SetString(const std::string& key, 111 const std::string& value) { 112 SetValue(key, new base::StringValue(value)); 113} 114 115void TestingPrefStore::SetInteger(const std::string& key, int value) { 116 SetValue(key, new base::FundamentalValue(value)); 117} 118 119void TestingPrefStore::SetBoolean(const std::string& key, bool value) { 120 SetValue(key, new base::FundamentalValue(value)); 121} 122 123bool TestingPrefStore::GetString(const std::string& key, 124 std::string* value) const { 125 const base::Value* stored_value; 126 if (!prefs_.GetValue(key, &stored_value) || !stored_value) 127 return false; 128 129 return stored_value->GetAsString(value); 130} 131 132bool TestingPrefStore::GetInteger(const std::string& key, int* value) const { 133 const base::Value* stored_value; 134 if (!prefs_.GetValue(key, &stored_value) || !stored_value) 135 return false; 136 137 return stored_value->GetAsInteger(value); 138} 139 140bool TestingPrefStore::GetBoolean(const std::string& key, bool* value) const { 141 const base::Value* stored_value; 142 if (!prefs_.GetValue(key, &stored_value) || !stored_value) 143 return false; 144 145 return stored_value->GetAsBoolean(value); 146} 147 148void TestingPrefStore::SetBlockAsyncRead(bool block_async_read) { 149 DCHECK(!init_complete_); 150 block_async_read_ = block_async_read; 151 if (pending_async_read_ && !block_async_read_) 152 NotifyInitializationCompleted(); 153} 154 155void TestingPrefStore::set_read_only(bool read_only) { 156 read_only_ = read_only; 157} 158 159void TestingPrefStore::set_read_success(bool read_success) { 160 DCHECK(!init_complete_); 161 read_success_ = read_success; 162} 163 164void TestingPrefStore::set_read_error( 165 PersistentPrefStore::PrefReadError read_error) { 166 DCHECK(!init_complete_); 167 read_error_ = read_error; 168} 169 170TestingPrefStore::~TestingPrefStore() {} 171