base/prefs/testing_pref_service.h

   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 #ifndef BASE_PREFS_TESTING_PREF_SERVICE_H_
   6 #define BASE_PREFS_TESTING_PREF_SERVICE_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/prefs/pref_registry.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/prefs/testing_pref_store.h"
  13
  14 class PrefNotifierImpl;
  15 class PrefRegistrySimple;
  16 class TestingPrefStore;
  17
  18 // A PrefService subclass for testing. It operates totally in memory and
  19 // provides additional API for manipulating preferences at the different levels
  20 // (managed, extension, user) conveniently.
  21 //
  22 // Use this via its specializations, e.g. TestingPrefServiceSimple.
  23 template <class SuperPrefService, class ConstructionPrefRegistry>
  24 class TestingPrefServiceBase : public SuperPrefService {
  25  public:
  26   virtual ~TestingPrefServiceBase();
  27
  28   // Read the value of a preference from the managed layer. Returns NULL if the
  29   // preference is not defined at the managed layer.
  30   const base::Value* GetManagedPref(const char* path) const;
  31
  32   // Set a preference on the managed layer and fire observers if the preference
  33   // changed. Assumes ownership of |value|.
  34   void SetManagedPref(const char* path, base::Value* value);
  35
  36   // Clear the preference on the managed layer and fire observers if the
  37   // preference has been defined previously.
  38   void RemoveManagedPref(const char* path);
  39
  40   // Similar to the above, but for user preferences.
  41   const base::Value* GetUserPref(const char* path) const;
  42   void SetUserPref(const char* path, base::Value* value);
  43   void RemoveUserPref(const char* path);
  44
  45   // Similar to the above, but for recommended policy preferences.
  46   const base::Value* GetRecommendedPref(const char* path) const;
  47   void SetRecommendedPref(const char* path, base::Value* value);
  48   void RemoveRecommendedPref(const char* path);
  49
  50   // Do-nothing implementation for TestingPrefService.
  51   static void HandleReadError(PersistentPrefStore::PrefReadError error) {}
  52
  53  protected:
  54   TestingPrefServiceBase(
  55       TestingPrefStore* managed_prefs,
  56       TestingPrefStore* user_prefs,
  57       TestingPrefStore* recommended_prefs,
  58       ConstructionPrefRegistry* pref_registry,
  59       PrefNotifierImpl* pref_notifier);
  60
  61  private:
  62   // Reads the value of the preference indicated by |path| from |pref_store|.
  63   // Returns NULL if the preference was not found.
  64   const base::Value* GetPref(TestingPrefStore* pref_store,
  65                              const char* path) const;
  66
  67   // Sets the value for |path| in |pref_store|.
  68   void SetPref(TestingPrefStore* pref_store, const char* path,
  69                base::Value* value);
  70
  71   // Removes the preference identified by |path| from |pref_store|.
  72   void RemovePref(TestingPrefStore* pref_store, const char* path);
  73
  74   // Pointers to the pref stores our value store uses.
  75   scoped_refptr<TestingPrefStore> managed_prefs_;
  76   scoped_refptr<TestingPrefStore> user_prefs_;
  77   scoped_refptr<TestingPrefStore> recommended_prefs_;
  78
  79   DISALLOW_COPY_AND_ASSIGN(TestingPrefServiceBase);
  80 };
  81
  82 // Test version of PrefService.
  83 class TestingPrefServiceSimple
  84     : public TestingPrefServiceBase<PrefService, PrefRegistry> {
  85  public:
  86   TestingPrefServiceSimple();
  87   ~TestingPrefServiceSimple() override;
  88
  89   // This is provided as a convenience for registering preferences on
  90   // an existing TestingPrefServiceSimple instance. On a production
  91   // PrefService you would do all registrations before constructing
  92   // it, passing it a PrefRegistry via its constructor (or via
  93   // e.g. PrefServiceFactory).
  94   PrefRegistrySimple* registry();
  95
  96  private:
  97   DISALLOW_COPY_AND_ASSIGN(TestingPrefServiceSimple);
  98 };
  99
 100 template<>
 101 TestingPrefServiceBase<PrefService, PrefRegistry>::TestingPrefServiceBase(
 102     TestingPrefStore* managed_prefs,
 103     TestingPrefStore* user_prefs,
 104     TestingPrefStore* recommended_prefs,
 105     PrefRegistry* pref_registry,
 106     PrefNotifierImpl* pref_notifier);
 107
 108 template<class SuperPrefService, class ConstructionPrefRegistry>
 109 TestingPrefServiceBase<
 110     SuperPrefService, ConstructionPrefRegistry>::~TestingPrefServiceBase() {
 111 }
 112
 113 template<class SuperPrefService, class ConstructionPrefRegistry>
 114 const base::Value* TestingPrefServiceBase<
 115     SuperPrefService, ConstructionPrefRegistry>::GetManagedPref(
 116         const char* path) const {
 117   return GetPref(managed_prefs_.get(), path);
 118 }
 119
 120 template<class SuperPrefService, class ConstructionPrefRegistry>
 121 void TestingPrefServiceBase<
 122     SuperPrefService, ConstructionPrefRegistry>::SetManagedPref(
 123         const char* path, base::Value* value) {
 124   SetPref(managed_prefs_.get(), path, value);
 125 }
 126
 127 template<class SuperPrefService, class ConstructionPrefRegistry>
 128 void TestingPrefServiceBase<
 129     SuperPrefService, ConstructionPrefRegistry>::RemoveManagedPref(
 130         const char* path) {
 131   RemovePref(managed_prefs_.get(), path);
 132 }
 133
 134 template<class SuperPrefService, class ConstructionPrefRegistry>
 135 const base::Value* TestingPrefServiceBase<
 136     SuperPrefService, ConstructionPrefRegistry>::GetUserPref(
 137         const char* path) const {
 138   return GetPref(user_prefs_.get(), path);
 139 }
 140
 141 template<class SuperPrefService, class ConstructionPrefRegistry>
 142 void TestingPrefServiceBase<
 143     SuperPrefService, ConstructionPrefRegistry>::SetUserPref(
 144         const char* path, base::Value* value) {
 145   SetPref(user_prefs_.get(), path, value);
 146 }
 147
 148 template<class SuperPrefService, class ConstructionPrefRegistry>
 149 void TestingPrefServiceBase<
 150     SuperPrefService, ConstructionPrefRegistry>::RemoveUserPref(
 151         const char* path) {
 152   RemovePref(user_prefs_.get(), path);
 153 }
 154
 155 template<class SuperPrefService, class ConstructionPrefRegistry>
 156 const base::Value* TestingPrefServiceBase<
 157     SuperPrefService, ConstructionPrefRegistry>::GetRecommendedPref(
 158         const char* path) const {
 159   return GetPref(recommended_prefs_, path);
 160 }
 161
 162 template<class SuperPrefService, class ConstructionPrefRegistry>
 163 void TestingPrefServiceBase<
 164     SuperPrefService, ConstructionPrefRegistry>::SetRecommendedPref(
 165         const char* path, base::Value* value) {
 166   SetPref(recommended_prefs_.get(), path, value);
 167 }
 168
 169 template<class SuperPrefService, class ConstructionPrefRegistry>
 170 void TestingPrefServiceBase<
 171     SuperPrefService, ConstructionPrefRegistry>::RemoveRecommendedPref(
 172         const char* path) {
 173   RemovePref(recommended_prefs_.get(), path);
 174 }
 175
 176 template<class SuperPrefService, class ConstructionPrefRegistry>
 177 const base::Value* TestingPrefServiceBase<
 178     SuperPrefService, ConstructionPrefRegistry>::GetPref(
 179         TestingPrefStore* pref_store, const char* path) const {
 180   const base::Value* res;
 181   return pref_store->GetValue(path, &res) ? res : NULL;
 182 }
 183
 184 template<class SuperPrefService, class ConstructionPrefRegistry>
 185 void TestingPrefServiceBase<
 186     SuperPrefService, ConstructionPrefRegistry>::SetPref(
 187         TestingPrefStore* pref_store, const char* path, base::Value* value) {
 188   pref_store->SetValue(path, value);
 189 }
 190
 191 template<class SuperPrefService, class ConstructionPrefRegistry>
 192 void TestingPrefServiceBase<
 193     SuperPrefService, ConstructionPrefRegistry>::RemovePref(
 194         TestingPrefStore* pref_store, const char* path) {
 195   pref_store->RemoveValue(path);
 196 }
 197
 198 #endif  // BASE_PREFS_TESTING_PREF_SERVICE_H_