• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.
4 
5 #ifndef EXTENSIONS_RENDERER_DISPATCHER_H_
6 #define EXTENSIONS_RENDERER_DISPATCHER_H_
7 
8 #include <map>
9 #include <set>
10 #include <string>
11 #include <utility>
12 #include <vector>
13 
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"
29 
30 class ChromeRenderViewTest;
31 class GURL;
32 class ModuleSystem;
33 class URLPattern;
34 struct ExtensionMsg_ExternalConnectionInfo;
35 struct ExtensionMsg_Loaded_Params;
36 struct ExtensionMsg_UpdatePermissions_Params;
37 
38 namespace blink {
39 class WebFrame;
40 class WebSecurityOrigin;
41 }
42 
43 namespace base {
44 class DictionaryValue;
45 class ListValue;
46 }
47 
48 namespace content {
49 class RenderThread;
50 }
51 
52 namespace extensions {
53 class ContentWatcher;
54 class DispatcherDelegate;
55 class Extension;
56 class FilteredEventRouter;
57 class ManifestPermissionSet;
58 class RequestSender;
59 class ScriptContext;
60 class ScriptInjectionManager;
61 struct Message;
62 
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 {
67  public:
68   explicit Dispatcher(DispatcherDelegate* delegate);
69   virtual ~Dispatcher();
70 
function_names()71   const std::set<std::string>& function_names() const {
72     return function_names_;
73   }
74 
is_extension_process()75   bool is_extension_process() const { return is_extension_process_; }
76 
extensions()77   const ExtensionSet* extensions() const { return &extensions_; }
78 
script_context_set()79   const ScriptContextSet& script_context_set() const {
80     return script_context_set_;
81   }
82 
v8_schema_registry()83   V8SchemaRegistry* v8_schema_registry() { return v8_schema_registry_.get(); }
84 
content_watcher()85   ContentWatcher* content_watcher() { return content_watcher_.get(); }
86 
request_sender()87   RequestSender* request_sender() { return request_sender_.get(); }
88 
89   void OnRenderViewCreated(content::RenderView* render_view);
90 
91   bool IsExtensionActive(const std::string& extension_id) const;
92 
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,
98                                                  int world_id,
99                                                  bool use_effective_url);
100 
101   void DidCreateScriptContext(blink::WebFrame* frame,
102                               const v8::Handle<v8::Context>& context,
103                               int extension_group,
104                               int world_id);
105 
106   void WillReleaseScriptContext(blink::WebFrame* frame,
107                                 const v8::Handle<v8::Context>& context,
108                                 int world_id);
109 
110   void DidCreateDocumentElement(blink::WebFrame* frame);
111 
112   void DidMatchCSS(
113       blink::WebFrame* frame,
114       const blink::WebVector<blink::WebString>& newly_matching_selectors,
115       const blink::WebVector<blink::WebString>& stopped_matching_selectors);
116 
117   void OnExtensionResponse(int request_id,
118                            bool success,
119                            const base::ListValue& response,
120                            const std::string& error);
121 
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;
127 
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;
131 
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,
138                                 bool user_gesture);
139 
140   void ClearPortData(int port_id);
141 
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);
150 
WasWebRequestUsedBySomeExtensions()151   bool WasWebRequestUsedBySomeExtensions() const { return webrequest_used_; }
152 
153  private:
154   friend class ::ChromeRenderViewTest;
155   FRIEND_TEST_ALL_PREFIXES(RendererPermissionsPolicyDelegateTest,
156                            CannotScriptWebstore);
157 
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;
163 
164   void OnActivateExtension(const std::string& extension_id);
165   void OnCancelSuspend(const std::string& extension_id);
166   void OnClearTabSpecificPermissions(
167       int tab_id,
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);
176   void OnLoaded(
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,
183                        bool user_gesture);
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,
196                                       int tab_id,
197                                       const std::string& extension_id,
198                                       const URLPatternSet& origin_set);
199   void OnUsingWebRequestAPI(bool webrequest_used);
200 
201   // UserScriptSetManager::Observer implementation.
202   virtual void OnUserScriptsUpdated(
203       const std::set<std::string>& changed_extensions,
204       const std::vector<UserScript*>& scripts) OVERRIDE;
205 
206   void UpdateActiveExtensions();
207 
208   // Sets up the host permissions for |extension|.
209   void InitOriginPermissions(const Extension* extension);
210 
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);
216 
217   // Enable custom element whitelist in Apps.
218   void EnableCustomElementWhiteList();
219 
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);
223 
224   void UpdateBindingsForContext(ScriptContext* context);
225 
226   void RegisterBinding(const std::string& api_name, ScriptContext* context);
227 
228   void RegisterNativeHandlers(ModuleSystem* module_system,
229                               ScriptContext* context);
230 
231   // Inserts static source code into |source_map_|.
232   void PopulateSourceMap();
233 
234   // Returns whether the current renderer hosts a platform app.
235   bool IsWithinPlatformApp();
236 
237   bool IsSandboxedPage(const GURL& url) const;
238 
239   // Returns the Feature::Context type of context for a JavaScript context.
240   Feature::Context ClassifyJavaScriptContext(
241       const Extension* extension,
242       int extension_group,
243       const GURL& url,
244       const blink::WebSecurityOrigin& origin);
245 
246   // Gets |field| from |object| or creates it as an empty object if it doesn't
247   // exist.
248   v8::Handle<v8::Object> GetOrCreateObject(const v8::Handle<v8::Object>& object,
249                                            const std::string& field,
250                                            v8::Isolate* isolate);
251 
252   v8::Handle<v8::Object> GetOrCreateBindObjectIfAvailable(
253       const std::string& api_name,
254       std::string* bind_name,
255       ScriptContext* context);
256 
257   // The delegate for this dispatcher. Not owned, but must extend beyond the
258   // Dispatcher's own lifetime.
259   DispatcherDelegate* delegate_;
260 
261   // True if this renderer is running extensions.
262   bool is_extension_process_;
263 
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_;
268 
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_;
272 
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_;
276 
277   scoped_ptr<ContentWatcher> content_watcher_;
278 
279   scoped_ptr<UserScriptSetManager> user_script_set_manager_;
280 
281   scoped_ptr<ScriptInjectionManager> script_injection_manager_;
282 
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_;
286 
287   // All declared function names.
288   std::set<std::string> function_names_;
289 
290   // The extensions and apps that are active in this process.
291   std::set<std::string> active_extension_ids_;
292 
293   ResourceBundleSourceMap source_map_;
294 
295   // Cache for the v8 representation of extension API schemas.
296   scoped_ptr<V8SchemaRegistry> v8_schema_registry_;
297 
298   // Sends API requests to the extension host.
299   scoped_ptr<RequestSender> request_sender_;
300 
301   // The platforms system font family and size;
302   std::string system_font_family_;
303   std::string system_font_size_;
304 
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_;
307 
308   // True once WebKit has been initialized (and it is therefore safe to poke).
309   bool is_webkit_initialized_;
310 
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_;
315 
316   // Status of webrequest usage.
317   bool webrequest_used_;
318 
319   DISALLOW_COPY_AND_ASSIGN(Dispatcher);
320 };
321 
322 }  // namespace extensions
323 
324 #endif  // EXTENSIONS_RENDERER_DISPATCHER_H_
325