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_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__ | |
6 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__ | |
7 | |
8 #include <map> | |
9 #include <string> | |
10 #include <vector> | |
11 | |
12 #include "base/callback_forward.h" | |
13 #include "base/memory/ref_counted.h" | |
14 #include "base/memory/scoped_vector.h" | |
15 #include "base/scoped_observer.h" | |
16 #include "content/public/browser/notification_observer.h" | |
17 #include "content/public/browser/notification_registrar.h" | |
18 #include "extensions/browser/api/declarative/rules_registry.h" | |
19 #include "extensions/browser/browser_context_keyed_api_factory.h" | |
20 #include "extensions/browser/extension_registry_observer.h" | |
21 | |
22 namespace content { | |
23 class BrowserContext; | |
24 class NotificationSource; | |
25 } | |
26 | |
27 namespace extensions { | |
28 class ContentRulesRegistry; | |
29 class ExtensionRegistry; | |
30 class RulesRegistryStorageDelegate; | |
31 } | |
32 | |
33 namespace extensions { | |
34 | |
35 // This class owns all RulesRegistries implementations of an ExtensionService. | |
36 // This class lives on the UI thread. | |
37 class RulesRegistryService : public BrowserContextKeyedAPI, | |
38 public content::NotificationObserver, | |
39 public ExtensionRegistryObserver { | |
40 public: | |
41 typedef RulesRegistry::WebViewKey WebViewKey; | |
42 struct RulesRegistryKey { | |
43 std::string event_name; | |
44 WebViewKey webview_key; | |
45 RulesRegistryKey(const std::string event_name, | |
46 const WebViewKey& webview_key) | |
47 : event_name(event_name), | |
48 webview_key(webview_key) {} | |
49 bool operator<(const RulesRegistryKey& other) const { | |
50 return (event_name < other.event_name) || | |
51 ((event_name == other.event_name) && | |
52 (webview_key < other.webview_key)); | |
53 } | |
54 }; | |
55 | |
56 explicit RulesRegistryService(content::BrowserContext* context); | |
57 virtual ~RulesRegistryService(); | |
58 | |
59 // Unregisters refptrs to concrete RulesRegistries at other objects that were | |
60 // created by us so that the RulesRegistries can be released. | |
61 virtual void Shutdown() OVERRIDE; | |
62 | |
63 // BrowserContextKeyedAPI implementation. | |
64 static BrowserContextKeyedAPIFactory<RulesRegistryService>* | |
65 GetFactoryInstance(); | |
66 | |
67 // Convenience method to get the RulesRegistryService for a context. | |
68 static RulesRegistryService* Get(content::BrowserContext* context); | |
69 | |
70 // Registers the default RulesRegistries used in Chromium. | |
71 void EnsureDefaultRulesRegistriesRegistered(const WebViewKey& webview_key); | |
72 | |
73 // Registers a RulesRegistry and wraps it in an InitializingRulesRegistry. | |
74 void RegisterRulesRegistry(scoped_refptr<RulesRegistry> rule_registry); | |
75 | |
76 // Returns the RulesRegistry for |event_name| and |webview_key| or NULL if no | |
77 // such registry has been registered. Default rules registries (such as the | |
78 // WebRequest rules registry) will be created on first access. | |
79 scoped_refptr<RulesRegistry> GetRulesRegistry(const WebViewKey& webview_key, | |
80 const std::string& event_name); | |
81 | |
82 // Accessors for each type of rules registry. | |
83 ContentRulesRegistry* content_rules_registry() const { | |
84 CHECK(content_rules_registry_); | |
85 return content_rules_registry_; | |
86 } | |
87 | |
88 // Removes all rules registries of a given webview embedder process ID. | |
89 void RemoveWebViewRulesRegistries(int process_id); | |
90 | |
91 // For testing. | |
92 void SimulateExtensionUninstalled(const std::string& extension_id); | |
93 | |
94 private: | |
95 friend class BrowserContextKeyedAPIFactory<RulesRegistryService>; | |
96 | |
97 // Maps <event name, webview key> to RuleRegistries that handle these | |
98 // events. | |
99 typedef std::map<RulesRegistryKey, scoped_refptr<RulesRegistry> > | |
100 RulesRegistryMap; | |
101 | |
102 // Implementation of content::NotificationObserver. | |
103 virtual void Observe(int type, | |
104 const content::NotificationSource& source, | |
105 const content::NotificationDetails& details) OVERRIDE; | |
106 | |
107 // ExtensionRegistryObserver implementation. | |
108 virtual void OnExtensionLoaded(content::BrowserContext* browser_context, | |
109 const Extension* extension) OVERRIDE; | |
110 virtual void OnExtensionUnloaded( | |
111 content::BrowserContext* browser_context, | |
112 const Extension* extension, | |
113 UnloadedExtensionInfo::Reason reason) OVERRIDE; | |
114 virtual void OnExtensionUninstalled( | |
115 content::BrowserContext* browser_context, | |
116 const Extension* extension, | |
117 extensions::UninstallReason reason) OVERRIDE; | |
118 | |
119 // Iterates over all registries, and calls |notification_callback| on them | |
120 // with |extension_id| as the argument. If a registry lives on a different | |
121 // thread, the call is posted to that thread, so no guarantee of synchronous | |
122 // processing. | |
123 void NotifyRegistriesHelper( | |
124 void (RulesRegistry::*notification_callback)(const std::string&), | |
125 const std::string& extension_id); | |
126 | |
127 // BrowserContextKeyedAPI implementation. | |
128 static const char* service_name() { | |
129 return "RulesRegistryService"; | |
130 } | |
131 static const bool kServiceHasOwnInstanceInIncognito = true; | |
132 static const bool kServiceIsNULLWhileTesting = true; | |
133 | |
134 RulesRegistryMap rule_registries_; | |
135 | |
136 // We own the parts of the registries which need to run on the UI thread. | |
137 ScopedVector<RulesCacheDelegate> cache_delegates_; | |
138 | |
139 // Weak pointer into rule_registries_ to make it easier to handle content rule | |
140 // conditions. | |
141 ContentRulesRegistry* content_rules_registry_; | |
142 | |
143 content::NotificationRegistrar registrar_; | |
144 | |
145 // Listen to extension load, unloaded notification. | |
146 ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver> | |
147 extension_registry_observer_; | |
148 | |
149 content::BrowserContext* browser_context_; | |
150 | |
151 DISALLOW_COPY_AND_ASSIGN(RulesRegistryService); | |
152 }; | |
153 | |
154 } // namespace extensions | |
155 | |
156 #endif // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__ | |
OLD | NEW |