22bc4350b75ef21d248bfdca8da723a91defb4d6
[WebKit-https.git] / Source / WebCore / bindings / js / JSDOMWindowBase.cpp
1 /*
2  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2006 Jon Shier (jshier@iastate.edu)
4  *  Copyright (C) 2003-2017 Apple Inc. All rights reseved.
5  *  Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
6  *  Copyright (c) 2015 Canon Inc. All rights reserved.
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Lesser General Public
10  *  License as published by the Free Software Foundation; either
11  *  version 2 of the License, or (at your option) any later version.
12  *
13  *  This library is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  Lesser General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Lesser General Public
19  *  License along with this library; if not, write to the Free Software
20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
21  *  USA
22  */
23
24 #include "config.h"
25 #include "JSDOMWindowBase.h"
26
27 #include "ActiveDOMCallbackMicrotask.h"
28 #include "Chrome.h"
29 #include "CommonVM.h"
30 #include "DOMWindow.h"
31 #include "Document.h"
32 #include "Frame.h"
33 #include "InspectorController.h"
34 #include "JSDOMBindingSecurity.h"
35 #include "JSDOMGlobalObjectTask.h"
36 #include "JSDOMWindowCustom.h"
37 #include "JSMainThreadExecState.h"
38 #include "JSNode.h"
39 #include "Logging.h"
40 #include "Page.h"
41 #include "RejectedPromiseTracker.h"
42 #include "RuntimeApplicationChecks.h"
43 #include "ScriptController.h"
44 #include "ScriptModuleLoader.h"
45 #include "SecurityOrigin.h"
46 #include "Settings.h"
47 #include "WebCoreJSClientData.h"
48 #include <JavaScriptCore/CodeBlock.h>
49 #include <JavaScriptCore/JSInternalPromise.h>
50 #include <JavaScriptCore/JSInternalPromiseDeferred.h>
51 #include <JavaScriptCore/Microtask.h>
52 #include <JavaScriptCore/StrongInlines.h>
53 #include <wtf/Language.h>
54 #include <wtf/MainThread.h>
55
56 #if PLATFORM(IOS)
57 #include "ChromeClient.h"
58 #endif
59
60
61 namespace WebCore {
62 using namespace JSC;
63
64 const ClassInfo JSDOMWindowBase::s_info = { "Window", &JSDOMGlobalObject::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDOMWindowBase) };
65
66 const GlobalObjectMethodTable JSDOMWindowBase::s_globalObjectMethodTable = {
67     &supportsRichSourceInfo,
68     &shouldInterruptScript,
69     &javaScriptRuntimeFlags,
70     &queueTaskToEventLoop,
71     &shouldInterruptScriptBeforeTimeout,
72     &moduleLoaderImportModule,
73     &moduleLoaderResolve,
74     &moduleLoaderFetch,
75     &moduleLoaderCreateImportMetaProperties,
76     &moduleLoaderEvaluate,
77     &promiseRejectionTracker,
78     &defaultLanguage
79 };
80
81 JSDOMWindowBase::JSDOMWindowBase(VM& vm, Structure* structure, RefPtr<DOMWindow>&& window, JSDOMWindowProxy* proxy)
82     : JSDOMGlobalObject(vm, structure, proxy->world(), &s_globalObjectMethodTable)
83     , m_windowCloseWatchpoints((window && window->frame()) ? IsWatched : IsInvalidated)
84     , m_wrapped(WTFMove(window))
85     , m_proxy(proxy)
86 {
87 }
88
89 void JSDOMWindowBase::finishCreation(VM& vm, JSDOMWindowProxy* proxy)
90 {
91     Base::finishCreation(vm, proxy);
92     ASSERT(inherits(vm, info()));
93
94     auto& builtinNames = static_cast<JSVMClientData*>(vm.clientData)->builtinNames();
95
96     GlobalPropertyInfo staticGlobals[] = {
97         GlobalPropertyInfo(builtinNames.documentPublicName(), jsNull(), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
98         GlobalPropertyInfo(builtinNames.windowPublicName(), m_proxy, PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
99     };
100
101     addStaticGlobals(staticGlobals, WTF_ARRAY_LENGTH(staticGlobals));
102
103     if (m_wrapped && m_wrapped->frame() && m_wrapped->frame()->settings().needsSiteSpecificQuirks())
104         setNeedsSiteSpecificQuirks(true);
105 }
106
107 void JSDOMWindowBase::destroy(JSCell* cell)
108 {
109     static_cast<JSDOMWindowBase*>(cell)->JSDOMWindowBase::~JSDOMWindowBase();
110 }
111
112 void JSDOMWindowBase::updateDocument()
113 {
114     // Since "document" property is defined as { configurable: false, writable: false, enumerable: true },
115     // users cannot change its attributes further.
116     // Reaching here, the attributes of "document" property should be never changed.
117     ASSERT(m_wrapped->document());
118     ExecState* exec = globalExec();
119     bool shouldThrowReadOnlyError = false;
120     bool ignoreReadOnlyErrors = true;
121     bool putResult = false;
122     symbolTablePutTouchWatchpointSet(this, exec, static_cast<JSVMClientData*>(exec->vm().clientData)->builtinNames().documentPublicName(), toJS(exec, this, m_wrapped->document()), shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult);
123 }
124
125 ScriptExecutionContext* JSDOMWindowBase::scriptExecutionContext() const
126 {
127     return m_wrapped->document();
128 }
129
130 void JSDOMWindowBase::printErrorMessage(const String& message) const
131 {
132     printErrorMessageForFrame(wrapped().frame(), message);
133 }
134
135 bool JSDOMWindowBase::supportsRichSourceInfo(const JSGlobalObject* object)
136 {
137     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
138     Frame* frame = thisObject->wrapped().frame();
139     if (!frame)
140         return false;
141
142     Page* page = frame->page();
143     if (!page)
144         return false;
145
146     bool enabled = page->inspectorController().enabled();
147     ASSERT(enabled || !thisObject->debugger());
148     return enabled;
149 }
150
151 static inline bool shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(Page* page)
152 {
153     // See <rdar://problem/5479443>. We don't think that page can ever be NULL
154     // in this case, but if it is, we've gotten into a state where we may have
155     // hung the UI, with no way to ask the client whether to cancel execution.
156     // For now, our solution is just to cancel execution no matter what,
157     // ensuring that we never hang. We might want to consider other solutions
158     // if we discover problems with this one.
159     ASSERT(page);
160     return !page;
161 }
162
163 bool JSDOMWindowBase::shouldInterruptScript(const JSGlobalObject* object)
164 {
165     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
166     ASSERT(thisObject->wrapped().frame());
167     Page* page = thisObject->wrapped().frame()->page();
168     return shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(page);
169 }
170
171 bool JSDOMWindowBase::shouldInterruptScriptBeforeTimeout(const JSGlobalObject* object)
172 {
173     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
174     ASSERT(thisObject->wrapped().frame());
175     Page* page = thisObject->wrapped().frame()->page();
176
177     if (shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(page))
178         return true;
179
180 #if PLATFORM(IOS)
181     if (page->chrome().client().isStopping())
182         return true;
183 #endif
184
185     return JSGlobalObject::shouldInterruptScriptBeforeTimeout(object);
186 }
187
188 RuntimeFlags JSDOMWindowBase::javaScriptRuntimeFlags(const JSGlobalObject* object)
189 {
190     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
191     Frame* frame = thisObject->wrapped().frame();
192     if (!frame)
193         return RuntimeFlags();
194     return frame->settings().javaScriptRuntimeFlags();
195 }
196
197 class JSDOMWindowMicrotaskCallback : public RefCounted<JSDOMWindowMicrotaskCallback> {
198 public:
199     static Ref<JSDOMWindowMicrotaskCallback> create(JSDOMWindowBase& globalObject, Ref<JSC::Microtask>&& task)
200     {
201         return adoptRef(*new JSDOMWindowMicrotaskCallback(globalObject, WTFMove(task)));
202     }
203
204     void call()
205     {
206         Ref<JSDOMWindowMicrotaskCallback> protectedThis(*this);
207         VM& vm = m_globalObject->vm();
208         JSLockHolder lock(vm);
209         auto scope = DECLARE_THROW_SCOPE(vm);
210
211         ExecState* exec = m_globalObject->globalExec();
212
213         JSMainThreadExecState::runTask(exec, m_task);
214
215         scope.assertNoException();
216     }
217
218 private:
219     JSDOMWindowMicrotaskCallback(JSDOMWindowBase& globalObject, Ref<JSC::Microtask>&& task)
220         : m_globalObject { globalObject.vm(), &globalObject }
221         , m_task { WTFMove(task) }
222     {
223     }
224
225     Strong<JSDOMWindowBase> m_globalObject;
226     Ref<JSC::Microtask> m_task;
227 };
228
229 void JSDOMWindowBase::queueTaskToEventLoop(JSGlobalObject& object, Ref<JSC::Microtask>&& task)
230 {
231     JSDOMWindowBase& thisObject = static_cast<JSDOMWindowBase&>(object);
232
233     RefPtr<JSDOMWindowMicrotaskCallback> callback = JSDOMWindowMicrotaskCallback::create(thisObject, WTFMove(task));
234     auto microtask = std::make_unique<ActiveDOMCallbackMicrotask>(MicrotaskQueue::mainThreadQueue(), *thisObject.scriptExecutionContext(), [callback]() mutable {
235         callback->call();
236     });
237
238     MicrotaskQueue::mainThreadQueue().append(WTFMove(microtask));
239 }
240
241 void JSDOMWindowBase::willRemoveFromWindowProxy()
242 {
243     setCurrentEvent(0);
244 }
245
246 JSDOMWindowProxy* JSDOMWindowBase::proxy() const
247 {
248     return m_proxy;
249 }
250
251 // JSDOMGlobalObject* is ignored, accessing a window in any context will
252 // use that DOMWindow's prototype chain.
253 JSValue toJS(ExecState* state, JSDOMGlobalObject*, DOMWindow& domWindow)
254 {
255     return toJS(state, domWindow);
256 }
257
258 JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject*, Frame& frame)
259 {
260     return toJS(state, frame);
261 }
262
263 JSValue toJS(ExecState* state, DOMWindow& domWindow)
264 {
265     return toJS(state, domWindow.frame());
266 }
267
268 JSDOMWindow* toJSDOMWindow(Frame& frame, DOMWrapperWorld& world)
269 {
270     return frame.script().windowProxy(world)->window();
271 }
272
273 JSDOMWindow* toJSDOMWindow(JSC::VM& vm, JSValue value)
274 {
275     if (!value.isObject())
276         return nullptr;
277
278     while (!value.isNull()) {
279         JSObject* object = asObject(value);
280         const ClassInfo* classInfo = object->classInfo(vm);
281         if (classInfo == JSDOMWindow::info())
282             return jsCast<JSDOMWindow*>(object);
283         if (classInfo == JSDOMWindowProxy::info())
284             return jsCast<JSDOMWindowProxy*>(object)->window();
285         value = object->getPrototypeDirect(vm);
286     }
287     return nullptr;
288 }
289
290 DOMWindow& incumbentDOMWindow(ExecState& state)
291 {
292     return asJSDOMWindow(&callerGlobalObject(state))->wrapped();
293 }
294
295 DOMWindow& activeDOMWindow(ExecState& state)
296 {
297     return asJSDOMWindow(state.lexicalGlobalObject())->wrapped();
298 }
299
300 DOMWindow& firstDOMWindow(ExecState& state)
301 {
302     return asJSDOMWindow(state.vmEntryGlobalObject())->wrapped();
303 }
304
305 Document* responsibleDocument(ExecState& state)
306 {
307     CallerFunctor functor;
308     state.iterate(functor);
309     auto* callerFrame = functor.callerFrame();
310     if (!callerFrame)
311         return nullptr;
312     return asJSDOMWindow(callerFrame->lexicalGlobalObject())->wrapped().document();
313 }
314
315 void JSDOMWindowBase::fireFrameClearedWatchpointsForWindow(DOMWindow* window)
316 {
317     JSC::VM& vm = commonVM();
318     JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData);
319     Vector<Ref<DOMWrapperWorld>> wrapperWorlds;
320     clientData->getAllWorlds(wrapperWorlds);
321     for (unsigned i = 0; i < wrapperWorlds.size(); ++i) {
322         auto& wrappers = wrapperWorlds[i]->wrappers();
323         auto result = wrappers.find(window);
324         if (result == wrappers.end())
325             continue;
326         JSC::JSObject* wrapper = result->value.get();
327         if (!wrapper)
328             continue;
329         JSDOMWindowBase* jsWindow = JSC::jsCast<JSDOMWindowBase*>(wrapper);
330         jsWindow->m_windowCloseWatchpoints.fireAll(vm, "Frame cleared");
331     }
332 }
333
334 JSC::Identifier JSDOMWindowBase::moduleLoaderResolve(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleName, JSC::JSValue importerModuleKey, JSC::JSValue scriptFetcher)
335 {
336     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
337     if (RefPtr<Document> document = thisObject->wrapped().document())
338         return document->moduleLoader()->resolve(globalObject, exec, moduleLoader, moduleName, importerModuleKey, scriptFetcher);
339     return { };
340 }
341
342 JSC::JSInternalPromise* JSDOMWindowBase::moduleLoaderFetch(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSValue parameters, JSC::JSValue scriptFetcher)
343 {
344     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
345     if (RefPtr<Document> document = thisObject->wrapped().document())
346         return document->moduleLoader()->fetch(globalObject, exec, moduleLoader, moduleKey, parameters, scriptFetcher);
347     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
348     return deferred->reject(exec, jsUndefined());
349 }
350
351 JSC::JSValue JSDOMWindowBase::moduleLoaderEvaluate(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSValue moduleRecord, JSC::JSValue scriptFetcher)
352 {
353     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
354     if (RefPtr<Document> document = thisObject->wrapped().document())
355         return document->moduleLoader()->evaluate(globalObject, exec, moduleLoader, moduleKey, moduleRecord, scriptFetcher);
356     return JSC::jsUndefined();
357 }
358
359 JSC::JSInternalPromise* JSDOMWindowBase::moduleLoaderImportModule(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSString* moduleName, JSC::JSValue parameters, const JSC::SourceOrigin& sourceOrigin)
360 {
361     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
362     if (RefPtr<Document> document = thisObject->wrapped().document())
363         return document->moduleLoader()->importModule(globalObject, exec, moduleLoader, moduleName, parameters, sourceOrigin);
364     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
365     return deferred->reject(exec, jsUndefined());
366 }
367
368 JSC::JSObject* JSDOMWindowBase::moduleLoaderCreateImportMetaProperties(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSModuleRecord* moduleRecord, JSC::JSValue scriptFetcher)
369 {
370     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
371     if (RefPtr<Document> document = thisObject->wrapped().document())
372         return document->moduleLoader()->createImportMetaProperties(globalObject, exec, moduleLoader, moduleKey, moduleRecord, scriptFetcher);
373     return constructEmptyObject(exec, globalObject->nullPrototypeObjectStructure());
374 }
375
376 void JSDOMWindowBase::promiseRejectionTracker(JSGlobalObject* jsGlobalObject, ExecState* exec, JSPromise* promise, JSPromiseRejectionOperation operation)
377 {
378     // https://html.spec.whatwg.org/multipage/webappapis.html#the-hostpromiserejectiontracker-implementation
379
380     VM& vm = exec->vm();
381     auto& globalObject = *JSC::jsCast<JSDOMWindowBase*>(jsGlobalObject);
382     auto* context = globalObject.scriptExecutionContext();
383     if (!context)
384         return;
385
386     // InternalPromises should not be exposed to user scripts.
387     if (JSC::jsDynamicCast<JSC::JSInternalPromise*>(vm, promise))
388         return;
389
390     // FIXME: If script has muted errors (cross origin), terminate these steps.
391     // <https://webkit.org/b/171415> Implement the `muted-errors` property of Scripts to avoid onerror/onunhandledrejection for cross-origin scripts
392
393     switch (operation) {
394     case JSPromiseRejectionOperation::Reject:
395         context->ensureRejectedPromiseTracker().promiseRejected(*exec, globalObject, *promise);
396         break;
397     case JSPromiseRejectionOperation::Handle:
398         context->ensureRejectedPromiseTracker().promiseHandled(*exec, globalObject, *promise);
399         break;
400     }
401 }
402
403 } // namespace WebCore