← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/prefs/pref_value_store.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/prefs/pref_value_store.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_PREF_VALUE_STORE_H_
6
 
#define BASE_PREFS_PREF_VALUE_STORE_H_
7
 
 
8
 
#include <map>
9
 
#include <string>
10
 
#include <vector>
11
 
 
12
 
#include "base/basictypes.h"
13
 
#include "base/callback.h"
14
 
#include "base/gtest_prod_util.h"
15
 
#include "base/memory/ref_counted.h"
16
 
#include "base/prefs/base_prefs_export.h"
17
 
#include "base/prefs/pref_store.h"
18
 
#include "base/values.h"
19
 
 
20
 
class PrefNotifier;
21
 
class PrefStore;
22
 
 
23
 
// The PrefValueStore manages various sources of values for Preferences
24
 
// (e.g., configuration policies, extensions, and user settings). It returns
25
 
// the value of a Preference from the source with the highest priority, and
26
 
// allows setting user-defined values for preferences that are not managed.
27
 
//
28
 
// Unless otherwise explicitly noted, all of the methods of this class must
29
 
// be called on the UI thread.
30
 
class BASE_PREFS_EXPORT PrefValueStore {
31
 
 public:
32
 
  typedef base::Callback<void(const std::string&)> PrefChangedCallback;
33
 
 
34
 
  // In decreasing order of precedence:
35
 
  //   |managed_prefs| contains all preferences from mandatory policies.
36
 
  //   |supervised_user_prefs| contains all preferences from supervised user
37
 
  //        settings, i.e. settings configured for a supervised user by their
38
 
  //        custodian.
39
 
  //   |extension_prefs| contains preference values set by extensions.
40
 
  //   |command_line_prefs| contains preference values set by command-line
41
 
  //        switches.
42
 
  //   |user_prefs| contains all user-set preference values.
43
 
  //   |recommended_prefs| contains all preferences from recommended policies.
44
 
  //   |default_prefs| contains application-default preference values. It must
45
 
  //        be non-null if any preferences are to be registered.
46
 
  //
47
 
  // |pref_notifier| facilitates broadcasting preference change notifications
48
 
  // to the world.
49
 
  PrefValueStore(PrefStore* managed_prefs,
50
 
                 PrefStore* supervised_user_prefs,
51
 
                 PrefStore* extension_prefs,
52
 
                 PrefStore* command_line_prefs,
53
 
                 PrefStore* user_prefs,
54
 
                 PrefStore* recommended_prefs,
55
 
                 PrefStore* default_prefs,
56
 
                 PrefNotifier* pref_notifier);
57
 
  virtual ~PrefValueStore();
58
 
 
59
 
  // Creates a clone of this PrefValueStore with PrefStores overwritten
60
 
  // by the parameters passed, if unequal NULL.
61
 
  PrefValueStore* CloneAndSpecialize(PrefStore* managed_prefs,
62
 
                                     PrefStore* supervised_user_prefs,
63
 
                                     PrefStore* extension_prefs,
64
 
                                     PrefStore* command_line_prefs,
65
 
                                     PrefStore* user_prefs,
66
 
                                     PrefStore* recommended_prefs,
67
 
                                     PrefStore* default_prefs,
68
 
                                     PrefNotifier* pref_notifier);
69
 
 
70
 
  // A PrefValueStore can have exactly one callback that is directly
71
 
  // notified of preferences changing in the store. This does not
72
 
  // filter through the PrefNotifier mechanism, which may not forward
73
 
  // certain changes (e.g. unregistered prefs).
74
 
  void set_callback(const PrefChangedCallback& callback);
75
 
 
76
 
  // Gets the value for the given preference name that has the specified value
77
 
  // type. Values stored in a PrefStore that have the matching |name| but
78
 
  // a non-matching |type| are silently skipped. Returns true if a valid value
79
 
  // was found in any of the available PrefStores. Most callers should use
80
 
  // Preference::GetValue() instead of calling this method directly.
81
 
  bool GetValue(const std::string& name,
82
 
                base::Value::Type type,
83
 
                const base::Value** out_value) const;
84
 
 
85
 
  // Gets the recommended value for the given preference name that has the
86
 
  // specified value type. A value stored in the recommended PrefStore that has
87
 
  // the matching |name| but a non-matching |type| is silently ignored. Returns
88
 
  // true if a valid value was found. Most callers should use
89
 
