1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_
#define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_
#pragma once
#include <list>
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "base/basictypes.h"
#include "base/scoped_ptr.h"
#include "base/stl_util-inl.h"
#include "chrome/browser/prefs/pref_notifier.h"
#include "chrome/common/notification_observer.h"
#include "chrome/common/notification_registrar.h"
#include "chrome/common/pref_store.h"
class DictionaryValue;
class Extension;
class PrefService;
class Profile;
class Value;
// This PrefStore keeps track of preferences set by extensions: for example,
// proxy settings. A stack of relevant extensions is stored in order of
// their addition to this PrefStore. For each preference, the last-added
// enabled extension that tries to set it overrules any others.
class ExtensionPrefStore : public PrefStore,
public NotificationObserver {
public:
ExtensionPrefStore(Profile* profile, PrefNotifier::PrefStoreType type);
virtual ~ExtensionPrefStore();
// Begins tracking the preference and value an extension wishes to set. This
// must be called each time an extension API tries to set a preference.
// The ExtensionPrefStore will take ownership of the |pref_value|.
virtual void InstallExtensionPref(Extension* extension,
const char* pref_path,
Value* pref_value);
// Removes an extension and all its preference settings from this PrefStore.
// This must be called when an extension is uninstalled or disabled.
virtual void UninstallExtension(Extension* extension);
// PrefStore methods:
virtual DictionaryValue* prefs() { return prefs_.get(); }
virtual PrefReadError ReadPrefs() { return PREF_READ_ERROR_NONE; }
// The type passed as Details for an EXTENSION_PREF_CHANGED notification.
// The nested pairs are <extension, <pref_path, pref_value> >. This is here,
// rather than in (say) notification_type.h, to keep the dependency on
// std::pair out of the many places that include notification_type.h.
typedef std::pair<Extension*, std::pair<const char*, Value*> >
ExtensionPrefDetails;
protected:
// Returns a vector of the extension IDs in the extension_stack_.
// This should only be accessed by subclasses for unit-testing.
void GetExtensionIDs(std::vector<std::string>* result);
// Returns the applicable pref service from the profile (if we have one) or
// the browser's local state. This should only be accessed or overridden by
// subclasses for unit-testing.
virtual PrefService* GetPrefService();
private:
// Maps preference paths to their values.
typedef std::map<const char*, Value*> PrefValueMap;
// Applies the highest-priority extension's setting for the given preference
// path to the |prefs_| store, or clears the setting there if no extensions
// wish to control it.
void UpdateOnePref(const char* path);
// Updates each preference in the key set of the |pref_values| map.
void UpdatePrefs(const PrefValueMap* pref_values);
// Registers this as an observer for relevant notifications.
void RegisterObservers();
// Responds to observed notifications.
void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
// A cache of the highest-priority values for each preference that any
// extension is controlling, for quick read access. Owns the stored values.
scoped_ptr<DictionaryValue> prefs_;
// Associates an extension with the prefs it sets. Owns the pref values.
struct ExtensionPrefs {
ExtensionPrefs(Extension* extension, PrefValueMap* values);
~ExtensionPrefs();
Extension* extension;
PrefValueMap* pref_values;
};
// A pseudo-stack of extensions and their preferences. Extensions are always
// added to the head, but may be removed from the middle.
typedef std::list<ExtensionPrefs*> ExtensionStack;
ExtensionStack extension_stack_;
NotificationRegistrar notification_registrar_;
// Weak reference to the profile whose extensions we're interested in. May be
// NULL (for the local-state preferences), in which case we watch all
// extensions.
Profile* profile_;
// My PrefStore type, assigned by the PrefValueStore.
PrefNotifier::PrefStoreType type_;
DISALLOW_COPY_AND_ASSIGN(ExtensionPrefStore);
};
#endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_
|
