Home | History | Annotate | Download | only in prefs 
      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 
     10 TestingPrefStore::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 
     19 bool TestingPrefStore::GetValue(const std::string& key,
     20                                 const base::Value** value) const {
     21   return prefs_.GetValue(key, value);
     22 }
     23 
     24 bool TestingPrefStore::GetMutableValue(const std::string& key,
     25                                        base::Value** value) {
     26   return prefs_.GetValue(key, value);
     27 }
     28 
     29 void TestingPrefStore::AddObserver(PrefStore::Observer* observer) {
     30   observers_.AddObserver(observer);
     31 }
     32 
     33 void TestingPrefStore::RemoveObserver(PrefStore::Observer* observer) {
     34   observers_.RemoveObserver(observer);
     35 }
     36 
     37 bool TestingPrefStore::HasObservers() const {
     38   return observers_.might_have_observers();
     39 }
     40 
     41 bool TestingPrefStore::IsInitializationComplete() const {
     42   return init_complete_;
     43 }
     44 
     45 void TestingPrefStore::SetValue(const std::string& key, base::Value* value) {
     46   if (prefs_.SetValue(key, value)) {
     47     committed_ = false;
     48     NotifyPrefValueChanged(key);
     49   }
     50 }
     51 
     52 void TestingPrefStore::SetValueSilently(const std::string& key,
     53                                         base::Value* value) {
     54   if (prefs_.SetValue(key, value))
     55     committed_ = false;
     56 }
     57 
     58 void TestingPrefStore::RemoveValue(const std::string& key) {
     59   if (prefs_.RemoveValue(key)) {
     60     committed_ = false;
     61     NotifyPrefValueChanged(key);
     62   }
     63 }
     64 
     65 bool TestingPrefStore::ReadOnly() const {
     66   return read_only_;
     67 }
     68 
     69 PersistentPrefStore::PrefReadError TestingPrefStore::GetReadError() const {
     70   return read_error_;
     71 }
     72 
     73 PersistentPrefStore::PrefReadError TestingPrefStore::ReadPrefs() {
     74   NotifyInitializationCompleted();
     75   return read_error_;
     76 }
     77 
     78 void 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 
     87 void TestingPrefStore::CommitPendingWrite() { committed_ = true; }
     88 
     89 void TestingPrefStore::SetInitializationCompleted() {
     90   NotifyInitializationCompleted();
     91 }
     92 
     93 void TestingPrefStore::NotifyPrefValueChanged(const std::string& key) {
     94   FOR_EACH_OBSERVER(Observer, observers_, OnPrefValueChanged(key));
     95 }
     96 
     97 void 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 
    106 void TestingPrefStore::ReportValueChanged(const std::string& key) {
    107   FOR_EACH_OBSERVER(Observer, observers_, OnPrefValueChanged(key));
    108 }
    109 
    110 void TestingPrefStore::SetString(const std::string& key,
    111                                  const std::string& value) {
    112   SetValue(key, new base::StringValue(value));
    113 }
    114 
    115 void TestingPrefStore::SetInteger(const std::string& key, int value) {
    116   SetValue(key, new base::FundamentalValue(value));
    117 }
    118 
    119 void TestingPrefStore::SetBoolean(const std::string& key, bool value) {
    120   SetValue(key, new base::FundamentalValue(value));
    121 }
    122 
    123 bool 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 
    132 bool 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 
    140 bool 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 
    148 void 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 
    155 void TestingPrefStore::set_read_only(bool read_only) {
    156   read_only_ = read_only;
    157 }
    158 
    159 void TestingPrefStore::set_read_success(bool read_success) {
    160   DCHECK(!init_complete_);
    161   read_success_ = read_success;
    162 }
    163 
    164 void TestingPrefStore::set_read_error(
    165     PersistentPrefStore::PrefReadError read_error) {
    166   DCHECK(!init_complete_);
    167   read_error_ = read_error;
    168 }
    169 
    170 TestingPrefStore::~TestingPrefStore() {}
    171