Move vmEntryGlobalObject() to VM from CallFrame.
[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 "FetchResponse.h"
33 #include "Frame.h"
34 #include "InspectorController.h"
35 #include "JSDOMBindingSecurity.h"
36 #include "JSDOMGlobalObjectTask.h"
37 #include "JSDOMWindowCustom.h"
38 #include "JSFetchResponse.h"
39 #include "JSMicrotaskCallback.h"
40 #include "JSNode.h"
41 #include "Logging.h"
42 #include "Page.h"
43 #include "RejectedPromiseTracker.h"
44 #include "RuntimeApplicationChecks.h"
45 #include "ScriptController.h"
46 #include "ScriptModuleLoader.h"
47 #include "SecurityOrigin.h"
48 #include "Settings.h"
49 #include "WebCoreJSClientData.h"
50 #include <JavaScriptCore/CodeBlock.h>
51 #include <JavaScriptCore/JSInternalPromise.h>
52 #include <JavaScriptCore/JSInternalPromiseDeferred.h>
53 #include <JavaScriptCore/Microtask.h>
54 #include <JavaScriptCore/PromiseDeferredTimer.h>
55 #include <JavaScriptCore/StrongInlines.h>
56 #include <JavaScriptCore/WebAssemblyPrototype.h>
57 #include <wtf/Language.h>
58 #include <wtf/MainThread.h>
59
60 #if PLATFORM(IOS)
61 #include "ChromeClient.h"
62 #endif
63
64
65 namespace WebCore {
66 using namespace JSC;
67
68 const ClassInfo JSDOMWindowBase::s_info = { "Window", &JSDOMGlobalObject::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDOMWindowBase) };
69
70 const GlobalObjectMethodTable JSDOMWindowBase::s_globalObjectMethodTable = {
71     &supportsRichSourceInfo,
72     &shouldInterruptScript,
73     &javaScriptRuntimeFlags,
74     &queueTaskToEventLoop,
75     &shouldInterruptScriptBeforeTimeout,
76     &moduleLoaderImportModule,
77     &moduleLoaderResolve,
78     &moduleLoaderFetch,
79     &moduleLoaderCreateImportMetaProperties,
80     &moduleLoaderEvaluate,
81     &promiseRejectionTracker,
82     &defaultLanguage,
83 #if ENABLE(WEBASSEMBLY)
84     &compileStreaming,
85     &instantiateStreaming,
86 #else
87     nullptr,
88     nullptr,
89 #endif
90 };
91
92 JSDOMWindowBase::JSDOMWindowBase(VM& vm, Structure* structure, RefPtr<DOMWindow>&& window, JSWindowProxy* proxy)
93     : JSDOMGlobalObject(vm, structure, proxy->world(), &s_globalObjectMethodTable)
94     , m_windowCloseWatchpoints((window && window->frame()) ? IsWatched : IsInvalidated)
95     , m_wrapped(WTFMove(window))
96     , m_proxy(proxy)
97 {
98 }
99
100 void JSDOMWindowBase::finishCreation(VM& vm, JSWindowProxy* proxy)
101 {
102     Base::finishCreation(vm, proxy);
103     ASSERT(inherits(vm, info()));
104
105     auto& builtinNames = static_cast<JSVMClientData*>(vm.clientData)->builtinNames();
106
107     GlobalPropertyInfo staticGlobals[] = {
108         GlobalPropertyInfo(builtinNames.documentPublicName(), jsNull(), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
109         GlobalPropertyInfo(builtinNames.windowPublicName(), m_proxy, PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
110     };
111
112     addStaticGlobals(staticGlobals, WTF_ARRAY_LENGTH(staticGlobals));
113
114     if (m_wrapped && m_wrapped->frame() && m_wrapped->frame()->settings().needsSiteSpecificQuirks())
115         setNeedsSiteSpecificQuirks(true);
116 }
117
118 void JSDOMWindowBase::destroy(JSCell* cell)
119 {
120     static_cast<JSDOMWindowBase*>(cell)->JSDOMWindowBase::~JSDOMWindowBase();
121 }
122
123 void JSDOMWindowBase::updateDocument()
124 {
125     // Since "document" property is defined as { configurable: false, writable: false, enumerable: true },
126     // users cannot change its attributes further.
127     // Reaching here, the attributes of "document" property should be never changed.
128     ASSERT(m_wrapped->document());
129     ExecState* exec = globalExec();
130     bool shouldThrowReadOnlyError = false;
131     bool ignoreReadOnlyErrors = true;
132     bool putResult = false;
133     symbolTablePutTouchWatchpointSet(this, exec, static_cast<JSVMClientData*>(exec->vm().clientData)->builtinNames().documentPublicName(), toJS(exec, this, m_wrapped->document()), shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult);
134 }
135
136 ScriptExecutionContext* JSDOMWindowBase::scriptExecutionContext() const
137 {
138     return m_wrapped->document();
139 }
140
141 void JSDOMWindowBase::printErrorMessage(const String& message) const
142 {
143     printErrorMessageForFrame(wrapped().frame(), message);
144 }
145
146 bool JSDOMWindowBase::supportsRichSourceInfo(const JSGlobalObject* object)
147 {
148     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
149     Frame* frame = thisObject->wrapped().frame();
150     if (!frame)
151         return false;
152
153     Page* page = frame->page();
154     if (!page)
155         return false;
156
157     bool enabled = page->inspectorController().enabled();
158     ASSERT(enabled || !thisObject->debugger());
159     return enabled;
160 }
161
162 static inline bool shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(Page* page)
163 {
164     // See <rdar://problem/5479443>. We don't think that page can ever be NULL
165     // in this case, but if it is, we've gotten into a state where we may have
166     // hung the UI, with no way to ask the client whether to cancel execution.
167     // For now, our solution is just to cancel execution no matter what,
168     // ensuring that we never hang. We might want to consider other solutions
169     // if we discover problems with this one.
170     ASSERT(page);
171     return !page;
172 }
173
174 bool JSDOMWindowBase::shouldInterruptScript(const JSGlobalObject* object)
175 {
176     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
177     ASSERT(thisObject->wrapped().frame());
178     Page* page = thisObject->wrapped().frame()->page();
179     return shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(page);
180 }
181
182 bool JSDOMWindowBase::shouldInterruptScriptBeforeTimeout(const JSGlobalObject* object)
183 {
184     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
185     ASSERT(thisObject->wrapped().frame());
186     Page* page = thisObject->wrapped().frame()->page();
187
188     if (shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(page))
189         return true;
190
191 #if PLATFORM(IOS)
192     if (page->chrome().client().isStopping())
193         return true;
194 #endif
195
196     return JSGlobalObject::shouldInterruptScriptBeforeTimeout(object);
197 }
198
199 RuntimeFlags JSDOMWindowBase::javaScriptRuntimeFlags(const JSGlobalObject* object)
200 {
201     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
202     Frame* frame = thisObject->wrapped().frame();
203     if (!frame)
204         return RuntimeFlags();
205     return frame->settings().javaScriptRuntimeFlags();
206 }
207
208 void JSDOMWindowBase::queueTaskToEventLoop(JSGlobalObject& object, Ref<JSC::Microtask>&& task)
209 {
210     JSDOMWindowBase& thisObject = static_cast<JSDOMWindowBase&>(object);
211
212     RefPtr<JSMicrotaskCallback> callback = JSMicrotaskCallback::create(thisObject, WTFMove(task));
213     auto microtask = std::make_unique<ActiveDOMCallbackMicrotask>(MicrotaskQueue::mainThreadQueue(), *thisObject.scriptExecutionContext(), [callback]() mutable {
214         callback->call();
215     });
216
217     MicrotaskQueue::mainThreadQueue().append(WTFMove(microtask));
218 }
219
220 void JSDOMWindowBase::willRemoveFromWindowProxy()
221 {
222     setCurrentEvent(0);
223 }
224
225 JSWindowProxy* JSDOMWindowBase::proxy() const
226 {
227     return m_proxy;
228 }
229
230 JSValue toJS(ExecState* state, DOMWindow& domWindow)
231 {
232     auto* frame = domWindow.frame();
233     if (!frame)
234         return jsNull();
235     return toJS(state, frame->windowProxy());
236 }
237
238 JSDOMWindow* toJSDOMWindow(Frame& frame, DOMWrapperWorld& world)
239 {
240     return frame.script().globalObject(world);
241 }
242
243 JSDOMWindow* toJSDOMWindow(JSC::VM& vm, JSValue value)
244 {
245     if (!value.isObject())
246         return nullptr;
247
248     while (!value.isNull()) {
249         JSObject* object = asObject(value);
250         const ClassInfo* classInfo = object->classInfo(vm);
251         if (classInfo == JSDOMWindow::info())
252             return jsCast<JSDOMWindow*>(object);
253         if (classInfo == JSWindowProxy::info())
254             return jsDynamicCast<JSDOMWindow*>(vm, jsCast<JSWindowProxy*>(object)->window());
255         value = object->getPrototypeDirect(vm);
256     }
257     return nullptr;
258 }
259
260 DOMWindow& incumbentDOMWindow(ExecState& state)
261 {
262     return asJSDOMWindow(&callerGlobalObject(state))->wrapped();
263 }
264
265 DOMWindow& activeDOMWindow(ExecState& state)
266 {
267     return asJSDOMWindow(state.lexicalGlobalObject())->wrapped();
268 }
269
270 DOMWindow& firstDOMWindow(ExecState& state)
271 {
272     VM& vm = state.vm();
273     return asJSDOMWindow(vm.vmEntryGlobalObject(&state))->wrapped();
274 }
275
276 Document* responsibleDocument(ExecState& state)
277 {
278     CallerFunctor functor;
279     state.iterate(functor);
280     auto* callerFrame = functor.callerFrame();
281     if (!callerFrame)
282         return nullptr;
283     return asJSDOMWindow(callerFrame->lexicalGlobalObject())->wrapped().document();
284 }
285
286 void JSDOMWindowBase::fireFrameClearedWatchpointsForWindow(DOMWindow* window)
287 {
288     JSC::VM& vm = commonVM();
289     JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData);
290     Vector<Ref<DOMWrapperWorld>> wrapperWorlds;
291     clientData->getAllWorlds(wrapperWorlds);
292     for (unsigned i = 0; i < wrapperWorlds.size(); ++i) {
293         auto& wrappers = wrapperWorlds[i]->wrappers();
294         auto result = wrappers.find(window);
295         if (result == wrappers.end())
296             continue;
297         JSC::JSObject* wrapper = result->value.get();
298         if (!wrapper)
299             continue;
300         JSDOMWindowBase* jsWindow = JSC::jsCast<JSDOMWindowBase*>(wrapper);
301         jsWindow->m_windowCloseWatchpoints.fireAll(vm, "Frame cleared");
302     }
303 }
304
305 JSC::Identifier JSDOMWindowBase::moduleLoaderResolve(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleName, JSC::JSValue importerModuleKey, JSC::JSValue scriptFetcher)
306 {
307     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
308     if (RefPtr<Document> document = thisObject->wrapped().document())
309         return document->moduleLoader()->resolve(globalObject, exec, moduleLoader, moduleName, importerModuleKey, scriptFetcher);
310     return { };
311 }
312
313 JSC::JSInternalPromise* JSDOMWindowBase::moduleLoaderFetch(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSValue parameters, JSC::JSValue scriptFetcher)
314 {
315     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
316     if (RefPtr<Document> document = thisObject->wrapped().document())
317         return document->moduleLoader()->fetch(globalObject, exec, moduleLoader, moduleKey, parameters, scriptFetcher);
318     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
319     return deferred->reject(exec, jsUndefined());
320 }
321
322 JSC::JSValue JSDOMWindowBase::moduleLoaderEvaluate(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSValue moduleRecord, JSC::JSValue scriptFetcher)
323 {
324     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
325     if (RefPtr<Document> document = thisObject->wrapped().document())
326         return document->moduleLoader()->evaluate(globalObject, exec, moduleLoader, moduleKey, moduleRecord, scriptFetcher);
327     return JSC::jsUndefined();
328 }
329
330 JSC::JSInternalPromise* JSDOMWindowBase::moduleLoaderImportModule(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSString* moduleName, JSC::JSValue parameters, const JSC::SourceOrigin& sourceOrigin)
331 {
332     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
333     if (RefPtr<Document> document = thisObject->wrapped().document())
334         return document->moduleLoader()->importModule(globalObject, exec, moduleLoader, moduleName, parameters, sourceOrigin);
335     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
336     return deferred->reject(exec, jsUndefined());
337 }
338
339 JSC::JSObject* JSDOMWindowBase::moduleLoaderCreateImportMetaProperties(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSModuleRecord* moduleRecord, JSC::JSValue scriptFetcher)
340 {
341     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
342     if (RefPtr<Document> document = thisObject->wrapped().document())
343         return document->moduleLoader()->createImportMetaProperties(globalObject, exec, moduleLoader, moduleKey, moduleRecord, scriptFetcher);
344     return constructEmptyObject(exec, globalObject->nullPrototypeObjectStructure());
345 }
346
347 #if ENABLE(WEBASSEMBLY)
348 static std::optional<Vector<uint8_t>> tryAllocate(JSC::ExecState* exec, JSC::JSPromiseDeferred* promise, const char* data, size_t byteSize)
349 {
350     Vector<uint8_t> arrayBuffer;
351     if (!arrayBuffer.tryReserveCapacity(byteSize)) {
352         promise->reject(exec, createOutOfMemoryError(exec));
353         return std::nullopt;
354     }
355
356     arrayBuffer.grow(byteSize);
357     memcpy(arrayBuffer.data(), data, byteSize);
358
359     return arrayBuffer;
360 }
361
362 static bool isResponseCorrect(JSC::ExecState* exec, FetchResponse* inputResponse, JSC::JSPromiseDeferred* promise)
363 {
364     bool isResponseCorsSameOrigin = inputResponse->type() == ResourceResponse::Type::Basic || inputResponse->type() == ResourceResponse::Type::Cors || inputResponse->type() == ResourceResponse::Type::Default;
365
366     if (!isResponseCorsSameOrigin) {
367         promise->reject(exec, createTypeError(exec, "Response is not CORS-same-origin"_s));
368         return false;
369     }
370
371     if (!inputResponse->ok()) {
372         promise->reject(exec, createTypeError(exec, "Response has not returned OK status"_s));
373         return false;
374     }
375
376     auto contentType = inputResponse->headers().fastGet(HTTPHeaderName::ContentType);
377     if (!equalLettersIgnoringASCIICase(contentType, "application/wasm")) {
378         promise->reject(exec, createTypeError(exec, "Unexpected response MIME type. Expected 'application/wasm'"_s));
379         return false;
380     }
381
382     return true;
383 }
384
385 static void handleResponseOnStreamingAction(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, FetchResponse* inputResponse, JSC::JSPromiseDeferred* promise, Function<void(JSC::ExecState* exec, const char* data, size_t byteSize)>&& actionCallback)
386 {
387     if (!isResponseCorrect(exec, inputResponse, promise))
388         return;
389
390     if (inputResponse->isBodyReceivedByChunk()) {
391         inputResponse->consumeBodyReceivedByChunk([promise, callback = WTFMove(actionCallback), globalObject, data = SharedBuffer::create()] (auto&& result) mutable {
392             ExecState* exec = globalObject->globalExec();
393             if (result.hasException()) {
394                 promise->reject(exec, createTypeError(exec, result.exception().message()));
395                 return;
396             }
397
398             if (auto chunk = result.returnValue())
399                 data->append(reinterpret_cast<const char*>(chunk->data), chunk->size);
400             else {
401                 VM& vm = exec->vm();
402                 JSLockHolder lock(vm);
403
404                 callback(exec, data->data(), data->size());
405             }
406         });
407         return;
408     }
409
410     auto body = inputResponse->consumeBody();
411     WTF::switchOn(body, [&] (Ref<FormData>& formData) {
412         if (auto buffer = formData->asSharedBuffer()) {
413             VM& vm = exec->vm();
414             JSLockHolder lock(vm);
415
416             actionCallback(exec, buffer->data(), buffer->size());
417             return;
418         }
419         // FIXME: http://webkit.org/b/184886> Implement loading for the Blob type
420         promise->reject(exec, createTypeError(exec, "Unexpected Response's Content-type"_s));
421     }, [&] (Ref<SharedBuffer>& buffer) {
422         VM& vm = exec->vm();
423         JSLockHolder lock(vm);
424
425         actionCallback(exec, buffer->data(), buffer->size());
426     }, [&] (std::nullptr_t&) {
427         promise->reject(exec, createTypeError(exec, "Unexpected Response's Content-type"_s));
428     });
429 }
430
431 void JSDOMWindowBase::compileStreaming(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSPromiseDeferred* promise, JSC::JSValue source)
432 {
433     ASSERT(source);
434
435     VM& vm = exec->vm();
436
437     ASSERT(vm.promiseDeferredTimer->hasPendingPromise(promise));
438     ASSERT(vm.promiseDeferredTimer->hasDependancyInPendingPromise(promise, globalObject));
439
440     if (auto inputResponse = JSFetchResponse::toWrapped(vm, source)) {
441         handleResponseOnStreamingAction(globalObject, exec, inputResponse, promise, [promise] (JSC::ExecState* exec, const char* data, size_t byteSize) mutable {
442             if (auto arrayBuffer = tryAllocate(exec, promise, data, byteSize))
443                 JSC::WebAssemblyPrototype::webAssemblyModuleValidateAsync(exec, promise, WTFMove(*arrayBuffer));
444         });
445     } else
446         promise->reject(exec, createTypeError(exec, "first argument must be an Response or Promise for Response"_s));
447 }
448
449 void JSDOMWindowBase::instantiateStreaming(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSPromiseDeferred* promise, JSC::JSValue source, JSC::JSObject* importedObject)
450 {
451     ASSERT(source);
452
453     VM& vm = exec->vm();
454
455     ASSERT(vm.promiseDeferredTimer->hasPendingPromise(promise));
456     ASSERT(vm.promiseDeferredTimer->hasDependancyInPendingPromise(promise, globalObject));
457     ASSERT(vm.promiseDeferredTimer->hasDependancyInPendingPromise(promise, importedObject));
458
459     if (auto inputResponse = JSFetchResponse::toWrapped(vm, source)) {
460         handleResponseOnStreamingAction(globalObject, exec, inputResponse, promise, [promise, importedObject] (JSC::ExecState* exec, const char* data, size_t byteSize) mutable {
461             if (auto arrayBuffer = tryAllocate(exec, promise, data, byteSize))
462                 JSC::WebAssemblyPrototype::webAssemblyModuleInstantinateAsync(exec, promise, WTFMove(*arrayBuffer), importedObject);
463         });
464     } else
465         promise->reject(exec, createTypeError(exec, "first argument must be an Response or Promise for Response"_s));
466 }
467 #endif
468
469 } // namespace WebCore