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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
// Copyright (c) 2012 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_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__
#define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__
#include <map>
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_vector.h"
#include "base/scoped_observer.h"
#include "chrome/browser/extensions/api/declarative/rules_registry.h"
#include "chrome/browser/profiles/profile.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "extensions/browser/browser_context_keyed_api_factory.h"
#include "extensions/browser/extension_registry_observer.h"
class Profile;
namespace content {
class BrowserContext;
class NotificationSource;
}
namespace extensions {
class ContentRulesRegistry;
class ExtensionRegistry;
class RulesRegistry;
class RulesRegistryStorageDelegate;
}
namespace extensions {
// This class owns all RulesRegistries implementations of an ExtensionService.
// This class lives on the UI thread.
class RulesRegistryService : public BrowserContextKeyedAPI,
public content::NotificationObserver,
public ExtensionRegistryObserver {
public:
typedef RulesRegistry::WebViewKey WebViewKey;
struct RulesRegistryKey {
std::string event_name;
WebViewKey webview_key;
RulesRegistryKey(const std::string event_name,
const WebViewKey& webview_key)
: event_name(event_name),
webview_key(webview_key) {}
bool operator<(const RulesRegistryKey& other) const {
return (event_name < other.event_name) ||
((event_name == other.event_name) &&
(webview_key < other.webview_key));
}
};
explicit RulesRegistryService(content::BrowserContext* context);
virtual ~RulesRegistryService();
// Unregisters refptrs to concrete RulesRegistries at other objects that were
// created by us so that the RulesRegistries can be released.
virtual void Shutdown() OVERRIDE;
// BrowserContextKeyedAPI implementation.
static BrowserContextKeyedAPIFactory<RulesRegistryService>*
GetFactoryInstance();
// Convenience method to get the RulesRegistryService for a profile.
static RulesRegistryService* Get(content::BrowserContext* context);
// Registers the default RulesRegistries used in Chromium.
void EnsureDefaultRulesRegistriesRegistered(const WebViewKey& webview_key);
// Registers a RulesRegistry and wraps it in an InitializingRulesRegistry.
void RegisterRulesRegistry(scoped_refptr<RulesRegistry> rule_registry);
// Returns the RulesRegistry for |event_name| and |webview_key| or NULL if no
// such registry has been registered. Default rules registries (such as the
// WebRequest rules registry) will be created on first access.
scoped_refptr<RulesRegistry> GetRulesRegistry(
const WebViewKey& webview_key,
const std::string& event_name);
// Accessors for each type of rules registry.
ContentRulesRegistry* content_rules_registry() const {
CHECK(content_rules_registry_);
return content_rules_registry_;
}
// Removes all rules registries of a given webview embedder process ID.
void RemoveWebViewRulesRegistries(int process_id);
// For testing.
void SimulateExtensionUninstalled(const std::string& extension_id);
private:
friend class BrowserContextKeyedAPIFactory<RulesRegistryService>;
// Maps <event name, webview key> to RuleRegistries that handle these
// events.
typedef std::map<RulesRegistryKey, scoped_refptr<RulesRegistry> >
RulesRegistryMap;
// Implementation of content::NotificationObserver.
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
// ExtensionRegistryObserver implementation.
virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
const Extension* extension) OVERRIDE;
virtual void OnExtensionUnloaded(
content::BrowserContext* browser_context,
const Extension* extension,
UnloadedExtensionInfo::Reason reason) OVERRIDE;
virtual void OnExtensionUninstalled(
content::BrowserContext* browser_context,
const Extension* extension,
extensions::UninstallReason reason) OVERRIDE;
// Iterates over all registries, and calls |notification_callback| on them
// with |extension_id| as the argument. If a registry lives on a different
// thread, the call is posted to that thread, so no guarantee of synchronous
// processing.
void NotifyRegistriesHelper(
void (RulesRegistry::*notification_callback)(const std::string&),
const std::string& extension_id);
// BrowserContextKeyedAPI implementation.
static const char* service_name() {
return "RulesRegistryService";
}
static const bool kServiceHasOwnInstanceInIncognito = true;
static const bool kServiceIsNULLWhileTesting = true;
RulesRegistryMap rule_registries_;
// We own the parts of the registries which need to run on the UI thread.
ScopedVector<RulesCacheDelegate> cache_delegates_;
// Weak pointer into rule_registries_ to make it easier to handle content rule
// conditions.
ContentRulesRegistry* content_rules_registry_;
content::NotificationRegistrar registrar_;
// Listen to extension load, unloaded notification.
ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
extension_registry_observer_;
Profile* profile_;
DISALLOW_COPY_AND_ASSIGN(RulesRegistryService);
};
} // namespace extensions
#endif // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__
|
