OLD | NEW |
| (Empty) |
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_EXTENSION_SYSTEM_H_ | |
6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SYSTEM_H_ | |
7 | |
8 #include <string> | |
9 | |
10 #include "base/memory/ref_counted.h" | |
11 #include "base/memory/scoped_ptr.h" | |
12 #include "components/browser_context_keyed_service/browser_context_keyed_service
.h" | |
13 #include "extensions/common/extension.h" | |
14 #include "extensions/common/one_shot_event.h" | |
15 | |
16 class ExtensionService; | |
17 class Profile; | |
18 | |
19 #if defined(OS_CHROMEOS) | |
20 namespace chromeos { | |
21 class DeviceLocalAccountManagementPolicyProvider; | |
22 } | |
23 #endif // defined(OS_CHROMEOS) | |
24 | |
25 namespace content { | |
26 class BrowserContext; | |
27 } | |
28 | |
29 namespace extensions { | |
30 class Blacklist; | |
31 class ErrorConsole; | |
32 class EventRouter; | |
33 class Extension; | |
34 class ExtensionSystemSharedFactory; | |
35 class ExtensionWarningBadgeService; | |
36 class ExtensionWarningService; | |
37 class InfoMap; | |
38 class InstallVerifier; | |
39 class LazyBackgroundTaskQueue; | |
40 class ManagementPolicy; | |
41 class NavigationObserver; | |
42 class ProcessManager; | |
43 class RuntimeData; | |
44 class StandardManagementPolicyProvider; | |
45 class StateStore; | |
46 class UserScriptMaster; | |
47 | |
48 // The ExtensionSystem manages the creation and destruction of services | |
49 // related to extensions. Most objects are shared between normal | |
50 // and incognito Profiles, except as called out in comments. | |
51 // This interface supports using TestExtensionSystem for TestingProfiles | |
52 // that don't want all of the extensions baggage in their tests. | |
53 class ExtensionSystem : public BrowserContextKeyedService { | |
54 public: | |
55 ExtensionSystem(); | |
56 virtual ~ExtensionSystem(); | |
57 | |
58 // Returns the instance for the given profile, or NULL if none. This is | |
59 // a convenience wrapper around ExtensionSystemFactory::GetForProfile. | |
60 static ExtensionSystem* Get(Profile* profile); | |
61 | |
62 // Returns the same instance as Get() above. | |
63 static ExtensionSystem* GetForBrowserContext( | |
64 content::BrowserContext* profile); | |
65 | |
66 // BrowserContextKeyedService implementation. | |
67 virtual void Shutdown() OVERRIDE {} | |
68 | |
69 // Initializes extensions machinery. | |
70 // Component extensions are always enabled, external and user extensions are | |
71 // controlled by |extensions_enabled|. | |
72 virtual void InitForRegularProfile(bool extensions_enabled) = 0; | |
73 | |
74 // The ExtensionService is created at startup. | |
75 virtual ExtensionService* extension_service() = 0; | |
76 | |
77 // Per-extension data that can change during the life of the process but | |
78 // does not persist across restarts. Lives on UI thread. Created at startup. | |
79 virtual RuntimeData* runtime_data() = 0; | |
80 | |
81 // The class controlling whether users are permitted to perform certain | |
82 // actions on extensions (install, uninstall, disable, etc.). | |
83 // The ManagementPolicy is created at startup. | |
84 virtual ManagementPolicy* management_policy() = 0; | |
85 | |
86 // The UserScriptMaster is created at startup. | |
87 virtual UserScriptMaster* user_script_master() = 0; | |
88 | |
89 // The ProcessManager is created at startup. | |
90 virtual ProcessManager* process_manager() = 0; | |
91 | |
92 // The StateStore is created at startup. | |
93 virtual StateStore* state_store() = 0; | |
94 | |
95 // The rules store is created at startup. | |
96 virtual StateStore* rules_store() = 0; | |
97 | |
98 // Returns the IO-thread-accessible extension data. | |
99 virtual InfoMap* info_map() = 0; | |
100 | |
101 // The LazyBackgroundTaskQueue is created at startup. | |
102 virtual LazyBackgroundTaskQueue* lazy_background_task_queue() = 0; | |
103 | |
104 // The EventRouter is created at startup. | |
105 virtual EventRouter* event_router() = 0; | |
106 | |
107 // The ExtensionWarningService is created at startup. | |
108 virtual ExtensionWarningService* warning_service() = 0; | |
109 | |
110 // The blacklist is created at startup. | |
111 virtual Blacklist* blacklist() = 0; | |
112 | |
113 // The ErrorConsole is created at startup. | |
114 virtual ErrorConsole* error_console() = 0; | |
115 | |
116 // The InstallVerifier is created at startup. | |
117 virtual InstallVerifier* install_verifier() = 0; | |
118 | |
119 // Called by the ExtensionService that lives in this system. Gives the | |
120 // info map a chance to react to the load event before the EXTENSION_LOADED | |
121 // notification has fired. The purpose for handling this event first is to | |
122 // avoid race conditions by making sure URLRequestContexts learn about new | |
123 // extensions before anything else needs them to know. | |
124 virtual void RegisterExtensionWithRequestContexts( | |
125 const Extension* extension) {} | |
126 | |
127 // Called by the ExtensionService that lives in this system. Lets the | |
128 // info map clean up its RequestContexts once all the listeners to the | |
129 // EXTENSION_UNLOADED notification have finished running. | |
130 virtual void UnregisterExtensionWithRequestContexts( | |
131 const std::string& extension_id, | |
132 const UnloadedExtensionInfo::Reason reason) {} | |
133 | |
134 // Signaled when the extension system has completed its startup tasks. | |
135 virtual const OneShotEvent& ready() const = 0; | |
136 }; | |
137 | |
138 // The ExtensionSystem for ProfileImpl and OffTheRecordProfileImpl. | |
139 // Implementation details: non-shared services are owned by | |
140 // ExtensionSystemImpl, a BrowserContextKeyedService with separate incognito | |
141 // instances. A private Shared class (also a BrowserContextKeyedService, | |
142 // but with a shared instance for incognito) keeps the common services. | |
143 class ExtensionSystemImpl : public ExtensionSystem { | |
144 public: | |
145 explicit ExtensionSystemImpl(Profile* profile); | |
146 virtual ~ExtensionSystemImpl(); | |
147 | |
148 // BrowserContextKeyedService implementation. | |
149 virtual void Shutdown() OVERRIDE; | |
150 | |
151 virtual void InitForRegularProfile(bool extensions_enabled) OVERRIDE; | |
152 | |
153 virtual ExtensionService* extension_service() OVERRIDE; // shared | |
154 virtual RuntimeData* runtime_data() OVERRIDE; // shared | |
155 virtual ManagementPolicy* management_policy() OVERRIDE; // shared | |
156 virtual UserScriptMaster* user_script_master() OVERRIDE; // shared | |
157 virtual ProcessManager* process_manager() OVERRIDE; | |
158 virtual StateStore* state_store() OVERRIDE; // shared | |
159 virtual StateStore* rules_store() OVERRIDE; // shared | |
160 virtual LazyBackgroundTaskQueue* lazy_background_task_queue() | |
161 OVERRIDE; // shared | |
162 virtual InfoMap* info_map() OVERRIDE; // shared | |
163 virtual EventRouter* event_router() OVERRIDE; // shared | |
164 virtual ExtensionWarningService* warning_service() OVERRIDE; | |
165 virtual Blacklist* blacklist() OVERRIDE; // shared | |
166 virtual ErrorConsole* error_console() OVERRIDE; | |
167 virtual InstallVerifier* install_verifier() OVERRIDE; | |
168 | |
169 virtual void RegisterExtensionWithRequestContexts( | |
170 const Extension* extension) OVERRIDE; | |
171 | |
172 virtual void UnregisterExtensionWithRequestContexts( | |
173 const std::string& extension_id, | |
174 const UnloadedExtensionInfo::Reason reason) OVERRIDE; | |
175 | |
176 virtual const OneShotEvent& ready() const OVERRIDE; | |
177 | |
178 private: | |
179 friend class ExtensionSystemSharedFactory; | |
180 | |
181 // Owns the Extension-related systems that have a single instance | |
182 // shared between normal and incognito profiles. | |
183 class Shared : public BrowserContextKeyedService { | |
184 public: | |
185 explicit Shared(Profile* profile); | |
186 virtual ~Shared(); | |
187 | |
188 // Initialization takes place in phases. | |
189 virtual void InitPrefs(); | |
190 // This must not be called until all the providers have been created. | |
191 void RegisterManagementPolicyProviders(); | |
192 void Init(bool extensions_enabled); | |
193 | |
194 // BrowserContextKeyedService implementation. | |
195 virtual void Shutdown() OVERRIDE; | |
196 | |
197 StateStore* state_store(); | |
198 StateStore* rules_store(); | |
199 ExtensionService* extension_service(); | |
200 RuntimeData* runtime_data(); | |
201 ManagementPolicy* management_policy(); | |
202 UserScriptMaster* user_script_master(); | |
203 Blacklist* blacklist(); | |
204 InfoMap* info_map(); | |
205 LazyBackgroundTaskQueue* lazy_background_task_queue(); | |
206 EventRouter* event_router(); | |
207 ExtensionWarningService* warning_service(); | |
208 ErrorConsole* error_console(); | |
209 InstallVerifier* install_verifier(); | |
210 const OneShotEvent& ready() const { return ready_; } | |
211 | |
212 private: | |
213 Profile* profile_; | |
214 | |
215 // The services that are shared between normal and incognito profiles. | |
216 | |
217 scoped_ptr<StateStore> state_store_; | |
218 scoped_ptr<StateStore> rules_store_; | |
219 // LazyBackgroundTaskQueue is a dependency of | |
220 // MessageService and EventRouter. | |
221 scoped_ptr<LazyBackgroundTaskQueue> lazy_background_task_queue_; | |
222 scoped_ptr<EventRouter> event_router_; | |
223 scoped_ptr<NavigationObserver> navigation_observer_; | |
224 scoped_refptr<UserScriptMaster> user_script_master_; | |
225 scoped_ptr<Blacklist> blacklist_; | |
226 // StandardManagementPolicyProvider depends on Blacklist. | |
227 scoped_ptr<StandardManagementPolicyProvider> | |
228 standard_management_policy_provider_; | |
229 scoped_ptr<RuntimeData> runtime_data_; | |
230 // ExtensionService depends on StateStore, Blacklist and RuntimeData. | |
231 scoped_ptr<ExtensionService> extension_service_; | |
232 scoped_ptr<ManagementPolicy> management_policy_; | |
233 // extension_info_map_ needs to outlive process_manager_. | |
234 scoped_refptr<InfoMap> extension_info_map_; | |
235 scoped_ptr<ExtensionWarningService> extension_warning_service_; | |
236 scoped_ptr<ExtensionWarningBadgeService> extension_warning_badge_service_; | |
237 scoped_ptr<ErrorConsole> error_console_; | |
238 scoped_ptr<InstallVerifier> install_verifier_; | |
239 | |
240 #if defined(OS_CHROMEOS) | |
241 scoped_ptr<chromeos::DeviceLocalAccountManagementPolicyProvider> | |
242 device_local_account_management_policy_provider_; | |
243 #endif | |
244 | |
245 OneShotEvent ready_; | |
246 }; | |
247 | |
248 Profile* profile_; | |
249 | |
250 Shared* shared_; | |
251 | |
252 // |process_manager_| must be destroyed before the Profile's |io_data_|. While | |
253 // |process_manager_| still lives, we handle incoming resource requests from | |
254 // extension processes and those require access to the ResourceContext owned | |
255 // by |io_data_|. | |
256 scoped_ptr<ProcessManager> process_manager_; | |
257 | |
258 DISALLOW_COPY_AND_ASSIGN(ExtensionSystemImpl); | |
259 }; | |
260 | |
261 } // namespace extensions | |
262 | |
263 #endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_SYSTEM_H_ | |
OLD | NEW |