extensions/renderer/dispatcher.h

   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   ~Dispatcher() override;
  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   bool OnControlMessageReceived(const IPC::Message& message) override;
 160   void WebKitInitialized() override;
 161   void IdleNotification() override;
 162   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   void OnUserScriptsUpdated(const std::set<std::string>& changed_extensions,
 203                             const std::vector<UserScript*>& scripts) override;
 204
 205   void UpdateActiveExtensions();
 206
 207   // Sets up the host permissions for |extension|.
 208   void InitOriginPermissions(const Extension* extension);
 209
 210   // Updates the host permissions for extension to include only those in
 211   // |new_patterns|, and remove from |old_patterns| that are no longer allowed.
 212   void UpdateOriginPermissions(const Extension* extension,
 213                                const URLPatternSet& old_patterns,
 214                                const URLPatternSet& new_patterns);
 215
 216   // Enable custom element whitelist in Apps.
 217   void EnableCustomElementWhiteList();
 218
 219   // Adds or removes bindings for every context belonging to |extension_id|, or
 220   // or all contexts if |extension_id| is empty.
 221   void UpdateBindings(const std::string& extension_id);
 222
 223   void UpdateBindingsForContext(ScriptContext* context);
 224
 225   void RegisterBinding(const std::string& api_name, ScriptContext* context);
 226
 227   void RegisterNativeHandlers(ModuleSystem* module_system,
 228                               ScriptContext* context);
 229
 230   // Inserts static source code into |source_map_|.
 231   void PopulateSourceMap();
 232
 233   // Returns whether the current renderer hosts a platform app.
 234   bool IsWithinPlatformApp();
 235
 236   bool IsSandboxedPage(const GURL& url) const;
 237
 238   // Returns the Feature::Context type of context for a JavaScript context.
 239   Feature::Context ClassifyJavaScriptContext(
 240       const Extension* extension,
 241       int extension_group,
 242       const GURL& url,
 243       const blink::WebSecurityOrigin& origin);
 244
 245   // Gets |field| from |object| or creates it as an empty object if it doesn't
 246   // exist.
 247   v8::Handle<v8::Object> GetOrCreateObject(const v8::Handle<v8::Object>& object,
 248                                            const std::string& field,
 249                                            v8::Isolate* isolate);
 250
 251   v8::Handle<v8::Object> GetOrCreateBindObjectIfAvailable(
 252       const std::string& api_name,
 253       std::string* bind_name,
 254       ScriptContext* context);
 255
 256   // The delegate for this dispatcher. Not owned, but must extend beyond the
 257   // Dispatcher's own lifetime.
 258   DispatcherDelegate* delegate_;
 259
 260   // True if this renderer is running extensions.
 261   bool is_extension_process_;
 262
 263   // Contains all loaded extensions.  This is essentially the renderer
 264   // counterpart to ExtensionService in the browser. It contains information
 265   // about all extensions currently loaded by the browser.
 266   ExtensionSet extensions_;
 267
 268   // The IDs of extensions that failed to load, mapped to the error message
 269   // generated on failure.
 270   std::map<std::string, std::string> extension_load_errors_;
 271
 272   // All the bindings contexts that are currently loaded for this renderer.
 273   // There is zero or one for each v8 context.
 274   ScriptContextSet script_context_set_;
 275
 276   scoped_ptr<ContentWatcher> content_watcher_;
 277
 278   scoped_ptr<UserScriptSetManager> user_script_set_manager_;
 279
 280   scoped_ptr<ScriptInjectionManager> script_injection_manager_;
 281
 282   // Same as above, but on a longer timer and will run even if the process is
 283   // not idle, to ensure that IdleHandle gets called eventually.
 284   scoped_ptr<base::RepeatingTimer<content::RenderThread> > forced_idle_timer_;
 285
 286   // All declared function names.
 287   std::set<std::string> function_names_;
 288
 289   // The extensions and apps that are active in this process.
 290   std::set<std::string> active_extension_ids_;
 291
 292   ResourceBundleSourceMap source_map_;
 293
 294   // Cache for the v8 representation of extension API schemas.
 295   scoped_ptr<V8SchemaRegistry> v8_schema_registry_;
 296
 297   // Sends API requests to the extension host.
 298   scoped_ptr<RequestSender> request_sender_;
 299
 300   // The platforms system font family and size;
 301   std::string system_font_family_;
 302   std::string system_font_size_;
 303
 304   // Mapping of port IDs to tabs. If there is no tab, the value would be -1.
 305   std::map<int, int> port_to_tab_id_map_;
 306
 307   // True once WebKit has been initialized (and it is therefore safe to poke).
 308   bool is_webkit_initialized_;
 309
 310   // It is important for this to come after the ScriptInjectionManager, so that
 311   // the observer is destroyed before the UserScriptSet.
 312   ScopedObserver<UserScriptSetManager, UserScriptSetManager::Observer>
 313       user_script_set_manager_observer_;
 314
 315   // Status of webrequest usage.
 316   bool webrequest_used_;
 317
 318   DISALLOW_COPY_AND_ASSIGN(Dispatcher);
 319 };
 320
 321 }  // namespace extensions
 322
 323 #endif  // EXTENSIONS_RENDERER_DISPATCHER_H_