testing_pref_store.cc revision effb81e5f8246d0db0270817048dc992db66e9fb 
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