  // Preference::GetRecommendedValue() instead of calling this method directly.
90
 
  bool GetRecommendedValue(const std::string& name,
91
 
                           base::Value::Type type,
92
 
                           const base::Value** out_value) const;
93
 
 
94
 
  // These methods return true if a preference with the given name is in the
95
 
  // indicated pref store, even if that value is currently being overridden by
96
 
  // a higher-priority source.
97
 
  bool PrefValueInManagedStore(const char* name) const;
98
 
  bool PrefValueInExtensionStore(const char* name) const;
99
 
  bool PrefValueInUserStore(const char* name) const;
100
 
 
101
 
  // These methods return true if a preference with the given name is actually
102
 
  // being controlled by the indicated pref store and not being overridden by
103
 
  // a higher-priority source.
104
 
  bool PrefValueFromExtensionStore(const char* name) const;
105
 
  bool PrefValueFromUserStore(const char* name) const;
106
 
  bool PrefValueFromRecommendedStore(const char* name) const;
107
 
  bool PrefValueFromDefaultStore(const char* name) const;
108
 
 
109
 
  // Check whether a Preference value is modifiable by the user, i.e. whether
110
 
  // there is no higher-priority source controlling it.
111
 
  bool PrefValueUserModifiable(const char* name) const;
112
 
 
113
 
  // Check whether a Preference value is modifiable by an extension, i.e.
114
 
  // whether there is no higher-priority source controlling it.
115
 
  bool PrefValueExtensionModifiable(const char* name) const;
116
 
 
117
 
  // Update the command line PrefStore with |command_line_prefs|.
118
 
  void UpdateCommandLinePrefStore(PrefStore* command_line_prefs);
119
 
 
120
 
 private:
121
 
  // PrefStores must be listed here in order from highest to lowest priority.
122
 
  //   MANAGED contains all managed preference values that are provided by
123
 
  //      mandatory policies (e.g. Windows Group Policy or cloud policy).
124
 
  //   SUPERVISED_USER contains preferences that are valid for supervised users.
125
 
  //   EXTENSION contains preference values set by extensions.
126
 
  //   COMMAND_LINE contains preference values set by command-line switches.
127
 
  //   USER contains all user-set preference values.
128
 
  //   RECOMMENDED contains all preferences that are provided by recommended
129
 
  //      policies.
130
 
  //   DEFAULT contains all application default preference values.
131
 
  enum PrefStoreType {
132
 
    // INVALID_STORE is not associated with an actual PrefStore but used as
133
 
    // an invalid marker, e.g. as a return value.
134
 
    INVALID_STORE = -1,
135
 
    MANAGED_STORE = 0,
136
 
    SUPERVISED_USER_STORE,
137
 
    EXTENSION_STORE,
138
 
    COMMAND_LINE_STORE,
139
 
    USER_STORE,
140
 
    RECOMMENDED_STORE,
141
 
    DEFAULT_STORE,
142
 
    PREF_STORE_TYPE_MAX = DEFAULT_STORE
143
 
  };
144
 
 
145
 
  // Keeps a PrefStore reference on behalf of the PrefValueStore and monitors
146
 
  // the PrefStore for changes, forwarding notifications to PrefValueStore. This
147
 
  // indirection is here for the sake of disambiguating notifications from the
148
 
  // individual PrefStores.
149
 
  class PrefStoreKeeper : public PrefStore::Observer {
150
 
   public:
151
 
    PrefStoreKeeper();
152
 
    virtual ~PrefStoreKeeper();
153
 
 
154
 
    // Takes ownership of |pref_store|.
155
 
    void Initialize(PrefValueStore* store,
156
 
                    PrefStore* pref_store,
157
 
                    PrefStoreType type);
158
 
 
159
 
    PrefStore* store() { return pref_store_.get(); }
160
 
    const PrefStore* store() const { return pref_store_.get(); }
161
 
 
162
 
   private:
163
 
    // PrefStore::Observer implementation.
164
 
    virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
165
 
    virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
166
 
 
167
 
    // PrefValueStore this keeper is part of.
168
 
    PrefValueStore* pref_value_store_;
169
 
 
170
 
    // The PrefStore managed by this keeper.
171
 
    scoped_refptr<PrefStore> pref_store_;
172
 
 
173
 
    // Type of the pref store.
174
 
    PrefStoreType type_;
175
 
 
176
 
    DISALLOW_COPY_AND_ASSIGN(PrefStoreKeeper);
177
 
  };
178
 
 
179
 
