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 71 const std::set<std::string>& function_names() const { 72 return function_names_; 73 } 74 75 bool is_extension_process() const { return is_extension_process_; } 76 77 const ExtensionSet* extensions() const { return &extensions_; } 78 79 const ScriptContextSet& script_context_set() const { 80 return script_context_set_; 81 } 82 83 V8SchemaRegistry* v8_schema_registry() { return v8_schema_registry_.get(); } 84 85 ContentWatcher* content_watcher() { return content_watcher_.get(); } 86 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 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
