[LFC][Floats] FloatAvoider does not need to keep a pointer to Layout::Box around.
[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-2019 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 "SerializedScriptValue.h"
27 #include "WindowProxy.h"
28 #include <JavaScriptCore/JSBase.h>
29 #include <JavaScriptCore/Strong.h>
30 #include <wtf/Forward.h>
31 #include <wtf/Optional.h>
32 #include <wtf/RefPtr.h>
33 #include <wtf/WeakPtr.h>
34 #include <wtf/text/TextPosition.h>
35
36 #if PLATFORM(COCOA)
37 #include <wtf/RetainPtr.h>
38 OBJC_CLASS JSContext;
39 OBJC_CLASS WebScriptObject;
40 #endif
41
42 struct NPObject;
43
44 namespace JSC {
45 class CallFrame;
46 class JSGlobalObject;
47 class JSInternalPromise;
48 class JSModuleRecord;
49
50 namespace Bindings {
51 class Instance;
52 class RootObject;
53 }
54 }
55
56 namespace WebCore {
57
58 class CachedScriptFetcher;
59 class Frame;
60 class HTMLDocument;
61 class HTMLPlugInElement;
62 class LoadableModuleScript;
63 class ModuleFetchParameters;
64 class ScriptSourceCode;
65 class SecurityOrigin;
66 class Widget;
67
68 enum class RunAsAsyncFunction : bool;
69
70 struct ExceptionDetails;
71 struct RunJavaScriptParameters;
72
73 enum ReasonForCallingCanExecuteScripts {
74     AboutToCreateEventListener,
75     AboutToExecuteScript,
76     NotAboutToExecuteScript
77 };
78
79 using ValueOrException = Expected<JSC::JSValue, ExceptionDetails>;
80
81 class ScriptController : public CanMakeWeakPtr<ScriptController> {
82     WTF_MAKE_FAST_ALLOCATED;
83
84     using RootObjectMap = HashMap<void*, Ref<JSC::Bindings::RootObject>>;
85
86 public:
87     explicit ScriptController(Frame&);
88     ~ScriptController();
89
90     enum class WorldType { User, Internal };
91     WEBCORE_EXPORT static Ref<DOMWrapperWorld> createWorld(const String& name, WorldType = WorldType::Internal);
92
93     JSDOMWindow* globalObject(DOMWrapperWorld& world)
94     {
95         return JSC::jsCast<JSDOMWindow*>(jsWindowProxy(world).window());
96     }
97
98     static void getAllWorlds(Vector<Ref<DOMWrapperWorld>>&);
99
100     using ResolveFunction = CompletionHandler<void(ValueOrException)>;
101
102     WEBCORE_EXPORT JSC::JSValue executeScriptIgnoringException(const String& script, bool forceUserGesture = false);
103     WEBCORE_EXPORT JSC::JSValue executeScriptInWorldIgnoringException(DOMWrapperWorld&, const String& script, bool forceUserGesture = false);
104     WEBCORE_EXPORT JSC::JSValue executeUserAgentScriptInWorldIgnoringException(DOMWrapperWorld&, const String& script, bool forceUserGesture);
105     WEBCORE_EXPORT ValueOrException executeUserAgentScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture);
106     WEBCORE_EXPORT void executeAsynchronousUserAgentScriptInWorld(DOMWrapperWorld&, RunJavaScriptParameters&&, ResolveFunction&&);
107     JSC::JSValue evaluateIgnoringException(const ScriptSourceCode&);
108     JSC::JSValue evaluateInWorldIgnoringException(const ScriptSourceCode&, DOMWrapperWorld&);
109
110     Expected<void, ExceptionDetails> shouldAllowUserAgentScripts(Document&) const;
111
112     // This asserts that URL argument is a JavaScript URL.
113     void executeJavaScriptURL(const URL&, RefPtr<SecurityOrigin> = nullptr, ShouldReplaceDocumentIfJavaScriptURL = ReplaceDocumentIfJavaScriptURL);
114
115     static void initializeMainThread();
116
117     void loadModuleScriptInWorld(LoadableModuleScript&, const String& moduleName, Ref<ModuleFetchParameters>&&, DOMWrapperWorld&);
118     void loadModuleScript(LoadableModuleScript&, const String& moduleName, Ref<ModuleFetchParameters>&&);
119     void loadModuleScriptInWorld(LoadableModuleScript&, const ScriptSourceCode&, DOMWrapperWorld&);
120     void loadModuleScript(LoadableModuleScript&, const ScriptSourceCode&);
121
122     JSC::JSValue linkAndEvaluateModuleScriptInWorld(LoadableModuleScript& , DOMWrapperWorld&);
123     JSC::JSValue linkAndEvaluateModuleScript(LoadableModuleScript&);
124
125     JSC::JSValue evaluateModule(const URL&, JSC::JSModuleRecord&, DOMWrapperWorld&);
126     JSC::JSValue evaluateModule(const URL&, JSC::JSModuleRecord&);
127
128     WTF::TextPosition eventHandlerPosition() const;
129
130     void enableEval();
131     void enableWebAssembly();
132     void disableEval(const String& errorMessage);
133     void disableWebAssembly(const String& errorMessage);
134
135     static bool canAccessFromCurrentOrigin(Frame*, Document& accessingDocument);
136     WEBCORE_EXPORT bool canExecuteScripts(ReasonForCallingCanExecuteScripts);
137
138     void setPaused(bool b) { m_paused = b; }
139     bool isPaused() const { return m_paused; }
140
141     const URL* sourceURL() const { return m_sourceURL; } // nullptr if we are not evaluating any script
142
143     void updateDocument();
144
145     void namedItemAdded(HTMLDocument*, const AtomString&) { }
146     void namedItemRemoved(HTMLDocument*, const AtomString&) { }
147
148     void clearScriptObjects();
149     WEBCORE_EXPORT void cleanupScriptObjectsForPlugin(void*);
150
151     void updatePlatformScriptObjects();
152
153     RefPtr<JSC::Bindings::Instance>  createScriptInstanceForWidget(Widget*);
154     WEBCORE_EXPORT JSC::Bindings::RootObject* bindingRootObject();
155     JSC::Bindings::RootObject* cacheableBindingRootObject();
156     JSC::Bindings::RootObject* existingCacheableBindingRootObject() const { return m_cacheableBindingRootObject.get(); }
157
158     WEBCORE_EXPORT Ref<JSC::Bindings::RootObject> createRootObject(void* nativeHandle);
159
160     void collectIsolatedContexts(Vector<std::pair<JSC::JSGlobalObject*, SecurityOrigin*>>&);
161
162 #if PLATFORM(COCOA)
163     WEBCORE_EXPORT WebScriptObject* windowScriptObject();
164     WEBCORE_EXPORT JSContext *javaScriptContext();
165 #endif
166
167     WEBCORE_EXPORT JSC::JSObject* jsObjectForPluginElement(HTMLPlugInElement*);
168     
169 #if ENABLE(NETSCAPE_PLUGIN_API)
170     WEBCORE_EXPORT NPObject* windowScriptNPObject();
171 #endif
172
173     void initScriptForWindowProxy(JSWindowProxy&);
174
175     bool willReplaceWithResultOfExecutingJavascriptURL() const { return m_willReplaceWithResultOfExecutingJavascriptURL; }
176
177 private:
178     ValueOrException executeUserAgentScriptInWorldInternal(DOMWrapperWorld&, RunJavaScriptParameters&&);
179     ValueOrException executeScriptInWorld(DOMWrapperWorld&, RunJavaScriptParameters&&);
180     ValueOrException evaluateInWorld(const ScriptSourceCode&, DOMWrapperWorld&);
181     ValueOrException callInWorld(RunJavaScriptParameters&&, DOMWrapperWorld&);
182     
183     void setupModuleScriptHandlers(LoadableModuleScript&, JSC::JSInternalPromise&, DOMWrapperWorld&);
184
185     void disconnectPlatformScriptObjects();
186
187     WEBCORE_EXPORT WindowProxy& windowProxy();
188     WEBCORE_EXPORT JSWindowProxy& jsWindowProxy(DOMWrapperWorld&);
189
190     Frame& m_frame;
191     const URL* m_sourceURL { nullptr };
192
193     bool m_paused;
194     bool m_willReplaceWithResultOfExecutingJavascriptURL { false };
195
196     // The root object used for objects bound outside the context of a plugin, such
197     // as NPAPI plugins. The plugins using these objects prevent a page from being cached so they
198     // are safe to invalidate() when WebKit navigates away from the page that contains them.
199     RefPtr<JSC::Bindings::RootObject> m_bindingRootObject;
200     // Unlike m_bindingRootObject these objects are used in pages that are cached, so they are not invalidate()'d.
201     // This ensures they are still available when the page is restored.
202     RefPtr<JSC::Bindings::RootObject> m_cacheableBindingRootObject;
203     RootObjectMap m_rootObjects;
204 #if ENABLE(NETSCAPE_PLUGIN_API)
205     NPObject* m_windowScriptNPObject;
206 #endif
207 #if PLATFORM(COCOA)
208     RetainPtr<WebScriptObject> m_windowScriptObject;
209 #endif
210 };
211
212 } // namespace WebCore