  typedef std::map<std::string, base::Value::Type> PrefTypeMap;
180
 
 
181
 
  friend class PrefValueStorePolicyRefreshTest;
182
 
  FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest, TestPolicyRefresh);
183
 
  FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest,
184
 
                           TestRefreshPolicyPrefsCompletion);
185
 
  FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest,
186
 
                           TestConcurrentPolicyRefresh);
187
 
 
188
 
  // Returns true if the preference with the given name has a value in the
189
 
  // given PrefStoreType, of the same value type as the preference was
190
 
  // registered with.
191
 
  bool PrefValueInStore(const char* name, PrefStoreType store) const;
192
 
 
193
 
  // Returns true if a preference has an explicit value in any of the
194
 
  // stores in the range specified by |first_checked_store| and
195
 
  // |last_checked_store|, even if that value is currently being
196
 
  // overridden by a higher-priority store.
197
 
  bool PrefValueInStoreRange(const char* name,
198
 
                             PrefStoreType first_checked_store,
199
 
                             PrefStoreType last_checked_store) const;
200
 
 
201
 
  // Returns the pref store type identifying the source that controls the
202
 
  // Preference identified by |name|. If none of the sources has a value,
203
 
  // INVALID_STORE is returned. In practice, the default PrefStore
204
 
  // should always have a value for any registered preferencem, so INVALID_STORE
205
 
  // indicates an error.
206
 
  PrefStoreType ControllingPrefStoreForPref(const char* name) const;
207
 
 
208
 
  // Get a value from the specified |store|.
209
 
  bool GetValueFromStore(const char* name,
210
 
                         PrefStoreType store,
211
 
                         const base::Value** out_value) const;
212
 
 
213
 
  // Get a value from the specified |store| if its |type| matches.
214
 
  bool GetValueFromStoreWithType(const char* name,
215
 
                                 base::Value::Type type,
216
 
                                 PrefStoreType store,
217
 
                                 const base::Value** out_value) const;
218
 
 
219
 
  // Called upon changes in individual pref stores in order to determine whether
220
 
  // the user-visible pref value has changed. Triggers the change notification
221
 
  // if the effective value of the preference has changed, or if the store
222
 
  // controlling the pref has changed.
223
 
  void NotifyPrefChanged(const char* path, PrefStoreType new_store);
224
 
 
225
 
  // Called from the PrefStoreKeeper implementation when a pref value for |key|
226
 
  // changed in the pref store for |type|.
227
 
  void OnPrefValueChanged(PrefStoreType type, const std::string& key);
228
 
 
229
 
  // Handle the event that the store for |type| has completed initialization.
230
 
  void OnInitializationCompleted(PrefStoreType type, bool succeeded);
231
 
 
232
 
  // Initializes a pref store keeper. Sets up a PrefStoreKeeper that will take
233
 
  // ownership of the passed |pref_store|.
234
 
  void InitPrefStore(PrefStoreType type, PrefStore* pref_store);
235
 
 
236
 
  // Checks whether initialization is completed and tells the notifier if that
237
 
  // is the case.
238
 
  void CheckInitializationCompleted();
239
 
 
240
 
  // Get the PrefStore pointer for the given type. May return NULL if there is
241
 
  // no PrefStore for that type.
242
 
  PrefStore* GetPrefStore(PrefStoreType type) {
243
 
    return pref_stores_[type].store();
244
 
  }
245
 
  const PrefStore* GetPrefStore(PrefStoreType type) const {
246
 
    return pref_stores_[type].store();
247
 
  }
248
 
 
249
 
  // Keeps the PrefStore references in order of precedence.
250
 
  PrefStoreKeeper pref_stores_[PREF_STORE_TYPE_MAX + 1];
251
 
 
252
 
  PrefChangedCallback pref_changed_callback_;
253
 
 
254
 
  // Used for generating notifications. This is a weak reference,
255
 
  // since the notifier is owned by the corresponding PrefService.
256
 
  PrefNotifier* pref_notifier_;
257
 
 
258
 
  // A mapping of preference names to their registered types.
259
 
  PrefTypeMap pref_types_;
260
 
 
261
 
  // True if not all of the PrefStores were initialized successfully.
262
 
  bool initialization_failed_;
263
 
 
264
 
  DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
265
 
};
266
 
 
267
 
#endif  // BASE_PREFS_PREF_VALUE_STORE_H_