6e9ddca08de0f6818a07675baa6f4ae4deeebbeb
[WebKit-https.git] / Source / WebCore / bindings / js / ScriptController.h
1 /*
2  *  Copyright (C) 1999 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2008-2017 Apple Inc. All rights reserved.
5  *  Copyright (C) 2008 Eric Seidel <eric@webkit.org>
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public
18  *  License along with this library; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #pragma once
23
24 #include "FrameLoaderTypes.h"
25 #include "JSWindowProxy.h"
26 #include "WindowProxy.h"
27 #include <JavaScriptCore/JSBase.h>
28 #include <JavaScriptCore/Strong.h>
29 #include <wtf/Forward.h>
30 #include <wtf/RefPtr.h>
31 #include <wtf/text/TextPosition.h>
32
33 #if PLATFORM(COCOA)
34 #include <wtf/RetainPtr.h>
35 OBJC_CLASS JSContext;
36 OBJC_CLASS WebScriptObject;
37 #endif
38
39 struct NPObject;
40
41 namespace JSC {
42 class ExecState;
43 class JSGlobalObject;
44 class JSInternalPromise;
45 class JSModuleRecord;
46
47 namespace Bindings {
48 class Instance;
49 class RootObject;
50 }
51 }
52
53 namespace WebCore {
54
55 class CachedScriptFetcher;
56 class Frame;
57 class HTMLDocument;
58 class HTMLPlugInElement;
59 class LoadableModuleScript;
60 class ModuleFetchParameters;
61 class ScriptSourceCode;
62 class SecurityOrigin;
63 class Widget;
64 struct ExceptionDetails;
65
66 enum ReasonForCallingCanExecuteScripts {
67     AboutToCreateEventListener,
68     AboutToExecuteScript,
69     NotAboutToExecuteScript
70 };
71
72 class ScriptController {
73     WTF_MAKE_FAST_ALLOCATED;
74
75     using RootObjectMap = HashMap<void*, Ref<JSC::Bindings::RootObject>>;
76
77 public:
78     explicit ScriptController(Frame&);
79     ~ScriptController();
80
81     WEBCORE_EXPORT static Ref<DOMWrapperWorld> createWorld();
82
83     JSDOMWindow* globalObject(DOMWrapperWorld& world)
84     {
85         return JSC::jsCast<JSDOMWindow*>(jsWindowProxy(world).window());
86     }
87
88     static void getAllWorlds(Vector<Ref<DOMWrapperWorld>>&);
89
90     JSC::JSValue executeScript(const ScriptSourceCode&, ExceptionDetails* = nullptr);
91     WEBCORE_EXPORT JSC::JSValue executeScript(const String& script, bool forceUserGesture = false, ExceptionDetails* = nullptr);
92     WEBCORE_EXPORT JSC::JSValue executeScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture = false, ExceptionDetails* = nullptr);
93
94     // Returns true if argument is a JavaScript URL.
95     bool executeIfJavaScriptURL(const URL&, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL = ReplaceDocumentIfJavaScriptURL);
96
97     // This function must be called from the main thread. It is safe to call it repeatedly.
98     // Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly.
99     static void initializeThreading();
100
101     JSC::JSValue evaluate(const ScriptSourceCode&, ExceptionDetails* = nullptr);
102     JSC::JSValue evaluateInWorld(const ScriptSourceCode&, DOMWrapperWorld&, ExceptionDetails* = nullptr);
103
104     void loadModuleScriptInWorld(LoadableModuleScript&, const String& moduleName, Ref<ModuleFetchParameters>&&, DOMWrapperWorld&);
105     void loadModuleScript(LoadableModuleScript&, const String& moduleName, Ref<ModuleFetchParameters>&&);
106     void loadModuleScriptInWorld(LoadableModuleScript&, const ScriptSourceCode&, DOMWrapperWorld&);
107     void loadModuleScript(LoadableModuleScript&, const ScriptSourceCode&);
108
109     JSC::JSValue linkAndEvaluateModuleScriptInWorld(LoadableModuleScript& , DOMWrapperWorld&);
110     JSC::JSValue linkAndEvaluateModuleScript(LoadableModuleScript&);
111
112     JSC::JSValue evaluateModule(const URL&, JSC::JSModuleRecord&, DOMWrapperWorld&);
113     JSC::JSValue evaluateModule(const URL&, JSC::JSModuleRecord&);
114
115     WTF::TextPosition eventHandlerPosition() const;
116
117     void enableEval();
118     void enableWebAssembly();
119     void disableEval(const String& errorMessage);
120     void disableWebAssembly(const String& errorMessage);
121
122     static bool canAccessFromCurrentOrigin(Frame*);
123     WEBCORE_EXPORT bool canExecuteScripts(ReasonForCallingCanExecuteScripts);
124
125     void setPaused(bool b) { m_paused = b; }
126     bool isPaused() const { return m_paused; }
127
128     const String* sourceURL() const { return m_sourceURL; } // 0 if we are not evaluating any script
129
130     void updateDocument();
131
132     void namedItemAdded(HTMLDocument*, const AtomicString&) { }
133     void namedItemRemoved(HTMLDocument*, const AtomicString&) { }
134
135     void clearScriptObjects();
136     WEBCORE_EXPORT void cleanupScriptObjectsForPlugin(void*);
137
138     void updatePlatformScriptObjects();
139
140     RefPtr<JSC::Bindings::Instance>  createScriptInstanceForWidget(Widget*);
141     WEBCORE_EXPORT JSC::Bindings::RootObject* bindingRootObject();
142     JSC::Bindings::RootObject* cacheableBindingRootObject();
143     JSC::Bindings::RootObject* existingCacheableBindingRootObject() const { return m_cacheableBindingRootObject.get(); }
144
145     WEBCORE_EXPORT Ref<JSC::Bindings::RootObject> createRootObject(void* nativeHandle);
146
147     void collectIsolatedContexts(Vector<std::pair<JSC::ExecState*, SecurityOrigin*>>&);
148
149 #if PLATFORM(COCOA)
150     WEBCORE_EXPORT WebScriptObject* windowScriptObject();
151     WEBCORE_EXPORT JSContext *javaScriptContext();
152 #endif
153
154     WEBCORE_EXPORT JSC::JSObject* jsObjectForPluginElement(HTMLPlugInElement*);
155     
156 #if ENABLE(NETSCAPE_PLUGIN_API)
157     WEBCORE_EXPORT NPObject* windowScriptNPObject();
158 #endif
159
160     void initScriptForWindowProxy(JSWindowProxy&);
161
162 private:
163     void setupModuleScriptHandlers(LoadableModuleScript&, JSC::JSInternalPromise&, DOMWrapperWorld&);
164
165     void disconnectPlatformScriptObjects();
166
167     WEBCORE_EXPORT WindowProxy& windowProxy();
168     WEBCORE_EXPORT JSWindowProxy& jsWindowProxy(DOMWrapperWorld&);
169
170     Frame& m_frame;
171     const String* m_sourceURL;
172
173     bool m_paused;
174
175     // The root object used for objects bound outside the context of a plugin, such
176     // as NPAPI plugins. The plugins using these objects prevent a page from being cached so they
177     // are safe to invalidate() when WebKit navigates away from the page that contains them.
178     RefPtr<JSC::Bindings::RootObject> m_bindingRootObject;
179     // Unlike m_bindingRootObject these objects are used in pages that are cached, so they are not invalidate()'d.
180     // This ensures they are still available when the page is restored.
181     RefPtr<JSC::Bindings::RootObject> m_cacheableBindingRootObject;
182     RootObjectMap m_rootObjects;
183 #if ENABLE(NETSCAPE_PLUGIN_API)
184     NPObject* m_windowScriptNPObject;
185 #endif
186 #if PLATFORM(COCOA)
187     RetainPtr<WebScriptObject> m_windowScriptObject;
188 #endif
189 };
190
191 } // namespace WebCore