1 // Copyright 2014 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.
5 #ifndef EXTENSIONS_RENDERER_DISPATCHER_H_
6 #define EXTENSIONS_RENDERER_DISPATCHER_H_
14 #include "base/scoped_observer.h"
15 #include "base/timer/timer.h"
16 #include "content/public/renderer/render_process_observer.h"
17 #include "extensions/common/event_filter.h"
18 #include "extensions/common/extension_set.h"
19 #include "extensions/common/extensions_client.h"
20 #include "extensions/common/features/feature.h"
21 #include "extensions/renderer/resource_bundle_source_map.h"
22 #include "extensions/renderer/script_context.h"
23 #include "extensions/renderer/script_context_set.h"
24 #include "extensions/renderer/user_script_set_manager.h"
25 #include "extensions/renderer/v8_schema_registry.h"
26 #include "third_party/WebKit/public/platform/WebString.h"
27 #include "third_party/WebKit/public/platform/WebVector.h"
28 #include "v8/include/v8.h"
30 class ChromeRenderViewTest;
34 struct ExtensionMsg_ExternalConnectionInfo;
35 struct ExtensionMsg_Loaded_Params;
36 struct ExtensionMsg_UpdatePermissions_Params;
40 class WebSecurityOrigin;
44 class DictionaryValue;
52 namespace extensions {
54 class DispatcherDelegate;
56 class FilteredEventRouter;
57 class ManifestPermissionSet;
60 class ScriptInjectionManager;
63 // Dispatches extension control messages sent to the renderer and stores
64 // renderer extension related state.
65 class Dispatcher : public content::RenderProcessObserver,
66 public UserScriptSetManager::Observer {
68 explicit Dispatcher(DispatcherDelegate* delegate);
69 virtual ~Dispatcher();
71 const std::set<std::string>& function_names() const {
72 return function_names_;
75 bool is_extension_process() const { return is_extension_process_; }
77 const ExtensionSet* extensions() const { return &extensions_; }
79 const ScriptContextSet& script_context_set() const {
80 return script_context_set_;
83 V8SchemaRegistry* v8_schema_registry() { return v8_schema_registry_.get(); }
85 ContentWatcher* content_watcher() { return content_watcher_.get(); }
87 RequestSender* request_sender() { return request_sender_.get(); }
89 void OnRenderViewCreated(content::RenderView* render_view);
91 bool IsExtensionActive(const std::string& extension_id) const;
93 // Finds the extension for the JavaScript context associated with the
94 // specified |frame| and isolated world. If |world_id| is zero, finds the
95 // extension ID associated with the main world's JavaScript context. If the
96 // JavaScript context isn't from an extension, returns empty string.
97 const Extension* GetExtensionFromFrameAndWorld(const blink::WebFrame* frame,
99 bool use_effective_url);
101 void DidCreateScriptContext(blink::WebFrame* frame,
102 const v8::Handle<v8::Context>& context,
106 void WillReleaseScriptContext(blink::WebFrame* frame,
107 const v8::Handle<v8::Context>& context,
110 void DidCreateDocumentElement(blink::WebFrame* frame);
113 blink::WebFrame* frame,
114 const blink::WebVector<blink::WebString>& newly_matching_selectors,
115 const blink::WebVector<blink::WebString>& stopped_matching_selectors);
117 void OnExtensionResponse(int request_id,
119 const base::ListValue& response,
120 const std::string& error);
122 // Checks that the current context contains an extension that has permission
123 // to execute the specified function. If it does not, a v8 exception is thrown
124 // and the method returns false. Otherwise returns true.
125 bool CheckContextAccessToExtensionAPI(const std::string& function_name,
126 ScriptContext* context) const;
128 // Dispatches the event named |event_name| to all render views.
129 void DispatchEvent(const std::string& extension_id,
130 const std::string& event_name) const;
132 // Shared implementation of the various MessageInvoke IPCs.
133 void InvokeModuleSystemMethod(content::RenderView* render_view,
134 const std::string& extension_id,
135 const std::string& module_name,
136 const std::string& function_name,
137 const base::ListValue& args,
140 void ClearPortData(int port_id);
142 // Returns a list of (module name, resource id) pairs for the JS modules to
143 // add to the source map.
144 static std::vector<std::pair<std::string, int> > GetJsResources();
145 static void RegisterNativeHandlers(ModuleSystem* module_system,
146 ScriptContext* context,
147 Dispatcher* dispatcher,
148 RequestSender* request_sender,
149 V8SchemaRegistry* v8_schema_registry);
151 bool WasWebRequestUsedBySomeExtensions() const { return webrequest_used_; }
154 friend class ::ChromeRenderViewTest;
155 FRIEND_TEST_ALL_PREFIXES(RendererPermissionsPolicyDelegateTest,
156 CannotScriptWebstore);
158 // RenderProcessObserver implementation:
159 virtual bool OnControlMessageReceived(const IPC::Message& message) OVERRIDE;
160 virtual void WebKitInitialized() OVERRIDE;
161 virtual void IdleNotification() OVERRIDE;
162 virtual void OnRenderProcessShutdown() OVERRIDE;
164 void OnActivateExtension(const std::string& extension_id);
165 void OnCancelSuspend(const std::string& extension_id);
166 void OnClearTabSpecificPermissions(
168 const std::vector<std::string>& extension_ids);
169 void OnDeliverMessage(int target_port_id, const Message& message);
170 void OnDispatchOnConnect(int target_port_id,
171 const std::string& channel_name,
172 const base::DictionaryValue& source_tab,
173 const ExtensionMsg_ExternalConnectionInfo& info,
174 const std::string& tls_channel_id);
175 void OnDispatchOnDisconnect(int port_id, const std::string& error_message);
177 const std::vector<ExtensionMsg_Loaded_Params>& loaded_extensions);
178 void OnLoadedInternal(scoped_refptr<const Extension> extension);
179 void OnMessageInvoke(const std::string& extension_id,
180 const std::string& module_name,
181 const std::string& function_name,
182 const base::ListValue& args,
184 void OnSetChannel(int channel);
185 void OnSetFunctionNames(const std::vector<std::string>& names);
186 void OnSetScriptingWhitelist(
187 const ExtensionsClient::ScriptingWhitelist& extension_ids);
188 void OnSetSystemFont(const std::string& font_family,
189 const std::string& font_size);
190 void OnShouldSuspend(const std::string& extension_id, uint64 sequence_id);
191 void OnSuspend(const std::string& extension_id);
192 void OnTransferBlobs(const std::vector<std::string>& blob_uuids);
193 void OnUnloaded(const std::string& id);
194 void OnUpdatePermissions(const ExtensionMsg_UpdatePermissions_Params& params);
195 void OnUpdateTabSpecificPermissions(const GURL& url,
197 const std::string& extension_id,
198 const URLPatternSet& origin_set);
199 void OnUsingWebRequestAPI(bool webrequest_used);
201 // UserScriptSetManager::Observer implementation.
202 virtual void OnUserScriptsUpdated(
203 const std::set<std::string>& changed_extensions,
204 const std::vector<UserScript*>& scripts) OVERRIDE;
206 void UpdateActiveExtensions();
208 // Sets up the host permissions for |extension|.
209 void InitOriginPermissions(const Extension* extension);
211 // Updates the host permissions for extension to include only those in
212 // |new_patterns|, and remove from |old_patterns| that are no longer allowed.
213 void UpdateOriginPermissions(const Extension* extension,
214 const URLPatternSet& old_patterns,
215 const URLPatternSet& new_patterns);
217 // Enable custom element whitelist in Apps.
218 void EnableCustomElementWhiteList();
220 // Adds or removes bindings for every context belonging to |extension_id|, or
221 // or all contexts if |extension_id| is empty.
222 void UpdateBindings(const std::string& extension_id);
224 void UpdateBindingsForContext(ScriptContext* context);
226 void RegisterBinding(const std::string& api_name, ScriptContext* context);
228 void RegisterNativeHandlers(ModuleSystem* module_system,
229 ScriptContext* context);
231 // Inserts static source code into |source_map_|.
232 void PopulateSourceMap();
234 // Returns whether the current renderer hosts a platform app.
235 bool IsWithinPlatformApp();
237 bool IsSandboxedPage(const GURL& url) const;
239 // Returns the Feature::Context type of context for a JavaScript context.
240 Feature::Context ClassifyJavaScriptContext(
241 const Extension* extension,
244 const blink::WebSecurityOrigin& origin);
246 // Gets |field| from |object| or creates it as an empty object if it doesn't
248 v8::Handle<v8::Object> GetOrCreateObject(const v8::Handle<v8::Object>& object,
249 const std::string& field,
250 v8::Isolate* isolate);
252 v8::Handle<v8::Object> GetOrCreateBindObjectIfAvailable(
253 const std::string& api_name,
254 std::string* bind_name,
255 ScriptContext* context);
257 // The delegate for this dispatcher. Not owned, but must extend beyond the
258 // Dispatcher's own lifetime.
259 DispatcherDelegate* delegate_;
261 // True if this renderer is running extensions.
262 bool is_extension_process_;
264 // Contains all loaded extensions. This is essentially the renderer
265 // counterpart to ExtensionService in the browser. It contains information
266 // about all extensions currently loaded by the browser.
267 ExtensionSet extensions_;
269 // The IDs of extensions that failed to load, mapped to the error message
270 // generated on failure.
271 std::map<std::string, std::string> extension_load_errors_;
273 // All the bindings contexts that are currently loaded for this renderer.
274 // There is zero or one for each v8 context.
275 ScriptContextSet script_context_set_;
277 scoped_ptr<ContentWatcher> content_watcher_;
279 scoped_ptr<UserScriptSetManager> user_script_set_manager_;
281 scoped_ptr<ScriptInjectionManager> script_injection_manager_;
283 // Same as above, but on a longer timer and will run even if the process is
284 // not idle, to ensure that IdleHandle gets called eventually.
285 scoped_ptr<base::RepeatingTimer<content::RenderThread> > forced_idle_timer_;
287 // All declared function names.
288 std::set<std::string> function_names_;
290 // The extensions and apps that are active in this process.
291 std::set<std::string> active_extension_ids_;
293 ResourceBundleSourceMap source_map_;
295 // Cache for the v8 representation of extension API schemas.
296 scoped_ptr<V8SchemaRegistry> v8_schema_registry_;
298 // Sends API requests to the extension host.
299 scoped_ptr<RequestSender> request_sender_;
301 // The platforms system font family and size;
302 std::string system_font_family_;
303 std::string system_font_size_;
305 // Mapping of port IDs to tabs. If there is no tab, the value would be -1.
306 std::map<int, int> port_to_tab_id_map_;
308 // True once WebKit has been initialized (and it is therefore safe to poke).
309 bool is_webkit_initialized_;
311 // It is important for this to come after the ScriptInjectionManager, so that
312 // the observer is destroyed before the UserScriptSet.
313 ScopedObserver<UserScriptSetManager, UserScriptSetManager::Observer>
314 user_script_set_manager_observer_;
316 // Status of webrequest usage.
317 bool webrequest_used_;
319 DISALLOW_COPY_AND_ASSIGN(Dispatcher);
322 } // namespace extensions
324 #endif // EXTENSIONS_RENDERER_DISPATCHER_H_