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_SCRIPT_CONTEXT_H_ 6#define EXTENSIONS_RENDERER_SCRIPT_CONTEXT_H_ 7 8#include <string> 9 10#include "base/basictypes.h" 11#include "base/compiler_specific.h" 12#include "extensions/common/features/feature.h" 13#include "extensions/renderer/module_system.h" 14#include "extensions/renderer/request_sender.h" 15#include "extensions/renderer/safe_builtins.h" 16#include "extensions/renderer/scoped_persistent.h" 17#include "v8/include/v8.h" 18 19namespace blink { 20class WebFrame; 21} 22 23namespace content { 24class RenderView; 25} 26 27namespace extensions { 28class Extension; 29 30// Extensions wrapper for a v8 context. 31class ScriptContext : public RequestSender::Source { 32 public: 33 ScriptContext(const v8::Handle<v8::Context>& context, 34 blink::WebFrame* frame, 35 const Extension* extension, 36 Feature::Context context_type); 37 virtual ~ScriptContext(); 38 39 // Clears the WebFrame for this contexts and invalidates the associated 40 // ModuleSystem. 41 void Invalidate(); 42 43 // Returns true if this context is still valid, false if it isn't. 44 // A context becomes invalid via Invalidate(). 45 bool is_valid() const { return !v8_context_.IsEmpty(); } 46 47 v8::Handle<v8::Context> v8_context() const { 48 return v8_context_.NewHandle(isolate()); 49 } 50 51 const Extension* extension() const { return extension_.get(); } 52 53 blink::WebFrame* web_frame() const { return web_frame_; } 54 55 Feature::Context context_type() const { return context_type_; } 56 57 void set_module_system(scoped_ptr<ModuleSystem> module_system) { 58 module_system_ = module_system.Pass(); 59 } 60 61 ModuleSystem* module_system() { return module_system_.get(); } 62 63 SafeBuiltins* safe_builtins() { return &safe_builtins_; } 64 65 const SafeBuiltins* safe_builtins() const { return &safe_builtins_; } 66 67 // Returns the ID of the extension associated with this context, or empty 68 // string if there is no such extension. 69 const std::string& GetExtensionID() const; 70 71 // Returns the RenderView associated with this context. Can return NULL if the 72 // context is in the process of being destroyed. 73 content::RenderView* GetRenderView() const; 74 75 // Runs |function| with appropriate scopes. Doesn't catch exceptions, callers 76 // must do that if they want. 77 // 78 // USE THIS METHOD RATHER THAN v8::Function::Call WHEREVER POSSIBLE. 79 v8::Local<v8::Value> CallFunction(v8::Handle<v8::Function> function, 80 int argc, 81 v8::Handle<v8::Value> argv[]) const; 82 83 void DispatchEvent(const char* event_name, v8::Handle<v8::Array> args) const; 84 85 // Fires the onunload event on the unload_event module. 86 void DispatchOnUnloadEvent(); 87 88 // Returns the availability of the API |api_name|. 89 Feature::Availability GetAvailability(const std::string& api_name); 90 91 // Returns a string description of the type of context this is. 92 std::string GetContextTypeDescription(); 93 94 v8::Isolate* isolate() const { return isolate_; } 95 96 // Get the URL of this context's web frame. 97 GURL GetURL() const; 98 99 // Returns whether the API |api| or any part of the API could be 100 // available in this context without taking into account the context's 101 // extension. 102 bool IsAnyFeatureAvailableToContext(const extensions::Feature& api); 103 104 // Utility to get the URL we will match against for a frame. If the frame has 105 // committed, this is the commited URL. Otherwise it is the provisional URL. 106 static GURL GetDataSourceURLForFrame(const blink::WebFrame* frame); 107 108 // Returns the first non-about:-URL in the document hierarchy above and 109 // including |frame|. The document hierarchy is only traversed if 110 // |document_url| is an about:-URL and if |match_about_blank| is true. 111 static GURL GetEffectiveDocumentURL(const blink::WebFrame* frame, 112 const GURL& document_url, 113 bool match_about_blank); 114 115 // RequestSender::Source implementation. 116 virtual ScriptContext* GetContext() OVERRIDE; 117 virtual void OnResponseReceived(const std::string& name, 118 int request_id, 119 bool success, 120 const base::ListValue& response, 121 const std::string& error) OVERRIDE; 122 123 protected: 124 // The v8 context the bindings are accessible to. 125 ScopedPersistent<v8::Context> v8_context_; 126 127 private: 128 // The WebFrame associated with this context. This can be NULL because this 129 // object can outlive is destroyed asynchronously. 130 blink::WebFrame* web_frame_; 131 132 // The extension associated with this context, or NULL if there is none. This 133 // might be a hosted app in the case that this context is hosting a web URL. 134 scoped_refptr<const Extension> extension_; 135 136 // The type of context. 137 Feature::Context context_type_; 138 139 // Owns and structures the JS that is injected to set up extension bindings. 140 scoped_ptr<ModuleSystem> module_system_; 141 142 // Contains safe copies of builtin objects like Function.prototype. 143 SafeBuiltins safe_builtins_; 144 145 v8::Isolate* isolate_; 146 147 DISALLOW_COPY_AND_ASSIGN(ScriptContext); 148}; 149 150} // namespace extensions 151 152#endif // EXTENSIONS_RENDERER_SCRIPT_CONTEXT_H_ 153