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 CHROME_BROWSER_EXTENSIONS_API_PREFERENCE_PREFERENCE_API_H__
6#define CHROME_BROWSER_EXTENSIONS_API_PREFERENCE_PREFERENCE_API_H__
7
8#include <string>
9
10#include "base/memory/ref_counted.h"
11#include "base/prefs/pref_change_registrar.h"
12#include "chrome/browser/extensions/api/content_settings/content_settings_store.h"
13#include "chrome/browser/extensions/chrome_extension_function.h"
14#include "content/public/browser/notification_observer.h"
15#include "extensions/browser/browser_context_keyed_api_factory.h"
16#include "extensions/browser/event_router.h"
17#include "extensions/browser/extension_prefs_scope.h"
18
19class ExtensionPrefValueMap;
20class PrefService;
21
22namespace base {
23class Value;
24}
25
26namespace extensions {
27class ExtensionPrefs;
28
29class PreferenceEventRouter {
30 public:
31  explicit PreferenceEventRouter(Profile* profile);
32  virtual ~PreferenceEventRouter();
33
34 private:
35  void OnPrefChanged(PrefService* pref_service,
36                     const std::string& pref_key);
37
38  PrefChangeRegistrar registrar_;
39  PrefChangeRegistrar incognito_registrar_;
40
41  // Weak, owns us (transitively via ExtensionService).
42  Profile* profile_;
43
44  DISALLOW_COPY_AND_ASSIGN(PreferenceEventRouter);
45};
46
47// The class containing the implementation for extension-controlled preference
48// manipulation. This implementation is separate from PreferenceAPI, since
49// we need to be able to use these methods in testing, where we use
50// TestExtensionPrefs and don't construct a profile.
51//
52// See also PreferenceAPI and TestPreferenceAPI.
53class PreferenceAPIBase {
54 public:
55  // Functions for manipulating preference values that are controlled by the
56  // extension. In other words, these are not pref values *about* the extension,
57  // but rather about something global the extension wants to override.
58
59  // Set a new extension-controlled preference value.
60  // Takes ownership of |value|.
61  void SetExtensionControlledPref(const std::string& extension_id,
62                                  const std::string& pref_key,
63                                  ExtensionPrefsScope scope,
64                                  base::Value* value);
65
66  // Remove an extension-controlled preference value.
67  void RemoveExtensionControlledPref(const std::string& extension_id,
68                                     const std::string& pref_key,
69                                     ExtensionPrefsScope scope);
70
71  // Returns true if currently no extension with higher precedence controls the
72  // preference.
73  bool CanExtensionControlPref(const std::string& extension_id,
74                               const std::string& pref_key,
75                               bool incognito);
76
77  // Returns true if extension |extension_id| currently controls the
78  // preference. If |from_incognito| is not NULL, looks at incognito preferences
79  // first, and |from_incognito| is set to true if the effective pref value is
80  // coming from the incognito preferences, false if it is coming from the
81  // normal ones.
82  bool DoesExtensionControlPref(const std::string& extension_id,
83                                const std::string& pref_key,
84                                bool* from_incognito);
85
86 protected:
87  // Virtual for testing.
88  virtual ExtensionPrefs* extension_prefs() = 0;
89  virtual ExtensionPrefValueMap* extension_pref_value_map() = 0;
90  virtual scoped_refptr<ContentSettingsStore> content_settings_store() = 0;
91};
92
93class PreferenceAPI : public PreferenceAPIBase,
94                      public BrowserContextKeyedAPI,
95                      public EventRouter::Observer,
96                      public ContentSettingsStore::Observer {
97 public:
98  explicit PreferenceAPI(content::BrowserContext* context);
99  virtual ~PreferenceAPI();
100
101  // KeyedService implementation.
102  virtual void Shutdown() OVERRIDE;
103
104  // BrowserContextKeyedAPI implementation.
105  static BrowserContextKeyedAPIFactory<PreferenceAPI>* GetFactoryInstance();
106
107  // Convenience method to get the PreferenceAPI for a profile.
108  static PreferenceAPI* Get(content::BrowserContext* context);
109
110  // EventRouter::Observer implementation.
111  virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
112
113 private:
114  friend class BrowserContextKeyedAPIFactory<PreferenceAPI>;
115
116  // ContentSettingsStore::Observer implementation.
117  virtual void OnContentSettingChanged(const std::string& extension_id,
118                                       bool incognito) OVERRIDE;
119
120  // Clears incognito session-only content settings for all extensions.
121  void ClearIncognitoSessionOnlyContentSettings();
122
123  // PreferenceAPIBase implementation.
124  virtual ExtensionPrefs* extension_prefs() OVERRIDE;
125  virtual ExtensionPrefValueMap* extension_pref_value_map() OVERRIDE;
126  virtual scoped_refptr<ContentSettingsStore> content_settings_store() OVERRIDE;
127
128  Profile* profile_;
129
130  // BrowserContextKeyedAPI implementation.
131  static const char* service_name() {
132    return "PreferenceAPI";
133  }
134  static const bool kServiceIsNULLWhileTesting = true;
135  static const bool kServiceRedirectedInIncognito = true;
136
137  // Created lazily upon OnListenerAdded.
138  scoped_ptr<PreferenceEventRouter> preference_event_router_;
139
140  DISALLOW_COPY_AND_ASSIGN(PreferenceAPI);
141};
142
143class PrefTransformerInterface {
144 public:
145  virtual ~PrefTransformerInterface() {}
146
147  // Converts the representation of a preference as seen by the extension
148  // into a representation that is used in the pref stores of the browser.
149  // Returns the pref store representation in case of success or sets
150  // |error| and returns NULL otherwise. |bad_message| is passed to simulate
151  // the behavior of EXTENSION_FUNCTION_VALIDATE. It is never NULL.
152  // The ownership of the returned value is passed to the caller.
153  virtual base::Value* ExtensionToBrowserPref(
154      const base::Value* extension_pref,
155      std::string* error,
156      bool* bad_message) = 0;
157
158  // Converts the representation of the preference as stored in the browser
159  // into a representation that is used by the extension.
160  // Returns the extension representation in case of success or NULL otherwise.
161  // The ownership of the returned value is passed to the caller.
162  virtual base::Value* BrowserToExtensionPref(
163      const base::Value* browser_pref) = 0;
164};
165
166// A base class to provide functionality common to the other *PreferenceFunction
167// classes.
168class PreferenceFunction : public ChromeSyncExtensionFunction {
169 protected:
170  enum PermissionType { PERMISSION_TYPE_READ, PERMISSION_TYPE_WRITE };
171
172  virtual ~PreferenceFunction();
173
174  // Given an |extension_pref_key|, provides its |browser_pref_key| from the
175  // static map in preference_api.cc. Returns true if the corresponding
176  // browser pref exists and the extension has the API permission needed to
177  // modify that pref. Sets |error_| if the extension doesn't have the needed
178  // permission.
179  bool ValidateBrowserPref(const std::string& extension_pref_key,
180                           PermissionType permission_type,
181                           std::string* browser_pref_key);
182};
183
184class GetPreferenceFunction : public PreferenceFunction {
185 public:
186  DECLARE_EXTENSION_FUNCTION("types.ChromeSetting.get", TYPES_CHROMESETTING_GET)
187
188 protected:
189  virtual ~GetPreferenceFunction();
190
191  // ExtensionFunction:
192  virtual bool RunSync() OVERRIDE;
193};
194
195class SetPreferenceFunction : public PreferenceFunction {
196 public:
197  DECLARE_EXTENSION_FUNCTION("types.ChromeSetting.set", TYPES_CHROMESETTING_SET)
198
199 protected:
200  virtual ~SetPreferenceFunction();
201
202  // ExtensionFunction:
203  virtual bool RunSync() OVERRIDE;
204};
205
206class ClearPreferenceFunction : public PreferenceFunction {
207 public:
208  DECLARE_EXTENSION_FUNCTION("types.ChromeSetting.clear",
209                             TYPES_CHROMESETTING_CLEAR)
210
211 protected:
212  virtual ~ClearPreferenceFunction();
213
214  // ExtensionFunction:
215  virtual bool RunSync() OVERRIDE;
216};
217
218}  // namespace extensions
219
220#endif  // CHROME_BROWSER_EXTENSIONS_API_PREFERENCE_PREFERENCE_API_H__
221